初识spring（二）AOP

最新推荐文章于 2025-04-02 20:16:15 发布

忘记578

最新推荐文章于 2025-04-02 20:16:15 发布

阅读量722

点赞数 26

文章标签： spring java 后端

本文链接：https://blog.youkuaiyun.com/weixin_66196728/article/details/133082344

版权

场景模拟

代理模式

它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用（先调用代理对象的方法，减少对目标方法的调用和打扰)，同时让附加功能能够集中在一起也有利于统一维护。

使用代理后

静态代理

public interface Calculator {
    int add(int i, int j);
    int sub(int i, int j);
    int mul(int i, int j);
    int div(int i, int j);
}


public class CalculatorImpl implements Calculator{
    @Override
    public int add(int i, int j) {
        int result = i+j;
        System.out.println("方法内部，result："+result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i-j;
        System.out.println("方法内部，result："+result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i*j;
        System.out.println("方法内部，result："+result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i/j;
        System.out.println("方法内部，result："+result);
        return result;
    }
}

//创建静态代理类：

public class CalculatorStaticProxy implements Calculator {
    // 将被代理的目标对象声明为成员变量
    private CalculatorImpl target;

    public CalculatorStaticProxy(CalculatorImpl target) {
        this.target = target;
    }

    @Override
    public int add(int i, int j) {
        // 附加功能由代理类中的代理方法来实现
        System.out.println("日志，方法：add，参数："+i+","+j);
        // 通过目标对象来实现核心业务逻辑
        int result = target.add(i, j);
        System.out.println("日志，方法：add，结果："+result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        System.out.println("日志，方法：sub，参数："+i+","+j);
        int result = target.add(i, j);
        System.out.println("日志，方法：sub，结果："+result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        System.out.println("日志，方法：mul，参数："+i+","+j);
        int result = target.add(i, j);
        System.out.println("日志，方法：mul，结果："+result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        System.out.println("日志，方法：div，参数："+i+","+j);
        int result = target.add(i, j);
        System.out.println("日志，方法：div，结果："+result);
        return result;
    }
}

测试

public class ProxyTest {
    @Test
    public void testProxy(){
        CalculatorStaticProxy proxy = new CalculatorStaticProxy(new CalculatorImpl());
        proxy.add(1,2);
    }
}

(静态代理确实实现了解耦，但是由于代码都写死了，完全不具备任何的灵活性。）

动态代理

public class ProxyFactory {
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    public Object getProxy(){
        /**
         * newProxyInstance()：创建一个代理实例
         * 其中有三个参数：
         * 1、classLoader：加载动态生成的代理类的类加载器(指定加载动态生成的代理类的类加载器），这里是应用类加载器（因为是获取自定义类）
         * 2、interfaces：目标对象实现的所有接口的class对象所组成的数组
         * 3、invocationHandler：设置代理对象实现目标对象方法的过程，即代理类中如何重写接
         口中的抽象方法
         */
        ClassLoader classLoader = this.getClass().getClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                /**
                 * proxy：代理对象
                 * method：代理对象需要实现的方法，即其中需要重写的方法
                 * args：method所对应方法的参数
                 */
                System.out.println("日志，方法："+method.getName()+"，参数："+ Arrays.toString(args));
                Object result = method.invoke(target,args);//target是代理对象
                System.out.println("日志，方法："+method.getName()+"，结果："+result);
                return result;
            }
        };
        return Proxy.newProxyInstance(classLoader,interfaces,invocationHandler );
    }
}

测试

public void testProxy(){
        ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
        Calculator proxy = (Calculator) proxyFactory.getProxy();
        proxy.add(1,2);
    }
}

再在核心代码周围添加一些内容

 InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                /**
                 * proxy：代理对象
                 * method：代理对象需要实现的方法，即其中需要重写的方法
                 * args：method所对应方法的参数
                 */
                Object result = null;
                try {
                    System.out.println("日志，方法："+method.getName()+"，参数："+ Arrays.toString(args));
                    result = method.invoke(target,args);
                    System.out.println("日志，方法："+method.getName()+"，结果："+result);
                }  catch (Exception e) {
                   e.printStackTrace();
                    System.out.println("日志，方法："+method.getName()+"，异常："+result);
                } finally {
                    System.out.println("日志，方法："+method.getName()+"，方法执行完毕");
                }
                return result;
            }
        };

代理模式再如：

（先看一下静态代理的例子

interface ClothFactory{
    void produceCloth();
}
//代理类
class ProxyClothFactory implements ClothFactory{
    private ClothFactory factory;//用被代理类对象进行实例化
    public ProxyClothFactory(ClothFactory factory){
        this.factory = factory;
    }

    @Override
    public void produceCloth() {
        System.out.println("代理工厂做一些准备工作");
        factory.produceCloth();
        System.out.println("代理工厂做一些后续的收尾工作");
    }
}

//被代理类
class NikeClothFactory implements ClothFactory{

    @Override
    public void produceCloth() {
        System.out.println("nick工厂生产一批服装");
    }
}
public class StaticProxyTest {
    public static void main(String[] args) {
        //创建被代理类的对象
        NikeClothFactory nick = new NikeClothFactory();
        //创建代理类的对象
        ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nick);
        proxyClothFactory.produceCloth();
        //代理工厂做一些准备工作
        //nick工厂生产一批服装
        //代理工厂做一些后续的收尾工作
    }
}

动态

interface Human{
    String getBelief();
    void eat(String food);
}

//被代理类
class SuperMan implements Human{

