主頁 > 後端開發 > Spring AOP及整合Mybatis

Spring AOP及整合Mybatis

2023-02-19 07:00:12 後端開發

代理模式

為什么要學習代理模式，因為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" />

<!--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/

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/544249.html

標籤：Java

上一篇：微軟出品自動化神器【Playwright+Java】系列（九）多執行緒、重定向、彈出新視窗、截圖、新頁面、錄制、頁面物件模式操作

下一篇：《分布式技術原理與演算法決議》學習筆記Day15

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