六、Spring（3）

一、 代理模式

为什么要学习代理模式？

因为这就是SpringAOP的底层！【SpringAOP 和 SpringMVC】

代理模式的分类：

• 静态代理
• 动态代理

1.1 静态代理

1.1.1 案例一：初次理解

角色分析：

• 抽象角色：一般会使用接口或者抽象类来解决
• 真实角色：被代理得角色
• 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
• 客户访问代理对象的人！

代码步骤：

创建子工程 （spring-06-proxy）

1. 接口 Rent.java

package com.zql;

/**
 * @Author:Daniel
 * @Version 1.0
 */
//租房接口
public interface c{

    public void rent();
}

2. 真实角色 Host.java

package com.zql;

/**
 * @Author:Daniel
 * @Version 1.0
 */
//房东
public class Host implements Rent{

    @Override
    public void rent() {
        System.out.println("房东要出租房子");
    }
}

3. 代理角色 Proxy.java

package com.zql;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class Proxy implements  Rent{

    public Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    public void rent() {
        host.rent();
        seeHome();
        hetong();
        receiveMoney();
    }


    public void seeHome(){
        System.out.println("中介带你看房");
    }
    
    public void hetong(){
        System.out.println("签合同");
    }
    public void receiveMoney(){

        System.out.println("收取押金");
    }
}

4. 客户端访问代理角色Client.java

package com.zql;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class Client {

    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //代理，中介帮房东租房子，但是呢？代理会有一些附属操作！
        Proxy proxy = new Proxy(host);
        //你不要面对房东，直接找中介
        proxy.rent();

    }
}

1.1.2 静态代理模式的好处👇🏾👇🏾

1. 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
2. 公共也就交给代理角色！实现了业务的分工！
3. 公共业务发生扩展的时候，方便集中管理！

缺点：

• 一个真实角色就会产生一个代理角色；代码量会翻倍，开发效率会变低~

1.1.3 案例二：再次理解静态代理

AOP👇🏾👇🏾

结构：👇🏾👇🏾

UserService.java

package com.zql.demo2;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public interface UserService {

    public void addUser();

    public void deleteUser();

    public void updateUser();

    public void queryUser();

}

UserServiceImpl.java

package com.zql.demo2;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class UserServiceImpl  implements  UserService{


    @Override
    public void addUser() {
        System.out.println("增加了一个");
    }

    @Override
    public void deleteUser() {

        System.out.println("删除了一个");

    }

    @Override
    public void updateUser() {

        System.out.println("修改了一个");

    }

    @Override
    public void queryUser() {

        System.out.println("查询到一个");
    }
}

UserProxy.java

package com.zql.demo2;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class UserProxy implements UserService {

    UserServiceImpl userService = new UserServiceImpl();

    public void setUserService(UserServiceImpl userService) {

        this.userService = userService;

    }

    @Override
    public void addUser() {

        userService.addUser();

        log("addUser");
    }

    @Override
    public void deleteUser() {

        userService.deleteUser();

        log("deleteUser");
    }

    @Override
    public void updateUser() {

        userService.updateUser();

        log("updateUser");

    }

    @Override
    public void queryUser() {

        userService.queryUser();

        log("queryUser");
    }

    public void log(String msg){

        System.out.println("使用了"+msg+"方法");
    }
}

Client.java

package com.zql.demo2;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class Client {

    public static void main(String[] args) {

        UserServiceImpl userService = new UserServiceImpl();

        UserProxy userProxy = new UserProxy();

        userProxy.setUserService(userService);

        userProxy.addUser();
    }
}

1.2 动态代理(反射机制)

👉🏾👉🏾反射

• 动态代理和静态代理角色一样
• 动态代理的代理类是动态生成的，不是我们直接写好的！
• 动态代理分为两大类：基于接口的动态代理。基于类的动态代理
  — 基于接口------JDK动态代理
  — 基于类：cglib
  — java字节码实现：javasist

需要了解两个类： Proxy: 代理， InvocationHandler :调用处理程序

1.2.1 案例