    @Override
    public String getBelief() {
        return "I believe I can!";
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃"+food);
    }
}

/*
要想实现动态代理，需要解决的问题
问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象
二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a（下面的MyInvocationHandler实现了

 */

//生产代理类的工厂
class ProxyFactory{
    //调用此方法，返回一个代理类的对象，解决问题一
     public static Object getProxyInstance(Object obj){//obj:被代理类对象
         MyInvocationHandler handler = new MyInvocationHandler();
         handler.bind(obj);//将被代理类对象传到MyInvocationHandler类中使用
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
//    Proxy.newProxyInstance创建一个代理类的对象，
//         1、obj.getClass().getClassLoader()是获取被代理类的加载器）  是哪个类加载的，调用类的加载器获取（
//         2、obj.getClass().getInterfaces() 是获取被代理类实现的接口
//         3、handler 对应参数InvocationHandler  其是一个接口，我们在下面实现用类继承该接口

     }
}


class MyInvocationHandler implements InvocationHandler{

    private Object obj;//需要使用被代理类的对象进行赋值（这里采用的是bind，创建方法的形式去赋值，也可以是设置一个被代理类对象为参数的构造器

    public void bind(Object obj){
        this.obj=obj;
    }
    //当我们通过代理类的对象，调用方法a时，就会自动的调动如下的方法：invoke（）
    //将被代理类要执行的方法a的功能就声明在invoke（）中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//Object proxy 代理类对象   被代理类调用的和代理类调用的同名方法    Object[] args 调用方法中的参数
        

        //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        Object returnValue = method.invoke(obj, args);
        //上述方法的返回值就作为当前类中invoke（）的返回值
        return  returnValue;

    }
}

public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        //proxyInstance：代理类的对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时，会自动的调用被代理类中同名方法
        String belief = proxyInstance.getBelief();
        System.out.println(belief);
        proxyInstance.eat("辣条");
        System.out.println("-----------------");

        NikeClothFactory nikeClothFactory = new NikeClothFactory();
        ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
        proxyClothFactory.produceCloth();
    }
}

（newProxyInstance方法中的参数如图所示）

运行结果如下，最后一个是调用之前写的静态代理去动态实现。

（补充：

动态代理分两种：

1、jdk动态代理：要求必须有接口，最终生成的代理类和目标类实现相同的接口，生成代理类在com.sun.proxy包下，类名为$proxy2

