Spring AOP及整合Mybatis

来源:https://www.cnblogs.com/wyh518/archive/2023/02/18/17132731.html
-Advertisement-
Play Games

代理模式 為什麼要學習代理模式，因為AOP的底層機制就是動態代理！ 代理模式： 靜態代理 動態代理 學習aop之前 , 我們要先瞭解一下代理模式！ 1、靜態代理 靜態代理角色分析 抽象角色 : 一般使用介面或者抽象類來實現 真實角色 : 被代理的角色 代理角色 : 代理真實角色 ; 代理真實角色後 ...


代理模式

為什麼要學習代理模式，因為AOP的底層機制就是動態代理！

代理模式：

  • 靜態代理
  • 動態代理

學習aop之前 , 我們要先瞭解一下代理模式！

 

 1、靜態代理

靜態代理角色分析

  • 抽象角色 : 一般使用介面或者抽象類來實現
  • 真實角色 : 被代理的角色
  • 代理角色 : 代理真實角色 ; 代理真實角色後 , 一般會做一些附屬的操作 .
  • 客戶 : 使用代理角色來進行一些操作 .

代碼實現

Rent . java 即抽象角色

//抽象角色：租房
public interface Rent {
　　public void rent();
}

Host . java 即真實角色

//真實角色: 房東，房東要出租房子
public class Host implements Rent{
　　public void rent() {
　　　　System.out.println("房屋出租");
　　}
}

Proxy . java 即代理角色

//代理角色：中介
public class Proxy implements Rent {
　　private Host host;

　　public Proxy() { }
　　public Proxy(Host host) {
　　　　this.host = host;
　　}
　　//租房
　　public void rent(){
　　　　seeHouse();
　　　　host.rent();
　　　　fare();
　　}
　　//看房
　　public void seeHouse(){
　　　　System.out.println("帶房客看房");
　　}
　　//收中介費
　　public void fare(){
　　　　System.out.println("收中介費");
　　}
}

Client . java 即客戶

//客戶類，一般客戶都會去找代理！
public class Client {
    public static void main(String[] args) {
        //房東要租房
        Host host = new Host();
        //中介幫助房東
        Proxy proxy = new Proxy(host);
        //你去找中介！
        proxy.rent();
    }
}

分析： 在這個過程中，你直接接觸的就是中介，就如同現實生活中的樣子，你看不到房東，但是你依舊 租到了房東的房子通過代理，這就是所謂的代理模式，程式源自於生活，所以學編程的人，一般能夠更 加抽象的看待生活中發生的事情。

2、靜態代理的好處

  • 可以使得我們的真實角色更加純粹 . 不再去關註一些公共的事情 .
  • 公共的業務由代理來完成 . 實現了業務的分工 ,
  • 公共業務發生擴展時變得更加集中和方便 .

缺點 :

  • 類多了 , 多了代理類 , 工作量變大了 . 開發效率降低 .

我們想要靜態代理的好處，又不想要靜態代理的缺點，所以 , 就有了動態代理 !

3、靜態代理再理解

練習步驟：

1. 創建一個抽象角色，比如咋們平時做的用戶業務，抽象起來就是增刪改查！

//抽象角色：增刪改查業務
public interface UserService {
    void add();
    void delete();
    void update();
    void query();
}

2. 我們需要一個真實對象來完成這些增刪改查操作

//真實對象，完成增刪改查操作的人
public class UserServiceImpl implements UserService {
    public void add() {
    　　System.out.println("增加了一個用戶");
　　}
　　public void delete() {
　　　　System.out.println("刪除了一個用戶");
　　}
　　public void update() {
　　　　System.out.println("更新了一個用戶");
　　}
　　public void query() {
　　　　System.out.println("查詢了一個用戶");
　　}
}

3. 需求來了，現在我們需要增加一個日誌功能，怎麼實現！

  • 思路1 ：在實現類上增加代碼 【麻煩！】
  • 思路2：使用代理來做，能夠不改變原來的業務情況下，實現此功能就是最好的了！

4. 設置一個代理類來處理日誌！ 代理角色