(1) Host.java

package com.zql.demo3;

/**
 * @Author:Daniel
 * @Version 1.0
 */
//房东
public class Host implements Rent {

    @Override
    public void rent() {
        System.out.println("房东要出租房子");
    }
}

(2) Rent.java

package com.zql.demo3;

/**
 * @Author:Daniel
 * @Version 1.0
 */
//租房接口
public interface Rent {

    public void rent();
}

(3) ProxyInvocationHandler.java

package com.zql.demo3;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @Author:Daniel
 * @Version 1.0
 */

//等我们会用这个类，自动生成代理类
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);
    }

    //处理代理实例，并返回结果
    @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("预缴押金");
    }
}

(4) Client.java

package com.zql.demo3;

import com.zql.demo1.Proxy;

/**
 * @Author:Daniel
 * @Version 1.0
 */
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是动态生成的，我们并没有写

        proxy.rent();
    }
}

1.2.2 优化案例

(1) UserService.java

package com.zql.demo4;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public interface UserService {

    public void addUser();

    public void deleteUser();

    public void updateUser();

    public void queryUser();
}

(2) UserServiceImpl.java

package com.zql.demo4;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class UserServiceImpl  implements UserService {


    @Override
    public void addUser() {
        System.out.println("增加了一个");
    }

    @Override
    public void deleteUser() {

        System.out.println("删除了一个");

    }

    @Override
    public void updateUser() {

        System.out.println("修改了一个");

    }

    @Override
    public void queryUser() {

        System.out.println("查询到一个");
    }
}

(3) ProxyInvocationHandler.java

package com.zql.demo4;

import com.zql.demo3.Rent;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @Author:Daniel
 * @Version 1.0
 * 代理模板，如同工具类
 */

//等我们会用这个类，自动生成代理类
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);
    }

    //处理代理实例，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质，就是使用反射机制实现！
        Object result = method.invoke(target, args);

        log(method.getName());
        return result;
    }
    public void log(String msg){

        System.out.println("执行了"+msg+"方法");
    }
}

(4) Client.java

package com.zql.demo4;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class Client  {

    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色，不存在
        ProxyInvocationHandler pih = new ProxyInvocationHandler();

        pih.setTarget(userService);//设置要代理的对象
        //动态生成代理类
        UserService service = (UserService) pih.getProxy();

        service.addUser();

        pih.getProxy();
    }
}

1.2.3 动态代理的好处（包含静态代理好处）👇🏾👇🏾

1. 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
2. 公共也就交给代理角色！实现了业务的分工！
3. 公共业务发生扩展的时候，方便集中管理！
4. 一个动态代理类代理的是一个接口，一般就是对应的一类业务

二、Spring AOP

2.1 什么是AOP

2.2 Aop在Spring中的作用

提供声明式事务，允许用户自定义切面

• 横切关注点，跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点，如日志，安全，缓存，事务等等……
• 切面（ASPECT):横切关注点被模块化的特殊对象。即，它是一个类。Log
• 通知（Advice)：切面必须要完成的工作，即，它是类中的一个方法。Log中的方法
• 目标（Target):被通知的对象。
• 代理（Proxy):向目标对象应用通知之后创建的对象。
• 切入点（PointCut）:切面通知执行的“地点”的定义。
• 连接点（JointPoint）：与切入点匹配的执行点。

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Adivce:

通知类型	连接点	注解	实现接口	说明
前置通知	方法前	@Before	org.springframework.aop.MethodBeforeAdvice	通知方法在目标方法调用之前执行
后置通知	方法后	@After	org.springframework.aop.AfterReturningAdvice	通知方法在目标方法返回或异常后调用
环绕通知	方法前后	@Around	org.aopalliance.intercept.MethodInterceptor	通知方法会将目标方法封装起来
异常抛出通知	方法抛出异常	@AfterThrowing	org.springframework.aop.ThrowsAdvice	通知方法会在目标方法抛出后调用
引介通知	类中增加新的方法属性	@	org.springframework.aop.InteoductionInterceptor	表示在目标类中添加一些新的方法和属性