2、cglib动态代理，最终生成的代理类会基础目标类，并且和目标类在相同包下

AOP概念及相关术语

概述
AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。

相关术语
①横切关注点

从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。
这个概念不是语法层面天然存在的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点。

②通知
每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。
前置通知：在被代理的目标方法前执行
返回通知：在被代理的目标方法成功结束后执行（寿终正寝）
异常通知：在被代理的目标方法异常结束后执行（死于非命）
后置通知：在被代理的目标方法最终结束后执行（盖棺定论）
环绕通知：使用try...catch...finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所
有位置
③切面
封装通知方法的类。

④目标
被代理的目标对象。
⑤代理
向目标对象应用通知之后创建的代理对象。
⑥连接点
这也是一个纯逻辑概念，不是语法定义的。
把方法排成一排，每一个横切位置看成x轴方向，把方法从上到下执行的顺序看成y轴，x轴和y轴的交叉点就是连接点。

⑦切入点
定位连接点的方式。
每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。
如果把连接点看作数据库中的记录，那么切入点就是查询记录的 SQL 语句。
Spring 的 AOP 技术可以通过切入点定位到特定的连接点。
切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

（在aop优化代码时，就是从横切点抽出代码去封装成一个切面类，然后切面类的业务重新套回目标时，就是连接点。）

基于注解的AOP

如图为技术说明

创建一个maven工程

添加如下依赖

 <dependencies>
        <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.1</version>
        </dependency>
        <!-- junit测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- spring-aspects会帮我们传递过来aspectjweaver -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.3.1</version>
        </dependency>
    </dependencies>

在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:context="http://www.springframework.org/schema/context"
       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/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--
    基于注解的AOP的实现：
    1、将目标对象和切面交给IOC容器管理（注解+扫描）
    2、开启AspectJ的自动代理，为目标对象自动生成代理
    3、将切面类通过注解@Aspect标识
    -->
    <context:component-scan base-package="personal.october.annotation"></context:component-scan>
    <!-- 开启基于注解的aop功能 -->
    <aop:aspectj-autoproxy/>
</beans>

创建切面类并配置

// @Aspect表示这个类是一个切面类(将当前组件标识为切面）
@Aspect
// @Component注解保证这个切面类能够放入IOC容器
@Component
public class LoggerAspect {
    @Before("execution(public int personal.october.annotation.CalculatorImpl.add(int, int))")
    public void beforeMethod(){
        System.out.println("Logger-->前置通知");
    }
}

测试类

public class AOPTest {
    @Test
    public void testAOPByAnnotation(){
        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator calculator = ioc.getBean(Calculator.class);
        calculator.mul(1,2);
    }
}

切入点表达式语法

如上代码中切入点表达式（其设置在标识通知的注解value属性中）

"execution(public int personal.october.annotation.CalculatorImpl.add(int, int))"只能在add方法中调用，只作用于add方法，
@Before("execution(* personal.october.annotation.CalculatorImpl.*(..))")表示任意修饰符，返回类型，在personal.october.annotation包下的CalculatorImpl类中的所有方法，任意返回值类型，当然如果由需求在所有类中，则可以将类名换成*，变成@Before("execution(* personal.october.annotation.*.*(..))")

重用切入点表达式

当要使用多个通知时，如果切入点表达式一样还要写多次，有点麻烦，

@Pointcut("execution(* personal.october.annotation.CalculatorImpl.*(..))")
    public void point(){}
//    @Before("execution(* personal.october.annotation.CalculatorImpl.*(..))")
    //@Pointcut声明一个公共的切入点表达式，
    //使用方式@Before("方法名()”)
    @Before("point()")
    public void beforeMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect，方法名："+signature.getName()+"，参数："+ Arrays.toString(args));
        }

（在切面中，需要通过指定的注解将方法标识为通知方法，如下@Before等）