//代理角色，在這裡面增加日誌的實現
public class UserServiceProxy implements UserService {
　　private UserServiceImpl userService;
　　public void setUserService(UserServiceImpl userService) {
　　　　this.userService = userService;
　　}
　　public void add() {
　　　　log("add");
　　　　userService.add();
　　}
　　public void delete() {
　　　　log("delete");
　　　　userService.delete();
　　}
　　public void update() {
　　　　log("update");
　　　　userService.update();
　　}
　　public void query() {
　　　　log("query");
　　　　userService.query();
　　}
　　public void log(String msg){
　　　　System.out.println("執行了"+msg+"方法");
　　}
}

5. 測試訪問類：

public class Client {
　　public static void main(String[] args) {
　　　　//真實業務
　　　　UserServiceImpl userService = new UserServiceImpl();
　　　　//代理類
　　　　UserServiceProxy proxy = new UserServiceProxy();
　　　　//使用代理類實現日誌功能！
　　　　proxy.setUserService(userService);
　　　　proxy.add();
　　}
}

OK，到了現在代理模式大家應該都沒有什麼問題了，重點大家需要理解其中的思想；

我們在不改變原來的代碼的情況下，實現了對原有功能的增強，這是AOP中最核心的思想

【聊聊AOP：縱向開發，橫向開發】

 

 4、動態代理

  • 動態代理的角色和靜態代理的一樣 .
  • 動態代理的代理類是動態生成的 . 靜態代理的代理類是我們提前寫好的
  • 動態代理分為兩類 : 一類是基於介面動態代理 , 一類是基於類的動態代理
    • 基於介面的動態代理----JDK動態代理
    • 基於類的動態代理--cglib
    • 現在用的比較多的是 javasist 來生成動態代理 . 百度一下javasist
    • 我們這裡使用JDK的原生代碼來實現，其餘的道理都是一樣的！

JDK的動態代理需要瞭解兩個類

核心 : InvocationHandler 和 Proxy ， 打開JDK幫助文檔看看

【InvocationHandler：調用處理程式】

 

 

Object invoke(Object proxy, 方法 method, Object[] args)；
//參數
//proxy - 調用該方法的代理實例
//method -所述方法對應於調用代理實例上的介面方法的實例。 方法對象的聲明類將是該方法聲明的接
口，它可以是代理類繼承該方法的代理介面的超級介面。
//args -包含的方法調用傳遞代理實例的參數值的對象的陣列，或null如果介面方法沒有參數。 原始
類型的參數包含在適當的原始包裝器類的實例中，例如java.lang.Integer或java.lang.Boolean

【Proxy : 代理】

 

 

 

 

//生成代理類
public Object getProxy(){
　　return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
}

代碼實現

抽象角色和真實角色和之前的一樣！

Rent . java 即抽象角色

//抽象角色：租房
public interface Rent {
　　public void rent();
}

Host . java 即真實角色

//真實角色: 房東，房東要出租房子
public class Host implements Rent{
　　public void rent() {
　　　　System.out.println("房屋出租");
　　}
}

ProxyInvocationHandler. java 即代理角色

public class ProxyInvocationHandler implements InvocationHandler {
　　private Rent rent;
　　public void setRent(Rent rent) {
　　　　this.rent = rent;
　　}
　　//生成代理類，重點是第二個參數，獲取要代理的抽象角色！之前都是一個角色，現在可以代理一類角色
　　public Object getProxy(){
　　　　return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
　　}
　　// proxy : 代理類 method : 代理類的調用處理程式的方法對象.
　　// 處理代理實例上的方法調用並返回結果
　　@Override
　　public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
　　　　seeHouse();
　　　　//核心：本質利用反射實現！
　　　　Object result = method.invoke(rent, args);
　　　　fare();
　　　　return result;
　　}
　　//看房
　　public void seeHouse(){
　　　　System.out.println("帶房客看房");
　　}
　　//收中介費
　　public void fare(){
　　　　System.out.println("收中介費");
　　}
}

Client . java

//租客
public class Client {
　　public static void main(String[] args) {
　　　　//真實角色
　　　　Host host = new Host();
　　　　//代理實例的調用處理程式
　　　　ProxyInvocationHandler pih = new ProxyInvocationHandler();
　　　　pih.setRent(host); //將真實角色放置進去！
　　　　Rent proxy = (Rent)pih.getProxy(); //動態生成對應的代理類！
　　　　proxy.rent();
　　}
}

核心：一個動態代理 , 一般代理某一類業務 , 一個動態代理可以代理多個類，代理的是介面！

5、深化理解

我們來使用動態代理實現代理我們後面寫的UserService！