即Aop在不改变原有代码的情况下，去增加新的功能。

2.3 使用Spring实现Aop

【重点】使用AOP织入，需要导入一个依赖包！

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
    <scope>runtime</scope>
</dependency>

2.3.1 案例（方式一:使用Spring的API接口)

主要是Spring API接口

创建一个子工程 spring-07-aop

1. 案例结构

2. 导入依赖(子工程 pom.xml)

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>com.zql</artifactId>
        <groupId>com.zql</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-07-aop</artifactId>

    <dependencies>
        <!--spring aop-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>
    </dependencies>
</project>

3. UserService.java

package com.zql.service;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public interface UserService {

    public void add();
    public void delete();
    public void update();
    public void seelct();
}

4. UserServiceImpl.java

package com.zql.service;

/**
 * @Author:Daniel
 * @Version 1.0
 */
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 seelct() {
        System.out.println("查到了一个方法");
    }
}

5. BoforeLog.java

package com.zql.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class BeforeLog implements MethodBeforeAdvice {
    //method:要执行的目标对象的方法
    //args：参数
    //target:目标对象
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

6. AfterLog.java

package com.zql.log;

import org.springframework.aop.AfterAdvice;
import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class AfterLog implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        //returnValue  返回值
        System.out.println("执行了"+method.getName()+"返回结果为"+returnValue);
    }
}

7. applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--suppress ALL -->
<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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="userService" class="com.zql.service.UserServiceImpl"></bean>
    <bean id="beforeLog" class="com.zql.log.BeforeLog"></bean>
    <bean id="afterLog" class="com.zql.log.AfterLog"></bean>
    
	<!--方式一： 使用原生的spring API接口-->
    <!--配置aop,需要导入aop的约束-->
    <aop:config>
        <!--切入点 expression 表达式 execution（要执行的位置）-->
        <aop:pointcut id="pointcut" expression="execution(* com.zql.service.UserServiceImpl.*(..))"/>

        <!--执行环绕增加-->
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"></aop:advisor><!--log意思是切入到方法上面-->
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"></aop:advisor>

    </aop:config>
</beans>

8. MyTest.java

import com.zql.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class MyTest {

    public static void main(String[] args) {

       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //注意：  动态代理代理的是接口
        UserService userService = (UserService) context.getBean("userService");

        userService.add();
    }
}

2.3.2 案例（方式二:自定义类实现AOP)

主要是切面定义

自定义类实现aop

1. 案例结构(在案例2.3.2基础上增加)
   

2. DiyPointCut.java

package com.zql.diy;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class DiyPointCut {

    public void before(){
        System.out.println("===============执行前一个方法==============");
    }

    public void after(){
        System.out.println("================执行后一个方法==============");
    }
}

3. applicationContext.java

<?xml version="1.0" encoding="UTF-8"?>
<!--suppress ALL -->
<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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="userService" class="com.zql.service.UserServiceImpl"></bean>
    <bean id="beforeLog" class="com.zql.log.BeforeLog"></bean>
    <bean id="afterLog" class="com.zql.log.AfterLog"></bean>

     <!--方式一： 使用原生的spring API接口-->
    <!--配置aop,需要导入aop的约束-->
    <!-- <aop:config>
        &lt;!&ndash;切入点 expression 表达式 execution（要执行的位置）&ndash;&gt;
        <aop:pointcut id="pointcut" expression="execution(* com.zql.service.UserServiceImpl.*(..))"/>
        &lt;!&ndash;执行环绕增加&ndash;&gt;
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"></aop:advisor>&lt;!&ndash;log意思是切入到方法上面&ndash;&gt;
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"></aop:advisor>
     </aop:config>-->

    <!--方式二 自定义类-->
    <bean id="diy" class="com.zql.diy.DiyPointCut"/>
    <aop:config>
        <!--自定义切面，ref 要引用的类-->
        <aop:aspect ref="diy">
            <!--切入点-->
            <aop:pointcut id="pointcut" expression="execution(* com.zql.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="pointcut"/>
            <aop:after method="after" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>