前置通知：使用@Before注解标识，在被代理的目标方法前执行
返回通知：使用@AfterReturning注解标识，在被代理的目标方法成功结束后执行（寿终正寝）
异常通知：使用@AfterThrowing注解标识，在被代理的目标方法异常结束后执行（死于非命）
后置通知：使用@After注解标识，在被代理的目标方法最终结束后执行（盖棺定论）
环绕通知：使用@Around注解标识，使用try...catch...finally结构围绕整个被代理的目标方法，包
括上面四种通知对应的所有位置

总的来说就是

@Before，在目标对象方法执行之前执行

@After，在目标对象方法的finally子句中执行

@AfterReturning，在目标对象方法返回值之前执行

@AfterThrowing，在目标对象方法的catch子句中执行

获取通知的相关信息

①获取连接点信息

在通知方法的参数位置，设置JoinPoint类型的参数，就可以获取父节点所对应方法的信息

@Before("execution(* personal.october.annotation.CalculatorImpl.*(..))")
    public void beforeMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect，方法名："+signature.getName()+"，参数："+ Arrays.toString(args));
        }

（签名信息是方法的声明信息，比如访问修饰符，返回值类型，方法名，参数等）

②获取目标方法的返回值

/*
          @AfterReturning中的属性returning，用来将通知方法的某个形参，接收目标方法的返回值
         */
        @AfterReturning(value ="point()",returning ="result")
         public  void afterReturningMethod(JoinPoint joinPoint,Object result){
            Signature signature = joinPoint.getSignature();
            System.out.println("LoggerAspect，方法名："+signature.getName()+"，结果："+ result);
        }

③获取目标方法的异常

/*
          @AfterThrowing中的属性throwing，用来将通知方法的某个形参，接收目标方法的异常
         */
        @AfterThrowing(value = "point()",throwing ="ex")
        public void afterThrowingAdviceMethod(JoinPoint joinPoint,Throwable ex){
            Signature signature = joinPoint.getSignature();
            System.out.println("LoggerAspect，方法名："+signature.getName()+"，异常："+ ex);
        }

环绕通知（注意环绕通知的方法返回值是目标对象方法的返回值类型）

 @Around("point()")
       public Object aroundAdviceMethod(ProceedingJoinPoint joinPoint){
            Object result=null;
            try {
                System.out.println("环绕通知--》前置通知");
                result = joinPoint.proceed();
                System.out.println("环绕通知--》返回通知");
            } catch (Throwable e) {
                e.printStackTrace();
                System.out.println("环绕通知--》异常通知");
            }finally {
                System.out.println("环绕通知--》后置通知");
            }
            return result;
        }

切面的优先级

如上下两图前置通知的输出顺序比较，可以知道

优先级可以通过注解@Order来改变，改变@Order注解的value值，注意是int型数据

且默认值为Interger最大值，其属性值越小，优先级越高

各种通知

基于XML的AOP（了解）

在xml配置文件中设置各种通知，切入点表达式等（注意之前添加的aop的注解要删掉）


    <!--扫描组件-->
    <context:component-scan base-package="personal.october.xml"></context:component-scan>

    <aop:config>
        <!--设置一个公共的切入点表达式-->
        <aop:pointcut id="point" expression="execution(* personal.october.xml.CalculatorImpl.*(..))"/>
        <!--将IOC容易中的某个bean设置为切面-->
        <aop:aspect ref="loggerAspect">
            <aop:before method="beforeMethod" pointcut-ref="point"></aop:before>
            <aop:after-returning method="afterReturningMethod"  returning="result" pointcut-ref="point"></aop:after-returning>
            <aop:after-throwing method="afterThrowingAdviceMethod" throwing="ex" pointcut-ref="point"></aop:after-throwing>
            <aop:around method="aroundAdviceMethod" pointcut-ref="point"></aop:around>
        </aop:aspect>
    </aop:config>

测试

public class AOPXMLTest {
    @Test
    public void testByXML(){
        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("aop-xml.xml");
        Calculator calculator = ioc.getBean(Calculator.class);
        calculator.add(1,7);

    }
}

声明式事务

JdbcTemplate

