Spring框架 2

了解一下“代理模式”

为什么要学习代理模式，因为Spring AOP的底层机制就是动态代理！

代理模式的分类

代理模式就是创建一个代理对象，由代理对象来接管原对象的引用。

• 静态代理
• 动态代理

上图通过“租房”的例子讲了一下代理模式的核心！

详细内容参考这篇文章！

静态代理

静态代理角色分析

• 抽象角色 : 一般使用接口或者抽象类来实现。

• 真实角色 : 被代理的角色。

• 代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作。

• 客户 : 使用代理角色来进行一些操作。

以租房为例，我们体验一下代码实现：

定义一个抽象接口：

//租房
public interface Rent {
    public void rent();
}

房东类：

//房东
public class Host {
    public void rent(){
        System.out.println("我是房东，有房子出租！");
    }
}

中介类：

//房屋中介（代理角色）
public class Proxy implements Rent{
    private Host host;

    public Proxy() {
    }

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

    //中介出租房屋（这是在帮房东做代理）
    public void rent() {
        host.rent();
        System.out.println("我是中介，我帮房东出租房子！");
        seeHouse();
        hetong();
        fare();
    }

    //中介带你看房
    public void seeHouse(){
        System.out.println("中介带你看房字！");  
    //签租赁合同
    public void hetong(){
        System.out.println("中介带你签合同！");
    }
    //收取中介费
    public void fare(){
        System.out.println("中介收取中介费！");
    }
}

房客类：

//房客
public class Client {
    public static void main(String[] args) {
        //房东要出租房子
        Host host = new Host();
        //代理角色，找房屋中介，一般会有一些附属操作
        Proxy proxy = new Proxy(host);
        //不需要直接面对房东，找中介即可
        proxy.rent();
    }
}

运行结果：

案例二：加深理解静态代理！！！

同学们练习完毕后，我们再来举一个例子，巩固大家的学习！

练习步骤：

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.add();
    }

    public void update() {
        log("update");
        userService.add();
    }

    public void query() {
        log("query");
        userService.add();
    }

    //日志方法
    public void log(String msg){
        System.out.println("[Debug]使用了"+msg+"方法！");
    }
}

5、测试访问类：

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        UserServiceProxy proxy = new UserServiceProxy();
        proxy.setUserService(userService);

        proxy.add();
        proxy.delete();
        proxy.update();
        proxy.query();
    }
}

运行结果：

OK，到了现在代理模式大家应该都没有什么问题了，重点大家需要理解其中的思想；

我们在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想！！！

静态代理的好处:

• 可以使得我们的真实角色更加纯粹，不再去关注一些公共的事情。

• 公共的业务由代理来完成，实现了业务的分工 。

• 公共业务发生扩展时变得更加集中和方便。

缺点 :

• 类多了 ，多了代理类，工作量变大了 ，开发效率降低 。

我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !

动态代理

• 动态代理的角色和静态代理的一样。

• 动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的。

• 动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理。

  • 基于接口的动态代理----JDK动态代理

  • 基于类的动态代理–cglib

  • 基于java字节码实现，现在用的比较多的是 javasist 来生成动态代理

我们这里使用JDK的原生代码来实现，其余的道理都是一样的！

JDK的动态代理需要了解两个类核心 : InvocationHandler 和 Proxy。

InvocationHandler：调用处理程序

InvocationHandler是由代理实例的调用处理程序实现的接口。每个代理实例都有一个关联的调用处理程序。 当在 代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。

object invoke (object proxy,
				方法method, 
				object[] args)
		throws Throwable

处理代理实例上的方法调用并返回结果。当在与之关联的代理实例上调用方法时，将在调用处理程序中调用此方法。

参数解析：

• proxy -调用该方法的代理实例。
• method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。
• args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如 java. lang. Integer或java.lang . Boolean。

Proxy：代理类

public class Proxy
extends Object
implements Serializable

Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。

为某个接口创建代理Foo:

InvocationHandler handler = new MyInvocationHandler(...) ;
Class<?> proxyClass = Proxy.getProxyClass (Foo.class.getClassLoader(), Foo.class) ;
Foo f = (Foo) proxyClass.getConstructor (InvocationHandler.class).newInstance (handler) ;

或更简单的：

Foo f = (Foo) Proxy.newProxyInstance (Foo.class.getClassLoader() , 
new Class<?>[] {Foo.class },
handler) ; 

该类中所有的方法：

通过代码来实际体验：

先创建一个抽象角色：rent

//租房
public interface Rent {
    public void rent();
}

再创建一个真实角色：host

//房东
public class Host implements Rent{
    public void rent(){
        System.out.println("我是房东，有房子出租！");
    }
}

创建代理角色：ProxyInvocationHandler

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

//用这个类来“动态生成”我们的代理类
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Rent rent;

    public void setRent(Rent rent){
        this.rent = rent;
    }

    //生成得到代理类,这个代码是固定的，只需要改动“rent”就可以
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                rent.getClass().getInterfaces(),
                this);
    }

    //处理代理实例，并返回结果
    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("中介收取中介费！");
    }
}

测试代码：