</beans>

2.3.3 案例（方式三:使用注解实现)

1. 案例结构

2. AnnotationPoinCut.java

package com.zql.diy;

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

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Aspect //标注这个类是一个切面
public class AnnotationPoinCut {

   @Before("execution(* com.zql.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("=============方法执行前================");
    }

    @After("execution(* com.zql.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("============方法执行后==================");
    }

    //在环绕增强种，我们可以给定一个参数，代表我们要获取处理切入的点
    @Around("execution(* com.zql.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint js) throws Throwable {

        System.out.println("==============环绕方法执行前================");

        Object proceed = js.proceed();//执行方法

        System.out.println(proceed);

        System.out.println("==============环绕方法执行后================");

        Signature signature = js.getSignature(); //获得签名

        System.out.println("signature:"+signature);

    }
}

3. applicationContext.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class="com.zql.service.UserServiceImpl"></bean>
    <bean id="before" class="com.zql.log.BeforeLog"></bean>
    <bean id="after" class="com.zql.log.AfterLog"></bean>
    <!--方式三 ： 注解-->
    <bean id="annotationPointCut" class="com.zql.diy.AnnotationPoinCut"/>
    <!--开启注解支持-->
    <aop:aspectj-autoproxy/>
</beans>

三、整合Mybatis

步骤：

1. 导入相关jar包

• junit
• mybatis
• mysql数据库
• spring相关的
• aop织入
• mybatis-spring【new】

<dependencies>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.48</version>
        </dependency>

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

        <!--springmvc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>

        <!--aspectjweaver-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>

        <!--spring-jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.22</version>
        </dependency>

        <!--spring-mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.7</version>
        </dependency>
    </dependencies>

    <!--在build中配置resources,来防止我们资源导出失败的问题-->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
        </resources>
	 </build>

2. 编写配置文件

3. 测试

3.1 温故Mybatis

结构：

1. 编写实体类User.java

package com.zql.pojo;

import lombok.Data;

import java.io.Serializable;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Data
public class User implements Serializable {

    private int id;
    private String name;
    private String pwd;
}

2. 编写核心配置文件mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

    <typeAliases>
        <package name="com.zql.pojo"/>
    </typeAliases>

    <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://localhost:3306/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper class="com.zql.mapper.UserMapper"/>
    </mappers>
</configuration>

3. 编写接口UserMapper.java

package com.zql.mapper;

import com.zql.pojo.User;

import java.util.List;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public interface UserMapper {

    List<User> selectUser();
}

4. 编写Mapper.xmlUserMapper.xml

<?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.zql.mapper.UserMapper" >
    <select id="selectUser"  resultType="user">
        select * from mybatis.user;
    </select>
</mapper>

5. 测试MyTest.java

import com.zql.mapper.UserMapper;
import com.zql.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class MyTest {

    @Test
    public void test() throws IOException {

        String resource = "mybatis-config.xml";

        InputStream is = Resources.getResourceAsStream(resource);

        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        SqlSession sqlSession = sqlSessionFactory.openSession(true);

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

        List<User> userList = mapper.selectUser();

        for (User user : userList) {

            System.out.println(user);

        }
        sqlSession.close();
        is.close();
    }
}

3.2 Mybatis-Spring 整合

3.2.1 方式一（掌握）

官网 Mybatis-Spring

1. 创建 spring-08-mybatis
   

2. 导入依赖 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>com.zql</artifactId>
        <groupId>com.zql</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-08-mybatis</artifactId>

    <dependencies>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.48</version>
        </dependency>

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

        <!--springmvc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>

        <!--aspectjweaver-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>

        <!--spring-jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.22</version>
        </dependency>

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

    </dependencies>

    <!--在build中配置resources,来防止我们资源导出失败的问题-->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>

            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
        </resources>
    </build>
</project>

3. 创建实体 User.java

package com.zql.pojo;

import lombok.Data;

import java.io.Serializable;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {

    private int id;
    private String name;
    private String pwd;
}