我們也可以編寫一個通用的動態代理實現的類！所有的代理對象設置為Object即可！

public class ProxyInvocationHandler implements InvocationHandler {
　　private Object target;
　　public void setTarget(Object target) {
　　　　this.target = target;
　　}
　　//生成代理類
　　public Object getProxy(){
　　　　return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
　　}
　　// proxy : 代理類
　　// method : 代理類的調用處理程式的方法對象.
　　public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
　　　　log(method.getName());
　　　　Object result = method.invoke(target, args);
　　　　return result;
　　}
　　public void log(String methodName){
　　　　System.out.println("執行了"+methodName+"方法");
　　}
}

測試！

public class Test {
　　public static void main(String[] args) {
　　　　//真實對象
　　　　UserServiceImpl userService = new UserServiceImpl();
　　　　//代理對象的調用處理程式
　　　　ProxyInvocationHandler pih = new ProxyInvocationHandler();
　　　　pih.setTarget(userService); //設置要代理的對象
　　　　UserService proxy = (UserService)pih.getProxy(); //動態生成代理類！
　　　　proxy.delete();
　　}
}

【測試，增刪改查，查看結果】

6、動態代理的好處

靜態代理有的它都有，靜態代理沒有的，它也有！

  • 可以使得我們的真實角色更加純粹 . 不再去關註一些公共的事情 .
  • 公共的業務由代理來完成 . 實現了業務的分工 ,
  • 公共業務發生擴展時變得更加集中和方便 .
  • 一個動態代理 , 一般代理某一類業務
  • 一個動態代理可以代理多個類，代理的是介面！

AOP

1 什麼是AOP

AOP（Aspect Oriented Programming）意為：面向切麵編程，通過預編譯方式和運行期動態代理實現 程式功能的統一維護的一種技術。AOP是OOP的延續，是軟體開發中的一個熱點，也是Spring框架中的 一個重要內容，是函數式編程的一種衍生範型。利用AOP可以對業務邏輯的各個部分進行隔離，從而使 得業務邏輯各部分之間的耦合度降低，提高程式的可重用性，同時提高了開發的效率。

 

 2 Aop在Spring中的作用

提供聲明式事務；允許用戶自定義切麵

  • 橫切關註點：跨越應用程式多個模塊的方法或功能。即是，與我們業務邏輯無關的，但是我們需要 關註的部分，就是橫切關註點。如日誌 , 安全 , 緩存 , 事務等等 ....
  • 切麵（ASPECT）：橫切關註點 被模塊化 的特殊對象。即，它是一個類。
  • 通知（Advice）：切麵必須要完成的工作。即，它是類中的一個方法。
  • 目標（Target）：被通知對象。
  • 代理（Proxy）：向目標對象應用通知之後創建的對象。
  • 切入點（PointCut）：切麵通知 執行的 “地點”的定義。
  • 連接點（JointPoint）：與切入點匹配的執行點。

 

 SpringAOP中，通過Advice定義橫切邏輯，Spring中支持5種類型的Advice:

 

 即 Aop 在 不改變原有代碼的情況下 , 去增加新的功能 .

3 使用Spring實現Aop

【重點】使用AOP織入，需要導入一個依賴包！

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
　　<groupId>org.aspectj</groupId>
　　<artifactId>aspectjweaver</artifactId>
　　<version>1.9.4</version>
</dependency>

第一種方式

通過 Spring API 實現

首先編寫我們的業務介面和實現類

public interface UserService {
　　public void add();
　　public void delete();
　　public void update();
　　public void search();
}

public class UserServiceImpl implements UserService{
　　@Override
　　public void add() {
　　　　System.out.println("增加用戶");
　　}
　　@Override
　　public void delete() {
　　　　System.out.println("刪除用戶");
　　}
　　@Override
　　public void update() {
　　　　System.out.println("更新用戶");
　　}
　　@Override
　　public void search() {
　　　　System.out.println("查詢用戶");
　　}
}

然後去寫我們的增強類 , 我們編寫兩個 , 一個前置增強 一個後置增強

public class Log implements MethodBeforeAdvice {
　　//method : 要執行的目標對象的方法
　　//objects : 被調用的方法的參數
　　//Object : 目標對象
　　@Override
　　public void before(Method method, Object[] objects, Object o) throws Throwable {
　　　　System.out.println( o.getClass().getName() + "的" + method.getName()+ "方法被執行了");
　　}
}