准备工作，创建一个maven工程

添加依赖

 <dependencies>
        <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.1</version>
        </dependency>
        <!-- Spring 持久化层支持jar包 -->
        <!-- Spring 在执行持久化层操作、与持久化层技术进行整合过程中，需要使用orm、jdbc、tx三个
        jar包 -->
        <!-- 导入 orm 包就可以通过 Maven 的依赖传递性把其他两个也导入 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.3.1</version>
        </dependency>
        <!-- Spring 测试相关 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.1</version>
        </dependency>
        <!-- junit测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- MySQL驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>
        <!-- 数据源 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.31</version>
        </dependency>
    </dependencies>

xml配置文件内容

 <!--引入jdbc.properties -->
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <bean class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

插入

//指定当前测试类在spring的测试环境中执行，此时就可以通过注入的方式直接获取IOC容器中的bean
@RunWith(SpringJUnit4ClassRunner.class)
//设置spring测试环境的配置文件
@ContextConfiguration("classpath:spring-jdbc.xml")
public class testJdbcTemplate {

    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Test
    public void testInsert(){
        String sql="insert into t_user values(null,?,?,?,?,?)";
        jdbcTemplate.update(sql,"root","1234",23,"男","147844@qq.com");
    }
}

查询操作

 public void testSelect(){
        String sql="select * from t_user where id=?";
        User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(User.class),1);
        System.out.println(user);
    }

BeanPropertyRowMapper<>(User.class)设置要映射的对象类型

查询多个数据

 public void testSelectALL(){
        String sql="select * from t_user";
        List<User> userList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
        System.out.println(userList);
    }

查询单条数据（如下查询结果为2，如下第二个参数是Integer.class表示返回值的对象的类)

public void testSelectCount(){
        String sql="select count(*) from t_user";
        Integer integer = jdbcTemplate.queryForObject(sql, Integer.class);
        System.out.println(integer);
    }

声明式事务概念

准备工作（新建两张表