4. 创建接口 UserMapper.java

package com.zql.mapper;

import com.zql.pojo.User;

import java.util.List;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public interface UserMapper {

    List<User> selectUser();
}

5. 创建mapper.xml UserMapper.xml

<?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.zql.mapper.UserMapper" >
    <select id="selectUser"  resultType="user">
        select * from mybatis.user;
    </select>
</mapper>

6. 创建 mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    <typeAliases>
        <package name="com.zql.pojo"/>
    </typeAliases>

</configuration>

7. 创建 spring-dao.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--DataSource：使用Spring的数据源替换Mybtis的配置   c3p0  dbcp   druid
     我这里使用Spring 提供的JDBC :org.springframwork.jdbc.datasource
    -->
    <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"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!--sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--绑定Mabatis配置-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/zql/mapper/*.xml"/>
    </bean>

    <!--SqlSessionTemplate:就是我们使用的sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入sqlSessionFactory,因为它没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

    <!---->
    <bean id="userMapper" class="com.zql.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

</beans>

8. 创建 applicationContext.xml

在这里插入代码片

9. 创建实现类 UserMapperImpl.java

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <import resource="spring-dao.xml"/>

</beans>

11. 测试类 MyTest.java

import com.zql.mapper.UserMapper;
import com.zql.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class MyTest {

    @Test
    public void test(){

       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);

        List<User> userList = userMapper.selectUser();

        for (User user : userList) {

            System.out.println(user);
        }
    }
}

3.2.1 方式二（了解）

在方式一基础上做的总结🤣🤣

官方 SqlSessionDaoSupport

1. 创建UserMapperImpl2.java

package com.zql.mapper;

import com.zql.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import java.util.List;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {


    @Override
    public List<User> selectUser() {

        return  getSqlSession().getMapper(UserMapper.class).selectUser();
    }
}

2. 修改spring-dao.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--DataSource：使用Spring的数据源替换Mybtis的配置   c3p0  dbcp   druid
     我这里使用Spring 提供的JDBC :org.springframwork.jdbc.datasource
    -->
    <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"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!--sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--绑定Mabatis配置-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/zql/mapper/*.xml"/>
    </bean>

    <!--方式一： SqlSessionTemplate:就是我们使用的sqlSession--><!--整合方式二不需要-->
    <!-- <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        &lt;!&ndash;只能使用构造器注入sqlSessionFactory,因为它没有set方法&ndash;&gt;
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
    <bean id="userMapper" class="com.zql.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>-->

    <!--方式二-->
    <bean id="userMapper" class="com.zql.mapper.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>
</beans>

四、声明式事务

4.1 回忆事务

事务之前笔记总结

别人总结的

• 把一组业务当成一个业务来做，要么都成功，要么都失败1
• 事务在项目开发中，是十分重要的，涉及到数据的一致性问题，不能马虎，正在看我文章的友友们！
• 确保完整性和一致性。
  事务ACID原则

1. 原子性
2. 一致性
3. 隔离性
   – 多个业务可能操作同一个资源，防止数据损坏
4. 持久性
   – 事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化的写到存储器中！

创建一个子工程 spring-09-transaction

1. 搭建环境（分别copy👇🏾👇🏾spring-08-mybatis工程文件（方式二操作） ）

2. UserMapper.java

package com.zql.mapper;

import com.zql.pojo.User;

import java.util.List;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public interface UserMapper {

    List<User> selectUser();

    //增加一个用户
    public int addUser(User user);

    //删除一个用户
    public User deleteUser(int id);
}

3. UserMapper.xml <!--deleete故意写错看是否也删除成功-->