public class AfterLog implements AfterReturningAdvice {
　　//returnValue 返回值
　　//method被調用的方法
　　//args 被調用的方法的對象的參數
　　//target 被調用的目標對象
　　@Override
　　public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
　　　　System.out.println("執行了" + target.getClass().getName()+"的"+method.getName()+"方法,"+"返回值："+returnValue);
　　}
}

最後去spring的文件中註冊 , 並實現aop切入實現 , 註意導入約束

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
　　　　xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
　　　　xmlns:aop="http://www.springframework.org/schema/aop"
　　　　xsi:schemaLocation="http://www.springframework.org/schema/beans
　　　　　　http://www.springframework.org/schema/beans/spring-beans.xsd
　　　　　　http://www.springframework.org/schema/aop
　　　　　　http://www.springframework.org/schema/aop/spring-aop.xsd">

　　<!--註冊bean-->
　　<bean id="userService" class="com.hang.service.UserServiceImpl"/>
　　<bean id="log" class="com.hang.log.Log"/>
　　<bean id="afterLog" class="com.hang.log.AfterLog"/>
　　<!--aop的配置-->
　　<aop:config>
　　　　<!--切入點 expression:表達式匹配要執行的方法-->
　　　　<aop:pointcut id="pointcut" expression="execution(* com.hang.service.UserServiceImpl.*(..))"/>
　　　　<!--執行環繞; advice-ref執行方法 . pointcut-ref切入點-->
　　　　<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
　　　　<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
　　</aop:config>
</beans>

測試

public class MyTest {
　　@Test
　　public void test(){
　　　　ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
　　　　UserService userService = (UserService)
　　　　context.getBean("userService");
　　　　userService.search();
　　}
}

Aop的重要性 : 很重要 . 一定要理解其中的思路 , 主要是思想的理解這一塊 .

Spring的Aop就是將公共的業務 (日誌 , 安全等) 和領域業務結合起來 , 當執行領域業務時 , 將會把公共業 務加進來 . 實現公共業務的重覆利用 . 領域業務更純粹 , 程式猿專註領域業務 , 其本質還是動態代理 .

第二種方式

自定義類來實現Aop

目標業務類不變依舊是userServiceImpl

第一步 : 寫我們自己的一個切入類

public class DiyPointcut {
　　public void before(){
　　　　System.out.println("---------方法執行前---------");
　　}
　　public void after(){
　　　　System.out.println("---------方法執行後---------");
　　}
}

去spring中配置

<!--第二種方式自定義實現-->
<!--註冊bean-->
<bean id="diy" class="com.kuang.config.DiyPointcut"/>

<!--aop的配置-->
<aop:config>
　　<!--第二種方式：使用AOP的標簽實現-->
　　<aop:aspect ref="diy">
　　　　<aop:pointcut id="diyPonitcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
　　　　<aop:before pointcut-ref="diyPonitcut" method="before"/>
　　　　<aop:after pointcut-ref="diyPonitcut" method="after"/>
　　</aop:aspect>
</aop:config>

測試：

public class MyTest {
　　@Test
　　public void test(){
　　　　ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
　　　　UserService userService = (UserService)
　　　　context.getBean("userService");
　　　　userService.add();
　　}
}

第三種方式

使用註解實現

第一步：編寫一個註解實現的增強類

package com.hang.config;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AnnotationPointcut {
　　@Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
　　public void before(){
　　　　System.out.println("---------方法執行前---------");
　　}
　　@After("execution(* com.kuang.service.UserServiceImpl.*(..))")
　　public void after(){
　　　　System.out.println("---------方法執行後---------");
　　}
　　@Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
　　public void around(ProceedingJoinPoint jp) throws Throwable {
　　　　System.out.println("環繞前");
　　　　System.out.println("簽名:"+jp.getSignature());
　　　　//執行目標方法proceed
　　　　Object proceed = jp.proceed();
　　　　System.out.println("環繞後");
　　　　System.out.println(proceed);
　　}
}

第二步：在Spring配置文件中，註冊bean，並增加支持註解的配置

<!--第三種方式:註解實現-->
<bean id="annotationPointcut" class="com.kuang.config.AnnotationPointcut"/>
<aop:aspectj-autoproxy/>