CREATE TABLE `t_book` (
`book_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
`book_name` varchar(20) DEFAULT NULL COMMENT '图书名称',
`price` int(11) DEFAULT NULL COMMENT '价格',
`stock` int(10) unsigned DEFAULT NULL COMMENT '库存（无符号）',
PRIMARY KEY (`book_id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
insert into `t_book`(`book_id`,`book_name`,`price`,`stock`) values (1,'斗破苍
穹',80,100),(2,'斗罗大陆',50,100);
CREATE TABLE `t_user` (
`user_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
`username` varchar(20) DEFAULT NULL COMMENT '用户名',
`balance` int(10) unsigned DEFAULT NULL COMMENT '余额（无符号）',
PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
insert into `t_user`(`user_id`,`username`,`balance`) values (1,'admin',50);

基于注解的声明式事务

测试无事务情况

当前项目层级如下

（上面spring-jdbc.xml配置文件是之前用的，在事务这里用的是下面的tx那个配置文件

其配置文件内容如下

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

    <!--扫描组件 -->
    <context:component-scan base-package="personal.december.aop"></context:component-scan>

    <!--引入jdbc.properties -->
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <bean class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
</beans>

相关代码如下

controller包下

@Controller
public class BookController {
    @Autowired
    private BookService bookService;
    public void buyBook(Integer userId,Integer bookId){
       bookService.buyBook(userId,bookId);
    }
}

service包下

public interface BookService {
    void buyBook(Integer userId, Integer bookId);
}

impl包下
@Service
public class BookServiceImpl implements BookService {
    @Autowired
    private BookDao bookDao;
    @Override
    public void buyBook(Integer userId, Integer bookId) {
        //查询图书的价格
        Integer price=bookDao.getPriceByBookId(bookId);
        //更新图书的库存
        bookDao.updateStock(bookId);
        //更新用户的余额
        bookDao.updateBanlance(userId,price);
    }
}

dao包下

public interface BookDao {

    Integer getPriceByBookId(Integer bookId);

    void updateStock(Integer bookId);

    void updateBanlance(Integer userId, Integer price);
}

impl包下
@Repository
public class BookDaoImpl implements BookDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public Integer getPriceByBookId(Integer bookId) {
        String sql = "select price from t_book where book_id=?";
        return jdbcTemplate.queryForObject(sql,Integer.class,bookId);
    }

    @Override
    public void updateStock(Integer bookId) {
        String sql ="update t_book set stock= stock-1 where book_id=?";
        jdbcTemplate.update(sql,bookId);
    }

    @Override
    public void updateBanlance(Integer userId, Integer price) {
        String sql ="update t_user set balance = balance-? where user_id=?";
        jdbcTemplate.update(sql,price,userId);
    }
}

pojo包下

public class User {
    private Integer id;
    private String username;
    private String password;
    private Integer age;
    private String gender;
    private String email;

    public User(Integer id, String username, String password, Integer age, String gender, String email) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
        this.gender = gender;
        this.email = email;
    }

    public User() {
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

当我们测试运行时

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:tx-annotation.xml")
public class TxByAnnotationTest {
    @Autowired
    private BookController bookController;

    @Test
    public void test(){
        bookController.buyBook(1,1);
    }
}

发现如下报错

因为我们对balance设置了无符号数，当数额不够时相减则会报错（余额只有50，但是需要买的的书是80），因为数据库默认是自动提交事务，所以每个sql语句独占一个事务，上述三个方法，前两成功不被第三个购买失败的事务影响，这时我们可以发现即使买书失败了，库存仍会-1。

针对这种情况，我们应该把上述方法放在一个事务中，当有异常则回滚。我们可以通过配置声明事务来实现

配置声明式事务的步骤

1、在spring的配置文件中配置事务管理器

2、开启事务的注解驱动

 <!-- 配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--开启事务的注解驱动
         将使用@Transaction注解所标识的方法或类中的所有方法使用事务进行管理
         transaction-manager属性的值为事务管理器的id
         如果id为默认的transactionManager，则该属性可以不写，
      -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

注意：导入的名称空间需要 tx 结尾的那个

在需要被事务管理的方法上，添加@Transactional注解，该方法就会被事务管理

（关于@Transactional注解标识的位置：可以标识在方法上，也可以标识在类上（则类中所有方法都会被事务管理））

如下标识

因为service层表示业务逻辑层，一个方法表示一个完成的功能，因此处理事务一般在service层处理，所以在BookServiceImpl的buybook()添加注解@Transactional

虽然执行后还是会报错，但是在购买失败后，书的数量则不会改变。

事务属性：只读

事务属性：超时

超时回滚，释放资源。。timeout属性是用来设置事务的超时时间。如果将timeout属性设置为-1，根据Spring的事务管理默认设置，这意味着事务将不会超时。

上图timeout=3意为如果事务在3秒内没有完成，那么事务将会失败。

事务属性：回滚策略

上图意思是当购买图书功能中出现了数学运算异常（ArithmeticException），我们设置的回滚策略是，当出现ArithmeticException不发生回滚，因此购买图书的操作正常执行

事务属性：事务隔离级别

一个事务与其他事务隔离的程度称为隔离级别。SQL标准中规定了多种事务隔离级别，不同隔离级别对应不同的干扰程度，隔离级别越高，数据一致性就越好，但并发性越弱。

事务属性：事务传播行为

基于XML的声明式事务

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

    <!--扫描组件 -->
    <context:component-scan base-package="personal.december.aop"></context:component-scan>

    <!--引入jdbc.properties -->
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <bean class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--开启事务的注解驱动
         将使用@Transaction注解所标识的方法或类中的所有方法使用事务进行管理
         transaction-manager属性的值为事务管理器的id
         如果id为默认的transactionManager，则该属性可以不写，
      -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:tx-xml.xml")
public class TxByXMLTest {
    @Autowired
    private BookController bookController;
    @Test
    public void testByXMl(){
        bookController.buyBook(1,2);
    }
}