public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host = new Host();

        //代理角色，现在没有
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理我们要调用的接口对象
        pih.setRent(host);
        //这里的proxy就是动态生成的
        Rent proxy = (Rent) pih.getProxy();
        proxy.rent();
    }
}

运行结果：

我们来使用动态代理实现代理我们前面写的UserService！

我们也可以编写一个通用的动态代理实现的类！所有的代理对象设置为Object即可！把他当做一个工具类使用即可~~

//用这个类来“动态生成”我们的代理类
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Object target;

    public void setTarget(Object target){
        this.target = target;
    }

    //生成得到代理类,这个代码是固定的，只需要改动“rent”就可以
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this);
    }

    //处理代理实例，并返回结果
    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 msg){
        System.out.println("执行了" + msg + "方法！");
    }
}

测试代码：

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //设置要代理的对象
        pih.setTarget(userService);
        //动态生成代理类
        UserService proxy = (UserService)pih.getProxy();

        proxy.add();
        proxy.delete();
        proxy.update();
        proxy.query();
    }
}

运行结果：

动态代理的好处：

• 静态代理有的它都有，静态代理没有的，它也有！

  • 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .

  • 公共的业务由代理来完成 . 实现了业务的分工 ,

  • 公共业务发生扩展时变得更加集中和方便 .

• 一个动态代理类代理的是一个接口 , 一般就对应的某一类业务

• 一个动态代理类可以代理多个类，只要是实现了同一个接口就行

Aspect Oriented Programming-AOP

什么是AOP？

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

Aop在Spring中的作用

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

以下名词需要了解下：

• 横切关注点 ：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …

• 切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。

• 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。

• 目标（Target）：被通知对象。

• 代理（Proxy）：向目标对象应用通知之后创建的对象。

• 切入点（PointCut）：切面通知 执行的 “地点”的定义。

• 连接点（JointPoint）：与切入点匹配的执行点。
  
  SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:
  
  即 Aop 在 不改变原有代码的情况下 , 去增加新的功能 。

使用Spring实现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 select();
}

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 select() {
        System.out.println("查询一个用户！");
    }
}

然后去写我们的增强类 , 我们编写两个 , 一个前置增强 一个后置增强：

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

public class AfterLog implements AfterReturningAdvice {
    //returnValue：返回值
    public void afterReturning(Object returnValue, Method method, Object[] objects, Object target) throws Throwable {
        System.out.println("执行了"+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.kuang.service.UserServiceImpl"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>
    <bean id="beforeLog" class="com.kuang.log.BeforeLog"/>

    <!--方式一：使用原生Spring API接口-->
    <!--配置aop:先在头部导入aop的约束-->
    <aop:config>
        <!--切入点 expression:表达式 expression:匹配要执行的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
        <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

测试代码：

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口
        UserService userService = (UserService)context.getBean("userService");
        userService.add();
        userService.delete();
        userService.update();
        userService.select();
    }
}

运行结果：

方式二：自定义类来实现AOP

目标业务类不变依旧是userServiceImpl，首先， 写我们自己的一个切入类：

public class DiyPointCut {
    public void before(){
        System.out.println("==========方法执行==========");
    }

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

去Spring中配置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
       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.kuang.service.UserServiceImpl"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>
    <bean id="beforeLog" class="com.kuang.log.BeforeLog"/>

    <!--方式二：自定义类-->
    <!--注册bean-->
    <bean id="diy" class="com.kuang.diy.DiyPointCut"/>
    <!--aop的配置-->
    <aop:config>
        <!--第二种方式：使用AOP的标签实现-->
        <aop:aspect ref="diy">
            <!--切入点-->
            <aop:pointcut id="point" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before pointcut-ref="point" method="before"/>
            <aop:after pointcut-ref="point" method="after"/>
        </aop:aspect>
    </aop:config>

</beans>

测试代码：

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口
        UserService userService = (UserService)context.getBean("userService");
        userService.add();
        userService.delete();
        userService.update();
        userService.select();
    }
}

运行结果：

方式三：使用注解实现AOP

首先，编写一个注解实现的增强类：

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());
        //执行方法
        Object proceed = jp.proceed();
        System.out.println("环绕后！");
        System.out.println(proceed);
    }
}

在Spring配置文件中，注册bean，并增加支持注解的配置：

<?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.kuang.service.UserServiceImpl"/>
    <!--方式三-->
    <bean id="annotationPointCut" class="com.kuang.diy.AnnotationPointCut"/>
    <!--开启注解支持-->
    <aop:aspectj-autoproxy proxy-target-class="true"/>

</beans>

测试代码：

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口
        UserService userService = (UserService)context.getBean("userService");
        userService.add();
    }
}

运行结果：

整合MyBatis

首先，导入jar包：

<?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>spring-study</artifactId>
        <groupId>com.kuang</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>spring-10-mybatis</artifactId>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <!--Spring操作数据库需要导入一个spring-jdbc的包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <!--aspectj AOP 织入器-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <!--Spring-mybatis 整合包-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
    </dependencies>
    <!--配置maven静态资源过滤问题-->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
    </build>
</project>

编写配置文件：