aop:aspectj-autoproxy：說明

 整合Mybatis

 步驟：

1) 導入相關jar包

1. junit

<dependency>
　　<groupId>junit</groupId>
　　<artifactId>junit</artifactId>
　　<version>4.12</version>
</dependency>

2. mybatis

<dependency>
　　<groupId>org.mybatis</groupId>
　　<artifactId>mybatis</artifactId>
　　<version>3.5.2</version>
</dependency>

3. mysql-connector-java

<dependency>
　　<groupId>mysql</groupId>
　　<artifactId>mysql-connector-java</artifactId>
　　<version>5.1.47</version>
</dependency>

4. spring相關

<dependency>
　　<groupId>org.springframework</groupId>
　　<artifactId>spring-webmvc</artifactId>
　　<version>5.1.10.RELEASE</version>
</dependency>
<dependency>
　　<groupId>org.springframework</groupId>
　　<artifactId>spring-jdbc</artifactId>
　　<version>5.1.10.RELEASE</version>
</dependency>

5. aspectJ AOP 織入器

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
　　<groupId>org.aspectj</groupId>
　　<artifactId>aspectjweaver</artifactId>
　　<version>1.9.4</version>
</dependency>

6. mybatis-spring整合包 【重點】

<dependency>
　　<groupId>org.mybatis</groupId>
　　<artifactId>mybatis-spring</artifactId>
　　<version>2.0.2</version>
</dependency>

7. 配置Maven靜態資源過濾問題！

<build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
</build>

2) 編寫配置文件

3) 代碼實現

回憶MyBatis

編寫pojo實體類

package com.hang.pojo;
public class User {
    private int id; //id
    private String name; //姓名
    private String pwd; //密碼
}

實現mybatis的配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <package name="com.hang.dao"/>
    </mappers>

</configuration>

UserDao介面編寫

public interface UserMapper {
    public List<User> selectUser();
}

介面對應的Mapper映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
　　　　　PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
　　　　　"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.kuang.dao.UserMapper">
　　<select id="selectUser" resultType="User">
　　　　select * from user
　　</select>
</mapper>

測試類

@Test
public void selectUser() throws IOException {
　　String resource = "mybatis-config.xml";
　　InputStream inputStream = Resources.getResourceAsStream(resource);
　　SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
　　SqlSession sqlSession = sqlSessionFactory.openSession();

　　UserMapper mapper = sqlSession.getMapper(UserMapper.class);

　　List<User> userList = mapper.selectUser();
　　for (User user: userList){
　　　　System.out.println(user);
　　}
　　sqlSession.close();
}

MyBatis-Spring學習

引入Spring之前需要瞭解mybatis-spring包中的一些重要類；

http://www.mybatis.org/spring/zh/index.html

什麼是 MyBatis-Spring？

MyBatis-Spring 會幫助你將 MyBatis 代碼無縫地整合到 Spring 中。

知識基礎

在開始使用 MyBatis-Spring 之前，你需要先熟悉 Spring 和 MyBatis 這兩個框架和有關它們的術語。這 很重要

MyBatis-Spring 需要以下版本：

 

 

 如果使用 Maven 作為構建工具，僅需要在 pom.xml 中加入以下代碼即可：

<dependency>
　　<groupId>org.mybatis</groupId>
　　<artifactId>mybatis-spring</artifactId>
　　<version>2.0.2</version>
</dependency>

要和 Spring 一起使用 MyBatis，需要在 Spring 應用上下文中定義至少兩樣東西：一個 SqlSessionFactory 和至少一個數據映射器類。

在 MyBatis-Spring 中，可使用 SqlSessionFactoryBean 來創建 SqlSessionFactory 。 要配置 這個工廠 bean，只需要把下麵代碼放在 Spring 的 XML 配置文件中：

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
　　<property name="dataSource" ref="dataSource" />
</bean>

註意： SqlSessionFactory 需要一個 DataSource （數據源）。 這可以是任意的 DataSource ，只需要和配置其它 Spring 資料庫連接一樣配置它就可以了。

在基礎的 MyBatis 用法中，是通過 SqlSessionFactoryBuilder 來創建 SqlSessionFactory 的。 而在 MyBatis-Spring 中，則使用 SqlSessionFactoryBean 來創建。