<?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.zql.mapper.UserMapper" >
    <select id="selectUser"  resultType="user">
        select * from mybatis.user;
    </select>

    <insert id="addUser" parameterType="user">
        insert into mybatis.user (id, name, pwd) VALUES (#{id}, #{name}, #{pwd})
    </insert>

    <delete id="deleteUsers" parameterType="int">
        deletes from mybatis.user where id=#{id}
      <!--deleete故意写错看是否也删除成功-->
    </delete>

</mapper>

4. UserMapperImpl.java

package com.zql.mapper;

import com.zql.pojo.User;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import javax.jws.soap.SOAPBinding;
import java.util.List;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {


    @Override
    public List<User> selectUser() {

        User user = new User(9,"Daniel","123");

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

        mapper.addUser(user);
        mapper.deleteUser(9);

        return  mapper.selectUser();

    }

    @Override
    public int addUser(User user) {
        return  getSqlSession().getMapper(UserMapper.class).addUser(user);
    }

    @Override
    public User deleteUser(int id) {
        return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
    }
}

4.2 Spring 声明式事务

官网👉🏾👉🏾Spring事务

• 声明式事务 ：AOP
• 编程式事务 : 需要在代码种，进行的事务的管理

要开启 Spring 的事务处理功能，在 Spring 的配置文件中创建一个 DataSourceTransactionManager 对象：

（1）在4.1 回忆事务 案例基础做优化修改
（2）UserMapper.java

package com.zql.mapper;

import com.zql.pojo.User;

import java.util.List;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public interface UserMapper {

    public List<User> selectUser();

    //增加一个用户
    public int addUser(User user);

    //删除一个用户
    public int deleteUser(int id);
}

(3) UserMapperImpl.java

package com.zql.mapper;

import com.zql.pojo.User;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import javax.jws.soap.SOAPBinding;
import java.util.List;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {


    @Override
    public List<User> selectUser() {

        User user = new User(4,"Daniel","123");

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

        mapper.addUser(user);
        mapper.deleteUser(2);

        return  mapper.selectUser();

    }

    @Override
    public int addUser(User user) {
        return  getSqlSession().getMapper(UserMapper.class).addUser(user);
    }

    @Override
    public int deleteUser(int id) {
        return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
    }
}

(4)UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybaits.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.zql.mapper.UserMapper" >
    <select id="selectUser"  resultType="user">
        select * from mybatis.user;
    </select>

    <insert id="addUser" parameterType="user">
        insert into mybatis.user (id, name, pwd) VALUES (#{id}, #{name}, #{pwd})
    </insert>

    <delete id="deleteUser" parameterType="int" >
        delete  from mybatis.user where id=#{id}
    </delete>

</mapper>

(5) applicationContext.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

<import resource="spring-dao.xml"/>

    <bean id="userMapper" class="com.zql.mapper.UserMapperImpl">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
     </bean>

</beans>

(6) spring-dao.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--DataSource：使用Spring的数据源替换Mybtis的配置   c3p0  dbcp   druid
     我这里使用Spring 提供的JDBC :org.springframwork.jdbc.datasource
    -->
    <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"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!--sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--绑定Mabatis配置-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/zql/mapper/*.xml"/>
    </bean>

    <!--配置声明式事务：官网copy-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <constructor-arg name="dataSource" ref="dataSource"  />
    </bean>

    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="add" propagation="REQUIRED"/>
            <tx:method name="delete" propagation="REQUIRED"/>
            <tx:method name="update" propagation="REQUIRED"/>
            <tx:method name="query" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <aop:config>
        <aop:pointcut id="txPointcut" expression="execution(* com.zql.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
    </aop:config>
</beans>

(7) mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    <typeAliases>
        <package name="com.zql.pojo"/>
    </typeAliases>

</configuration>

(8) MyTest.java

import com.zql.mapper.UserMapper;
import com.zql.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class MyTest {

    @Test
    public void test(){

       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);

        List<User> userList = userMapper.selectUser();

        for (User user : userList) {

            System.out.println(user);
        }
    }
}

事务前 👇🏾👇🏾

增加id=4删除id=2 ，事务一致性 👇🏾👇🏾

为什么需要事务？

总结：

1. 如果不配置事务，可能存在数据提交不一致的情况；
2. 如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置事务！
3. 事务在项目的开发中十分重要，涉及到数据的一致性和完整性问题，不容马虎，兄弟们！

Spring案例所有源码