<?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核心配置文件-->
<configuration>

    <typeAliases>
        <package name="com.kuang.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?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="1314520sky"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="com/kuang/mapper/UserMapper.xml"/>
    </mappers>

</configuration>

测试代码：

public class MyTest {
    @Test
    public void test() throws IOException {
        String resources = "mybatis-config.xml";
        InputStream in = Resources.getResourceAsStream(resources);
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sessionFactory.openSession(true);

        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = userMapper.selectUser();
        for (User user : userList) {
            System.out.println(user);
        }

        sqlSession.close();
    }
}

运行结果：

Mybatis-Spring 学习

什么是 MyBatis-Spring?

MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。

我们先需要掌握这个前置知识！！！

整合方式 1

主要步骤：

• 引入Spring配置文件applicationContext.xml
• 编写数据源配置，替换mybatis的数据源
• 配置sqlSessionFactory，，关联mybatis
• 注册sqlSessionTemplate，关联sqlSessionFactory
• 增加接口实现类，私有化sqlSessionTemplate
• 注册bean实现
• 测试代码

配置文件：

<?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">

    <!--DataSource:使用Spring 的数据源 替换 Mybatis的数据源
    可以使用Spring提供的JDBC：org.springframework.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?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="1314520sky"/>
    </bean>

    <!--salSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--绑定mybatis配置文件-->
        <property name="configLocation" value="classpath:                mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/kuang/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.kuang.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>
</beans>

接口实现类：

public class UserMapperImpl implements UserMapper {
    //我们的所有操作，原来都是使用的SqlSession来执行
    //现在都是用SqlSessionTemplate来完成
    private SqlSessionTemplate sqlSession;
    public void setSqlSession(SqlSessionTemplate sqlSession){
        this.sqlSession = sqlSession;
    }
    public List<User> selectUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

测试代码：

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper userMapper = context.getBean("userMapper",UserMapper.class);
        for (User user : userMapper.selectUser()){
            System.out.println(user);
        }
    }
}

整合方式 2

声明式事务

事务在项目开发过程非常重要，涉及到数据的一致性的问题，不容马虎！事务管理是企业级应用程序开发中必备技术，用来确保数据的完整性和一致性。

事务就是把一系列的动作当成一个独立的工作单元，这些动作要么全部完成，要么全部不起作用。

事务四个属性ACID：

• 原子性(atomicity)：事务是原子性操作，由-系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用。
• 一致性 (consistency)：一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中。
• 隔离性(isolation)：可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来,防止数据损坏。
• 持久性(durability)：事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中。

案例1：

创建一个User类：

@AllArgsConstructor
@NoArgsConstructor
@Data
public class User {
    private int id;
    private String name;
    private String pwd;
}

创建UserMapper接口：

public interface UserMapper {
    public List<User> selectUser();
    public int addUser(User user);
    public int deleteUser(int id);
}

配置Mapper文件，故意把delete写错，进行测试：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--configuration核心配置文件-->
<mapper namespace="com.kuang.mapper.UserMapper">
    <select id="selectUser" resultType="com.kuang.pojo.User">
        select * from mybatis.user
    </select>

    <select id="addUser" resultType="com.kuang.pojo.User">
        insert into mybatis.user (id,name,pwd) values (#{id},#{name},#{pwd});
    </select>

    <select id="deleteUser" resultType="int">
        deletesssss from mybatis.user where id = #{id}
        <!--这里的语句是错误的，一般来说我们的语句就无法执行成功！-->
    </select>
</mapper>

编写接口的实现类，在实现类中去操作一波~：

public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
    public List<User> selectUser() {

        User user = new User(7,"Seven","7777777");

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

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

        return mapper.selectUser();
    }

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

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

运行结果：

我们发现，运行报错: sq|异常, 这很正常，因为delete写错了！ 但是，数据库结果:插入成功!

这就是因为，没有进行事务的管理，我们想让他们都成功才成功，有一个失败， 就都失败，我们就应该需要进行事务管理!

Spring中的事务管理

以前我们都需要自己手动管理事务，十分麻烦!但是Spring给我们提供了事务管理，我们只需要配置即可。

Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程 式事务管理和声明式的事务管理。

编程式事务管理

• 将事务管理代码嵌到业务方法中来控制事务的提交和回滚
• 缺点:必须在每个事务操作业务逻辑中包含额外的事务管理代码

声明式事务管理

• 一般情况下比编程式事务好用。
• 将事务管理代码从业务方法中分离出来，以以明的方式来实现事务管理。
• 将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持
  声明式事务管理。

步骤：

• 使用Spring管理事务，注意头文件的约束导入：tx
• 事务管理器，无论使用Spring的哪种事务管理策略，事务管理器都是必须的。（就是Spring的核心事务管理抽象，封装了一组独立于技术的方法）
• 配置好事务管理器后，我们需要去配置事务的通知。Spring的事务传播特性如下图所示：
  
• 配置AOP

测试结果：

为什么需要配置事务?

●如果不配置，就需要我们手动提交控制事务;

●事务在项目开发过程非常重要，涉及到数据的一致性的问题，不容马虎!