在 MyBatis 中，你可以使用 SqlSessionFactory 來創建 SqlSession 。一旦你獲得一個 session 之後，你可以使用它來執行映射了的語句，提交或回滾連接，最後，當不再需要它的時候，你 可以關閉 session。

SqlSessionFactory 有一個唯一的必要屬性：用於 JDBC 的 DataSource 。這可以是任意的 DataSource 對象，它的配置方法和其它 Spring 資料庫連接是一樣的。

一個常用的屬性是 configLocation ，它用來指定 MyBatis 的 XML 配置文件路徑。它在需要修改 MyBatis 的基礎配置非常有用。通常，基礎配置指的是<settings> 或 <typeAliases>元素。

需要註意的是，這個配置文件並不需要是一個完整的 MyBatis 配置。確切地說，任何環境配置 （ <environments>），數據源（<DataSource> ）和 MyBatis 的事務管理器 （ <transactionManager>）都會被忽略。 SqlSessionFactoryBean 會創建它自有的 MyBatis 環境配置（ Environment ），並按要求設置自定義環境的值。

SqlSessionTemplate 是 MyBatis-Spring 的核心。作為 SqlSession 的一個實現，這意味著可 以使用它無縫代替你代碼中已經在使用的 SqlSession 。

模板可以參與到 Spring 的事務管理中，並且由於其是線程安全的，可以供多個映射器類使用，你應該總 是用 SqlSessionTemplate 來替換 MyBatis 預設的 DefaultSqlSession 實現。在同一應用程 序中的不同類之間混雜使用可能會引起數據一致性的問題。

可以使用 SqlSessionFactory 作為構造方法的參數來創建 SqlSessionTemplate 對象。

<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
　　<constructor-arg index="0" ref="sqlSessionFactory" />
</bean>

現在，這個 bean 就可以直接註入到你的 DAO bean 中了。你需要在你的 bean 中添加一個 SqlSession 屬性，就像下麵這樣：

public class UserDaoImpl implements UserDao {
　　private SqlSession sqlSession;
　　public void setSqlSession(SqlSession sqlSession) {
　　　　this.sqlSession = sqlSession;
　　}
　　public User getUser(String userId) {
　　　　return sqlSession.getMapper...;
　　}
}

按下麵這樣，註入 SqlSessionTemplate ：

<bean id="userDao" class="org.mybatis.spring.sample.dao.UserDaoImpl">
　　<property name="sqlSession" ref="sqlSession" />
</bean>

整合實現一

1. 引入Spring配置文件beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
　　　　xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
　　　　xsi:schemaLocation="http://www.springframework.org/schema/beans
　　　　　　http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

2. 配置數據源替換mybaits的數據源

<!--配置數據源：數據源有非常多，可以使用第三方的，也可使使用Spring的-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
　　<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
　　<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf8"/>
　　<property name="username" value="root"/>
　　<property name="password" value="123456"/>
</bean>

3. 配置SqlSessionFactory，關聯MyBatis

<!--配置SqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
　　<property name="dataSource" ref="dataSource"/>
　　<!--關聯Mybatis-->
　　<property name="configLocation" value="classpath:mybatisconfig.xml"/>
　　<property name="mapperLocations" value="classpath:com/hang/dao/*.xml"/>
</bean>

4. 註冊sqlSessionTemplate，關聯sqlSessionFactory；

<!--註冊sqlSessionTemplate , 關聯sqlSessionFactory-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
　　<!--利用構造器註入-->
　　<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>

5. 增加Dao介面的實現類；私有化sqlSessionTemplate

public class UserDaoImpl implements UserMapper {
　　//sqlSession不用我們自己創建了，Spring來管理
　　private SqlSessionTemplate sqlSession;
　　public void setSqlSession(SqlSessionTemplate sqlSession) {
　　　　this.sqlSession = sqlSession;
　　}
　　public List<User> selectUser() {
　　　　UserMapper mapper = sqlSession.getMapper(UserMapper.class);
　　　　return mapper.selectUser();
　　}
}

6. 註冊bean實現

<bean id="userDao" class="com.kuang.dao.UserDaoImpl">
　　<property name="sqlSession" ref="sqlSession"/>
</bean>

7. 測試

@Test
public void test2(){
　　ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
　　UserMapper mapper = (UserMapper) context.getBean("userDao");
　　List<User> user = mapper.selectUser();
　　System.out.println(user);
}

結果成功輸出！現在我們的Mybatis配置文件的狀態！發現都可以被Spring整合！

整合實現二

mybatis-spring1.2.3版以上的才有這個 .

官方文檔截圖 :

dao繼承Support類 , 直接利用 getSqlSession() 獲得 , 然後直接註入SqlSessionFactory . 比起方式1 , 不 需要管理SqlSessionTemplate , 而且對事務的支持更加友好 . 可跟蹤源碼查看

 

 測試：

1. 將我們上面寫的UserDaoImpl修改一下

public class UserDaoImpl extends SqlSessionDaoSupport implements UserMapper {
　　public List<User> selectUser() {
　　　　UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
　　　　return mapper.selectUser();
　　}
}

2. 修改bean的配置

<bean id="userDao" class="com.kuang.dao.UserDaoImpl">
　　<property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

3. 測試

@Test
public void test2(){
　　ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
　　UserMapper mapper = (UserMapper) context.getBean("userDao");
　　List<User> user = mapper.selectUser();
　　System.out.println(user);
}

總結 : 整合到spring中以後可以完全不要mybatis的配置文件，除了這些方式可以實現整合之外，我們還 可以使用註解來實現，這個等我們後面學習SpringBoot的時候還會測試整合！

 

本文來自博客園，作者：腹白，轉載請註明原文鏈接：https://www.cnblogs.com/wyh518/


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 學習Vue過程中遇到的問題---code: 'MODULE_NOT_FOUND'
    在學習安裝腳手架Vue-cli過程中 步驟為： 第一步（僅第一次執行）：全局安裝@vue/cli。 npm install -g @vue/cli 第二步：切換到你要創建項目的目錄，然後使用命令創建項目 vue create xxxx 第三步：啟動項目 npm run serve 備註： 如出現下載 ...
  • 04-數據類型轉換
    數據類型 Number - 強制類型轉換(int float bool complex) 1. 強制把數據轉換為整型 - int float bool 純數字字元串 # 強制把數據轉換為整型 - int float bool 純數字字元串 var1 = 13 var2 = 5.67 var3 = T ...
  • 03-數據類型
    #數據類型 Number - 數字類型 數字類型包含int,float,bool,complex類型 int - 整型 整型 - 正數,負數,0 # type(variable) 可以查看變數的類型 # id(variable) 可以查看變數的地址 age = 18 res = type(int) ...
  • Spring IOC官方文檔學習筆記（十一）之使用JSR 330標準註解
    自定義攔截器 1.什麼是攔截器 說明： 攔截器與過濾器的區別 SpringMVC 的攔截器（Interceptor）與 Java Servlet 的過濾器（Filter）類似，它主要用於攔截用戶的請求並做相應的處理，通常應用在許可權驗證、記錄請求信息的日誌、判斷用戶是否登錄等功能上。 SpringMV ...
  • Protobuf Options 自定義插件使用
    1.記憶體對齊是什麼？ 對結構體和類來說，讓變數不是緊挨著存放，而是通過變數位元組倍數的形式存放 2.為什麼會有記憶體對齊？ 增加cpu的訪問數據的速度 對於cpu來說，數據從記憶體中讀到緩存中去，是通過偏移量(offset)進行讀取，也就是常說的通過塊來讀取，而不是按照位元組讀取。 讀取非記憶體對齊的數據，會 ...
  • GO web 開發 實戰，資料庫預處理 技術學習分享
    咱們其實可以使用 mysql 預處理的方式來操作這些 那麼我們一起來看看什麼是已處理呢？ 什麼是預處理？ 瞭解什麼是預處理，我們可以來對比一下，普通的 sql 語句執行過程和 預處理的執行過程 普通 sql 語句執行過程： 客戶端對 SQL 語句進行 占位符 替換得到完整的 sql 語句 客戶端發送 ...
  • 02-python簡介
    python簡介 python認知 1、python簡介 89年開發的語言,創始人範羅蘇姆(Guido van Rossum),別稱:龜叔(Guido). python具有非常多並且強大的第三方庫,使得程式開發起來得心應手. Python程式員的信仰:人生苦短,我用python! 開發方向： 機器學 ...
  • 《分散式技術原理與演算法解析》學習筆記Day15
    這篇文章主要描述Actor模型，Actor類似於一個封裝了自己狀態和行為的“黑盒”對象，Actor之間通過消息進行通信，解決了死鎖、競爭等問題。 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類