Spring全栈式轻量级开源框架②

最新推荐文章于 2022-08-25 15:15:31 发布

Iliuhu

最新推荐文章于 2022-08-25 15:15:31 发布

阅读量133

点赞数 1

分类专栏：框架文章标签： spring

本文链接：https://blog.csdn.net/liu_to_liu/article/details/118161193

版权

框架专栏收录该内容

13 篇文章 0 订阅

订阅专栏

Spring全栈式轻量级开源框架之Spring AOP

一转账案例
二 Proxy优化转账案例
三初识AOP
四基于XML的AOP开发
五基于注解的AOP开发
六 AOP优化转账案例

一转账案例

需求

使用spring框架整合DBUtils技术，实现用户转账功能

1.1 基础功能

步骤分析

1. 创建java项目，导入坐标
2. 编写Account实体类
3. 编写AccountDao接口和实现类
4. 编写AccountService接口和实现类
5. 编写spring核心配置文件
6. 编写测试代码

在这里插入图片描述

1）创建java项目，导入依赖

<?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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.myProject</groupId>
    <artifactId>spring_transfer</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.9</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.6</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

</project>

2）编写Account实体类

package com.myProject.domain;

public class Account {
    private Integer id;
    private String name;
    private Double money;

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }
}

3）编写AccountDao接口和实现类

package com.myProject.dao;

public interface AccountDao {
    // 转出操作
    public void out (String outUser,Double money);
    // 转入操作
    public void in(String inUser,Double money);
}

package com.myProject.dao.impl;

import com.myProject.dao.AccountDao;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.sql.SQLException;

@Repository("accountDao") // 生成该类实例存到IOC容器中
public class AccountDaoImpl implements AccountDao {
    @Autowired
    private QueryRunner queryRunner;

    // 转出操作
    @Override
    public void out(String outUser, Double money) {
        String sql = "update account set money = money - ? where name = ?";
        try {
            queryRunner.update(sql, money, outUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 转入操作
    @Override
    public void in(String inUser, Double money) {
        String sql = "update account set money = money + ? where name = ?";
        try {
            queryRunner.update(sql, money, inUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

4）编写AccountService接口和实现类

package com.myProject.service;

public interface AccountService {
    // 转账方法
    public  void transfer(String outUser, String inUser, Double money);
}

package com.myProject.service.impl;

import com.myProject.dao.AccountDao;
import com.myProject.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("accountService")
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;
    // 转账方法
    @Override
    public void transfer(String outUser, String inUser, Double money) {
        // 调用了减钱方法
        accountDao.out(outUser, money);

        // 调用了加钱方法
        accountDao.in(inUser, money);
    }
}

5）编写spring核心配置文件

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

    <!--开启注解扫描-->
    <context:component-scan base-package="com.myProject" />

    <!--引入properties文件-->
    <context:property-placeholder location="classpath:jdbc.properties" />
    <!--配置DataSource-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>
    <!--配置QueryRunner-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
        <constructor-arg name="ds" ref="dataSource" />
    </bean>
</beans>

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring_db
jdbc.username=root
jdbc.password=root

6）编写测试代码

package com.myProject.test;

import com.myProject.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() {

        accountService.transfer("tom","jerry", 100d);
    }
}

7）问题分析

上面的代码事务在dao层，转出转入操作都是一个独立的事务，但实际开发，应该把业务逻辑控制在一个事务中，所以应该将事务挪到service层。

1.2 传统事务

步骤分析

1. 编写线程绑定工具类
2. 编写事务管理器
3. 修改service层代码
4. 修改dao层代码

在这里插入图片描述

1）编写线程绑定工具类

package com.myProject.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * 连接工具类： 从数据源中获取一个连接，并且将获取到的连接与线程进行绑定
 *      ThreadLocal: 线程内部的存储类，可以在指定的线程内存储数据
 *                  key: ThreadLocal  value:任意类型的值 Connection
 */
@Component
public class ConnectionUtils {
    @Autowired
    private DataSource dataSource;

    private ThreadLocal<Connection> threadLocal = new ThreadLocal<>();

    /**
     * 获取当前线程上绑定的连接： 如果获取到的链接为空，那么就要从数据源中获取连接，并且放到ThreadLocal中（绑定到当前线程）
     */
    public Connection getThreadConnection() {
        // 1.先从ThreadLocal上获取连接
        Connection connection = threadLocal.get();

        // 2. 判断当前线程中是否有Connection
        if (connection == null) {
            // 3.从数据源中获取一个连接，并且存入ThreadLocal中
            try {
                connection = dataSource.getConnection();
                threadLocal.set(connection);
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }

        }
        return connection;
    }

    /**
     * 解除当前线程的连接绑定
     */
    public void removeThreadConnection() {
        threadLocal.remove();
    }
}

在这里插入图片描述

2）编写事务管理器

package com.myProject.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.sql.Connection;
import java.sql.SQLException;

/**
 * 事务管理器工具类： 包含：开启事务、提交事务、回滚事务、释放事务
 */
@Component
public class TransactionManager {
    @Autowired
    private ConnectionUtils connectionUtils;

    // 开启事务
    public void beginTransaction() {
        // 获取connection对象
        Connection connection = connectionUtils.getThreadConnection();

        try {
            // 开启了一个手动事务
            connection.setAutoCommit(false);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    // 提交事务
    public void commit() {
        Connection connection = connectionUtils.getThreadConnection();

        try {
            connection.commit();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    // 回滚事务
    public void rollback() {
        Connection connection = connectionUtils.getThreadConnection();

        try {
            connection.rollback();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    // 释放资源
    public void release() {
        Connection connection = connectionUtils.getThreadConnection();

        try {
            // 将手动事务改回自动提交事务
            connection.setAutoCommit(true);
            // 将连接归还到连接池
            connectionUtils.getThreadConnection().close();
            // 解除线程绑定
            connectionUtils.removeThreadConnection();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}

3）修改service层代码

package com.myProject.service.impl;

import com.myProject.dao.AccountDao;
import com.myProject.service.AccountService;
import com.myProject.utils.TransactionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("accountService")
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    @Autowired
    private TransactionManager transactionManager;

    // 转账方法
    @Override
    public void transfer(String outUser, String inUser, Double money) {
        // 手动开启事务：调用事务管理器类中的开启事务方法
        transactionManager.beginTransaction();

        try {
            // 调用了减钱方法
            accountDao.out(outUser, money);

//            int i = 1/0;

            // 调用了加钱方法
            accountDao.in(inUser, money);

            // 手动提交事务
            transactionManager.commit();
        } catch (Exception e) {
            e.printStackTrace();

            // 手动回滚事务
            transactionManager.rollback();
        } finally {
            // 手动释放事务
            transactionManager.release();
        }
    }
}

4）修改dao层代码

package com.myProject.dao.impl;

import com.myProject.dao.AccountDao;
import com.myProject.utils.ConnectionUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.sql.SQLException;

@Repository("accountDao") // 生成该类实例存到IOC容器中
public class AccountDaoImpl implements AccountDao {
    @Autowired
    private QueryRunner queryRunner;

    @Autowired
    private ConnectionUtils connectionUtils;

    // 转出操作
    @Override
    public void out(String outUser, Double money) {
        String sql = "update account set money = money - ? where name = ?";
        try {
            queryRunner.update(connectionUtils.getThreadConnection(), sql, money, outUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 转入操作
    @Override
    public void in(String inUser, Double money) {
        String sql = "update account set money = money + ? where name = ?";
        try {
            queryRunner.update(connectionUtils.getThreadConnection(), sql, money, inUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

5）编写测试代码

package com.myProject.test;

import com.myProject.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() {

        accountService.transfer("tom","jerry", 100d);
    }
}

6）问题分析

上面代码，通过对业务层改造，已经可以实现事务控制了，但是由于我们添加了事务控制，也产生了一个新的问题：业务层方法变得臃肿了，里面充斥着很多重复代码。并且业务层方法和事务控制方法耦合了，违背了面向对象的开发思想。

二 Proxy优化转账案例

我们可以将业务代码和事务代码进行拆分，通过动态代理的方式，对业务方法进行事务的增强。这样就不会对业务层产生影响，解决了耦合性的问题啦！

常用的动态代理技术

1、JDK 代理 : 基于接口的动态代理技术·：利用拦截器（必须实现invocationHandler）加上反射机制生成一个代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理，从而实现方法增强

2、CGLIB代理：基于父类的动态代理技术：动态生成一个要代理的子类，子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截技术拦截所有的父类方法的调用，顺势织入横切逻辑，对方法进行增强

在这里插入图片描述

2.1 JDK动态代理方式

1）Jdk工厂类

package com.myProject.proxy;

import com.myProject.service.AccountService;
import com.myProject.utils.TransactionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

/**
 * JDK动态代理工厂类
 */
@Component
public class JDKProxyFactory {
    @Autowired
    private AccountService accountService;

    @Autowired
    private TransactionManager transactionManager;
    /**
     * 采用JDK动态代理技术来生成目标类的代理对象
     *      ClassLoader loader: 类加载器：借助被代理对象获取到类加载器
     *      Class<?>[] interfaces: 被代理类所需要事项的全部接口
     *      InvocationHandler h: 当代理对象调用接口中的任意方法时，那么就会执行InvocationHandler中invoke方法
     */
    public AccountService createAccountServiceJDKProxy() {
        AccountService accountServiceProxy = (AccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(), accountService.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                try {
                    // 手动开启事务：调用事务管理器类中的开启事务方法
                    transactionManager.beginTransaction();

                    // 让被代理对象的原方法执行
                    method.invoke(accountService,args);// 手动开启事务：调用事务管理器类中的开启事务方法

                    // 手动提交事务
                    transactionManager.commit();
                } catch (Exception e) {
                    e.printStackTrace();

                    // 手动回滚事务
                    transactionManager.rollback();
                } finally {
                    // 手动释放事务
                    transactionManager.release();
                }

                return null;
            }
        });
        return accountServiceProxy;
    }
}

2）测试代码

package com.myProject.test;

import com.myProject.proxy.JDKProxyFactory;
import com.myProject.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountServiceTest {
    @Autowired
    private JDKProxyFactory jdkProxyFactory;
    /**
     * 测试JDK动态代理优化转账案例
     */
    @Test
    public void testTransferProxyJDK() {
        // 当前返回的实际上是AccountService的代理对象proxy
        AccountService accountServiceJDKProxy = jdkProxyFactory.createAccountServiceJDKProxy();

        // 代理对象proxy调用接口中的任意方法时，都会执行底层的invoke方法
        accountServiceJDKProxy.transfer("tom", "jerry", 100d);
    }
}

2.2 CGLIB动态代理方式

1）Cglib工厂类

package com.myProject.proxy;

import com.myProject.service.AccountService;
import com.myProject.utils.TransactionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * 该类就是采用cglib动态代理来对目标类进行方法的动态增强
 */
@Component
public class CglibProxyFactory {
    @Autowired
    private AccountService accountService;

    @Autowired
    private TransactionManager transactionManager;
    public AccountService createAccountServiceCglibProxy() {
        // 编写cglib对应的API来生成代理对象进行返回
        // 参数1：accountService.getClass(): 目标类的字节码对象；
        // 参数2：动作类，当代理对象调用目标对象中原方法时，那么会执行
        AccountService accountServiceProxy = (AccountService) Enhancer.create(accountService.getClass(), new MethodInterceptor() {
            // o: 代表生成的代理对象， method:调用目标方法的引用， objects 方法入参， methodProxy: 代理方法
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                try {
                    // 手动开启事务：调用事务管理器类中的开启事务方法
                    transactionManager.beginTransaction();

                    method.invoke(accountService,objects);

                    // 手动提交事务
                    transactionManager.commit();
                } catch (Exception e) {
                    e.printStackTrace();

                    // 手动回滚事务
                    transactionManager.rollback();
                } finally {
                    // 手动释放事务
                    transactionManager.release();
                }
                return null;
            }
        });
        return accountServiceProxy;
    }
}

2）测试代码

package com.myProject.test;

import com.myProject.proxy.CglibProxyFactory;
import com.myProject.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountServiceTest {
    @Autowired
    private CglibProxyFactory cglibProxyFactory;
    /**
     * 测试Cglib动态代理优化转账案例
     */
    @Test
    public void testTransferProxyCglib() {
        // accountServiceCglibProxy: proxy代理对象
        AccountService accountServiceCglibProxy = cglibProxyFactory.createAccountServiceCglibProxy();
        accountServiceCglibProxy.transfer("tom", "jerry", 100d);
    }
}

三初识AOP

AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程
AOP 是 OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

这样做的好处是：

在程序运行期间，在不修改源码的情况下对方法进行功能增强
逻辑清晰，开发核心业务的时候，不必关注增强业务的代码
减少重复代码，提高开发效率，便于后期维护

3.2 AOP底层实现

实际上，AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

3.3 AOP相关术语

Spring 的 AOP 实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。

在正式讲解 AOP 的操作之前，我们必须理解 AOP 的相关术语，常用的术语如下：

* Target（目标对象）：代理的目标对象

* Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类

* Joinpoint（连接点）：所谓连接点是指那些可以被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点

* Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义

* Advice（通知/ 增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知
分类：前置通知、后置通知、异常通知、最终通知、环绕通知

* Aspect（切面）：是切入点和通知（引介）的结合

* Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入

在这里插入图片描述

3.4 AOP开发明确事项

3.4.1 开发阶段（我们做的）

编写核心业务代码（目标类的目标方法）切入点
把公用代码抽取出来，制作成通知（增强功能方法）通知
在配置文件中，声明切入点与通知间的关系，即切面

3.4.2 运行阶段（Spring框架完成的）

Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

3.4.3 底层代理实现

在 Spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

当bean实现接口时，会用JDK代理模式
当bean没有实现接口，用cglib实现（可以强制使用cglib（在spring配置中加入<aop:aspectj-autoproxy proxyt-target-class=”true”/>）

3.5 知识小结

* aop：面向切面编程

* aop底层实现：基于JDK的动态代理 和 基于Cglib的动态代理

* aop的重点概念：
	Pointcut（切入点）：真正被增强的方法
	Advice（通知/ 增强）：封装增强业务逻辑的方法
	Aspect（切面）：切点+通知
	Weaving（织入）：将切点与通知结合，产生代理对象的过程

四基于XML的AOP开发

4.1 快速入门

步骤分析

1. 创建java项目，导入AOP相关坐标
2. 创建目标接口和目标实现类（定义切入点）
3. 创建通知类及方法（定义通知）
4. 将目标类和通知类对象创建权交给spring
5. 在核心配置文件中配置织入关系，及切面
6. 编写测试代码

在这里插入图片描述

4.1.1 创建java项目，导入AOP相关坐标

<?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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.myProject</groupId>
    <artifactId>spring_aop_xml</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!--导入spring的context坐标，context依赖aop-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <!-- aspectj的织入（切点表达式需要用到该jar包） -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <!--spring整合junit-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
</project>

4.1.2 创建目标接口和目标实现类

package com.myProject.service;

public interface AccountService {
    /**
     * 目标方法： （切入点：要进行拦截增强的方法）
     */
    public void transfer();
}

package com.myProject.service.impl;

import com.myProject.service.AccountService;

public class AccountServiceImpl implements AccountService {
    /**
     * 目标方法： （切入点：要进行拦截增强的方法）
     */
    @Override
    public void transfer() {
        System.out.println("转账方法执行了。。。 ");
    }
}

4.1.3 创建通知类

package com.myProject.advice;

/**
 * 通知类
 */
public class MyAdvice {
    public void before() {
        System.out.println("前置通知执行了。。。");
    }
}

4.1.4 将目标类和通知类对象创建权交给spring

<!--目标类交给IOC容器-->
<bean id="accountService" class="com.myProject.service.impl.AccountServiceImpl"></bean>

<!--通知类交 给IOC容器-->
<bean id="myAdvice" class="com.myProject.advice.MyAdvice"> </bean>

4.1.5 在核心配置文件中配置织入关系，及切面

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

    <!--目标类交给IOC容器-->
    <bean id="accountService" class="com.myProject.service.impl.AccountServiceImpl"></bean>

    <!--通知类交 给IOC容器-->
    <bean id="myAdvice" class="com.myProject.advice.MyAdvice"> </bean>

    <!--AOP配置-->
    <aop:config>
        <!--配置切面： 切入点+通知-->
        <aop:aspect ref="myAdvice">
            <!--配置目标类的transfer方法执行时，使用myadvice类中before方法做一个前置增强-->
            <aop:before method="before" pointcut="execution(public void com.myProject.service.impl.AccountServiceImpl.transfer())"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

4.1.6 编写测试代码

package com.myProject.test;

import com.myProject.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() {
        accountService.transfer();
    }
}

4.2 XML配置AOP详解

4.2.1 切点表达式

表达式语法：

execution([修饰符] 返回值类型 包名.类名.方法名(参数))

访问修饰符可以省略
返回值类型、包名、类名、方法名可以使用星号 * 代替，代表任意
包名与类名之间一个点 . 代表当前包下的类，两个点 … 表示当前包及其子包下的类
参数列表可以使用两个点 … 表示任意个数，任意类型的参数列表

例如：

execution(public void com.myProject.service.impl.AccountServiceImpl.transfer())

execution(void com.myProject.service.impl.AccountServiceImpl.*(..))

execution(* com.myProject.service.impl.*.*(..))

execution(* com.myProject.service..*.*(..))

切点表达式抽取

当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用 pointcut-ref 属性代替
pointcut 属性来引用抽取后的切点表达式。

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

    <!--目标类交给IOC容器-->
    <bean id="accountService" class="com.myProject.service.impl.AccountServiceImpl"></bean>

    <!--通知类交 给IOC容器-->
    <bean id="myAdvice" class="com.myProject.advice.MyAdvice"> </bean>

    <!--AOP配置-->
    <aop:config>
        <!--抽取切点表达式 把重复代码进行抽取，方便维护-->
        <aop:pointcut id="myPointcut" expression="execution(* com.myProject.service.impl.AccountServiceImpl.*(..))"/>
        <!--配置切面： 切入点+通知-->
        <aop:aspect ref="myAdvice">
            <aop:before method="before" pointcut-ref="myPointcut"></aop:before>
            <aop:after-returning method="afterReturning" pointcut-ref="myPointcut"></aop:after-returning>
        </aop:aspect>

        <!--配置切面： 切入点+通知-->
        <!--<aop:aspect ref="myAdvice">-->
        <!--配置目标类的transfer方法执行时，使用myadvice类中before方法做一个前置增强-->
        <!--<aop:before method="before" pointcut="execution(public void com.myProject.service.impl.AccountServiceImpl.transfer())"></aop:before>-->
        <!--<aop:after-returning method="afterReturning" pointcut="execution(* com.myProject.service.impl.AccountServiceImpl.*(..))"></aop:after-returning>-->
        <!--</aop:aspect>-->
    </aop:config>
</beans>

4.2.2 通知类型

通知的配置语法：

<aop:通知类型 method=“通知类中方法名” pointcut=“切点表达式"></aop:通知类型>

名称	标签	说明
前置通知	`<aop:before>`	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	`<aop:afterReturning>`	用于配置后置通知。指定增强的方法在切入点方法之后执行
异常通知	`<aop:afterThrowing>`	用于配置异常通知。指定增强的方法出现异常后执行
最终通知	`<aop:after>`	用于配置最终通知。无论切入点方法执行时是否有异常，都会执行
环绕通知	`<aop:around>`	用于配置环绕通知。开发者可以手动控制增强代码在什么时候执行

1）创建目标接口和目标实现类

package com.myProject.service;

public interface AccountService {
    /**
     * 目标方法： （切入点：要进行拦截增强的方法）
     */
    public void transfer();
}

package com.myProject.service.impl;

import com.myProject.service.AccountService;

public class AccountServiceImpl implements AccountService {
    /**
     * 目标方法： （切入点：要进行拦截增强的方法）
     */
    @Override
    public void transfer() {
        System.out.println("转账方法执行了。。。 ");
        int i = 1/0;
    }
}

2）创建通知类

package com.myProject.advice;

/**
 * 通知类
 */
public class MyAdvice {
    public void before() {
        System.out.println("前置通知执行了。。。");
    }

    public void afterReturning() {
        System.out.println("后置通知执行了。。。");
    }

    public void afterThrowing() {
        System.out.println("异常通知执行了。。。");
    }

    public void after() {
        System.out.println("最终通知执行了。。。");
    }
}

3）在核心配置文件中配置织入关系，及切面

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

    <!--目标类交给IOC容器-->
    <bean id="accountService" class="com.myProject.service.impl.AccountServiceImpl"></bean>

    <!--通知类交 给IOC容器-->
    <bean id="myAdvice" class="com.myProject.advice.MyAdvice"> </bean>

    <!--AOP配置-->
    <aop:config>
        <!--抽取切点表达式 把重复代码进行抽取，方便维护-->
        <aop:pointcut id="myPointcut" expression="execution(* com.myProject.service.impl.AccountServiceImpl.*(..))"/>
        <!--配置切面： 切入点+通知-->
        <aop:aspect ref="myAdvice">
            <!--前置通知-->
            <aop:before method="before" pointcut-ref="myPointcut"></aop:before>
            <!--后置通知-->
            <aop:after-returning method="afterReturning" pointcut-ref="myPointcut"></aop:after-returning>
            <!--异常通知-->
            <aop:after-throwing method="afterThrowing" pointcut-ref="myPointcut"></aop:after-throwing>
            <!--最终通知-->
            <aop:after method="after" pointcut-ref="myPointcut"></aop:after>
         </aop:aspect>
    </aop:config>
</beans>

4）编写测试代码

package com.myProject.test;

import com.myProject.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() {
        accountService.transfer();
    }
}

4.2.3 环绕通知类型

注意：通常情况下，环绕通知都是独立使用的

1）创建通知类

package com.myProject.advice;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 通知类
 */
public class MyAdvice {
    // ProceedingJoinPoint: 正在执行的连接点：切点
    public Object around(ProceedingJoinPoint pjp) {
        Object proceed = null;

        // 切点方法执行
        try {
            System.out.println("前置通知执行了。。。");
            proceed = pjp.proceed();
            System.out.println("后置通知执行了。。。");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("异常通知执行了。。。");
        } finally {
            System.out.println("最终通知执行了。。。");
        }
        return null;
    }
}

2）在核心配置文件中配置织入关系，及切面

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

    <!--目标类交给IOC容器-->
    <bean id="accountService" class="com.myProject.service.impl.AccountServiceImpl"></bean>

    <!--通知类交 给IOC容器-->
    <bean id="myAdvice" class="com.myProject.advice.MyAdvice"> </bean>

    <!--AOP配置-->
    <aop:config>
        <!--抽取切点表达式 把重复代码进行抽取，方便维护-->
        <aop:pointcut id="myPointcut" expression="execution(* com.myProject.service.impl.AccountServiceImpl.*(..))"/>
        <!--配置切面： 切入点+通知-->
        <aop:aspect ref="myAdvice">
            <!--环绕通知-->
            <aop:around method="around" pointcut-ref="myPointcut"></aop:around>
         </aop:aspect>
    </aop:config>
</beans>

4.3 知识小结

* aop织入的配置
	<aop:config>
		<aop:aspect ref=“通知类”>
			<aop:before method=“通知方法名称” pointcut=“切点表达式"></aop:before>
		</aop:aspect>
</aop:config>

* 通知的类型
	前置通知、后置通知、异常通知、最终通知
	环绕通知
	
* 切点表达式
	execution([修饰符] 返回值类型 包名.类名.方法名(参数))

五基于注解的AOP开发

5.1 快速入门

步骤分析

1. 创建java项目，导入AOP相关坐标
2. 创建目标接口和目标实现类（定义切入点）
3. 创建通知类（定义通知）
4. 将目标类和通知类对象创建权交给spring
5. 在通知类中使用注解配置织入关系，升级为切面类
6. 在配置文件中开启组件扫描和 AOP 的自动代理
7. 编写测试代码

在这里插入图片描述

5.1.1 创建java项目，导入AOP相关坐标

<?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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.myProject</groupId>
    <artifactId>spring_aop_anno</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!--导入spring的context坐标，context依赖aop-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <!-- aspectj的织入 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <!--spring整合junit-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
</project>

5.1.2 创建目标接口和目标实现类

package com.myProject.service;

public interface AccountService {
    public void transfer();
}

package com.myProject.service.impl;

import com.myProject.service.AccountService;
import org.springframework.stereotype.Service;

@Service
public class AccountServiceImpl implements AccountService {
    @Override
    public void transfer() {
        System.out.println("转账方法执行了。。。");
    }
}

5.1.3 创建通知类

package com.myProject.advice;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
 * 通知类
 */
@Component
@Aspect // 升级为切面类： 配置切入点和通知的关系
public class MyAdvice {
    @Before("execution(* com.myProject.service.impl.AccountServiceImpl.*(..))")
    public void before() {
        System.out.println("前置通知执行了。。。");
    }
}

5.1.4 将目标类和通知类对象创建权交给spring

@Service
public class AccountServiceImpl implements AccountService {}


@Component
public class MyAdvice {}

5.1.5 在通知类中使用注解配置织入关系，升级为切面类

package com.myProject.advice;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
 * 通知类
 */
@Component
@Aspect // 升级为切面类： 配置切入点和通知的关系
public class MyAdvice {
    @Before("execution(* com.myProject.service.impl.AccountServiceImpl.*(..))")
    public void before() {
        System.out.println("前置通知执行了。。。");
    }
}

5.1.6 在配置文件中开启组件扫描和 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"
       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/aop http://www.springframework.org/schema/aop/spring-aop.xsd
                          http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
">

    <!--开启IOC注解扫描-->
    <context:component-scan base-package="com.myProject"></context:component-scan>

    <!--开启AOP的自动代理: spring会采用动态代理完成织入增强，并且生成代理
        proxy-target-class="true"：强制使用cglib动态代理
    -->
    <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
</beans>

5.1.7 编写测试代码

package com.myProject.test;

import com.myProject.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void transfer() {
        accountService.transfer();
    }
}

5.2 注解配置AOP详解

5.2.1 切点表达式

切点表达式的抽取

package com.myProject.advice;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 通知类
 */
@Component
@Aspect // 升级为切面类： 配置切入点和通知的关系
public class MyAdvice {
    // 有重复代码,切点表达式的抽取
    @Pointcut("execution(* com.myProject.service.impl.AccountServiceImpl.*(..))")
    public void myPoint() {}

//    @Before("execution(* com.myProject.service.impl.AccountServiceImpl.*(..))")
    @Before("MyAdvice.myPoint()")
    public void before() {
        System.out.println("前置通知执行了。。。");
    }

//    @AfterReturning("execution(* com.myProject.service.impl.AccountServiceImpl.*(..))")
    @AfterReturning("MyAdvice.myPoint()")
    public void afterReturning() {
        System.out.println("后置通知执行了。。。");
    }
//    @AfterThrowing("execution(* com.myProject.service.impl.AccountServiceImpl.*(..))")
    @AfterThrowing("MyAdvice.myPoint()")
    public void afterThrowing() {
        System.out.println("异常通知执行了。。。");
    }

//    @After("execution(* com.myProject.service.impl.AccountServiceImpl.*(..))")
    @After("MyAdvice.myPoint()")
    public void after() {
        System.out.println("最终通知执行了。。。");
    }

    @Around("MyAdvice.myPoint()")
    public Object around(ProceedingJoinPoint pjp) {
        try {
            System.out.println("前置通知执行了。。。");
            Object proceed = pjp.proceed();
            System.out.println("后置通知执行了。。。");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("异常通知执行了。。。");
        } finally {
            System.out.println("最终通知执行了。。。");
        }

        return null;
    }
}

5.2.2 通知类型

通知的配置语法：@通知注解(“切点表达式")

名称	标签	说明
前置通知	@Before	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	@AfterReturning	用于配置后置通知。指定增强的方法在切入点方法之后执行
异常通知	@AfterThrowing	用于配置异常通知。指定增强的方法出现异常后执行
最终通知	@After	用于配置最终通知。无论切入点方法执行时是否有异常，都会执行
环绕通知	@Around	用于配置环绕通知。开发者可以手动控制增强代码在什么时候执行

注意：

当前四个通知组合在一起时，执行顺序如下：
@Before -> @After -> @AfterReturning（如果有异常：@AfterThrowing）

1）前置、后置、异常、最终通知

package com.myProject.advice;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 通知类
 */
@Component
@Aspect // 升级为切面类： 配置切入点和通知的关系
public class MyAdvice {
    // 有重复代码,切点表达式的抽取
    @Pointcut("execution(* com.myProject.service.impl.AccountServiceImpl.*(..))")
    public void myPoint() {}

//    @Before("execution(* com.myProject.service.impl.AccountServiceImpl.*(..))")
    @Before("MyAdvice.myPoint()")
    public void before() {
        System.out.println("前置通知执行了。。。");
    }

//    @AfterReturning("execution(* com.myProject.service.impl.AccountServiceImpl.*(..))")
    @AfterReturning("MyAdvice.myPoint()")
    public void afterReturning() {
        System.out.println("后置通知执行了。。。");
    }
//    @AfterThrowing("execution(* com.myProject.service.impl.AccountServiceImpl.*(..))")
    @AfterThrowing("MyAdvice.myPoint()")
    public void afterThrowing() {
        System.out.println("异常通知执行了。。。");
    }

//    @After("execution(* com.myProject.service.impl.AccountServiceImpl.*(..))")
    @After("MyAdvice.myPoint()")
    public void after() {
        System.out.println("最终通知执行了。。。");
    }
}

2）环绕通知（手动控制通知顺序）

package com.myProject.advice;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 通知类
 */
@Component
@Aspect // 升级为切面类： 配置切入点和通知的关系
public class MyAdvice {
    // 有重复代码,切点表达式的抽取
    @Pointcut("execution(* com.myProject.service.impl.AccountServiceImpl.*(..))")
    public void myPoint() {}

    @Around("MyAdvice.myPoint()")
    public Object around(ProceedingJoinPoint pjp) {
        try {
            System.out.println("前置通知执行了。。。");
            Object proceed = pjp.proceed();
            System.out.println("后置通知执行了。。。");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("异常通知执行了。。。");
        } finally {
            System.out.println("最终通知执行了。。。");
        }
        return null;
    }
}

5.2.3 纯注解配置

使用纯注解开发，applicationContext.xml核心配置就不需要了

1）编写spring核心配置文件

package com.myProject.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan("com.myProject") // 替换核心配置的注解扫描（context:component-scan）
@EnableAspectJAutoProxy // 开启AOP的自动代理 替代了aop:aspectj-autoproxy标签
public class SpringConfig {}

2）编写通知类

package com.myProject.advice;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 通知类
 */
@Component
@Aspect // 升级为切面类： 配置切入点和通知的关系
public class MyAdvice {
    // 有重复代码,切点表达式的抽取
    @Pointcut("execution(* com.myProject.service.impl.AccountServiceImpl.*(..))")
    public void myPoint() {}

    @Around("MyAdvice.myPoint()")
    public Object around(ProceedingJoinPoint pjp) {
        try {
            System.out.println("前置通知执行了。。。");
            Object proceed = pjp.proceed();
            System.out.println("后置通知执行了。。。");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("异常通知执行了。。。");
        } finally {
            System.out.println("最终通知执行了。。。");
        }

        return null;
    }
}

3）编写测试代码

package com.myProject.test;

import com.myProject.config.SpringConfig;
import com.myProject.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void transfer() {
        accountService.transfer();
    }
}

5.3 知识小结

* 使用@Aspect注解，标注切面类

* 使用@Before等注解，标注通知方法

* 使用@Pointcut注解，抽取切点表达式

* 配置aop自动代理 <aop:aspectj-autoproxy/> 或 @EnableAspectJAutoProxy

六 AOP优化转账案例

依然使用前面的转账案例，将两个代理工厂对象直接删除！改为spring的aop思想来实现

6.1 xml配置实现

1）导入AOP相关依赖

<?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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.myProject</groupId>
    <artifactId>spring_transfer</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.9</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.6</version>
        </dependency>
        <!-- aspectj的织入 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.6</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
</project>

2）配置文件

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

    <!--开启注解扫描-->
    <context:component-scan base-package="com.myProject" />

    <!--引入properties文件-->
    <context:property-placeholder location="classpath:jdbc.properties" />
    <!--配置DataSource-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>
    <!--配置QueryRunner-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
        <constructor-arg name="ds" ref="dataSource" />
    </bean>

    <!--配置AOP-->
    <aop:config>
        <!--切面表达式-->
        <aop:pointcut id="myPointcut" expression="execution(* com.myProject.service.impl.AccountServiceImpl.*(..))"/>

        <!--切面配置-->
        <aop:aspect ref="transactionManager">
            <aop:before method="beginTransaction" pointcut-ref="myPointcut"></aop:before>
            <aop:after-returning method="commit" pointcut-ref="myPointcut"></aop:after-returning>
            <aop:after-throwing method="rollback" pointcut-ref="myPointcut"></aop:after-throwing>
            <aop:after method="release" pointcut-ref="myPointcut"></aop:after>
        </aop:aspect>
    </aop:config>
</beans>

jdbc.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring_db
jdbc.username=root
jdbc.password=root

3）事务管理器（通知）

package com.myProject.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.sql.Connection;
import java.sql.SQLException;

/**
 * 事务管理器工具类： 包含：开启事务、提交事务、回滚事务、释放事务
 * 通知类
 */
@Component("transactionManager")
public class TransactionManager {
    @Autowired
    private ConnectionUtils connectionUtils;

    // 开启事务
    public void beginTransaction() {
        // 获取connection对象
        Connection connection = connectionUtils.getThreadConnection();

        try {
            // 开启了一个手动事务
            connection.setAutoCommit(false);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    // 提交事务
    public void commit() {
        Connection connection = connectionUtils.getThreadConnection();

        try {
            connection.commit();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    // 回滚事务
    public void rollback() {
        Connection connection = connectionUtils.getThreadConnection();

        try {
            connection.rollback();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    // 释放资源
    public void release() {
        Connection connection = connectionUtils.getThreadConnection();

        try {
            // 将手动事务改回自动提交事务
            connection.setAutoCommit(true);
            // 将连接归还到连接池
            connectionUtils.getThreadConnection().close();
            // 解除线程绑定
            connectionUtils.removeThreadConnection();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}

4）创建目标接口和目标实现类

package com.myProject.test;

import com.myProject.proxy.JDKProxyFactory;
import com.myProject.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;


    @Test
    public void testTransfer() {

        accountService.transfer("tom","jerry", 100d);
    }
}

package com.myProject.service.impl;

import com.myProject.dao.AccountDao;
import com.myProject.service.AccountService;
import com.myProject.utils.TransactionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("accountService")
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    // 转账方法 切入点 添加上事务控制的效果
    @Override
    public void transfer(String outUser, String inUser, Double money) {
        // 调用了减钱方法
        accountDao.out(outUser, money);

        int i = 1/0;

        // 调用了加钱方法
        accountDao.in(inUser, money);
    }

    @Override
    public void save() {
        System.out.println("save方法");
    }

    @Override
    public void update() {
        System.out.println("update方法");
    }

    @Override
    public void delete() {
        System.out.println("delete方法");
    }
}

5）编写测试类

package com.myProject.test;

import com.myProject.proxy.JDKProxyFactory;
import com.myProject.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;


    @Test
    public void testTransfer() {

        accountService.transfer("tom","jerry", 100d);
    }
}

6.2 注解配置实现

1）配置文件

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

    <!--开启注解扫描-->
    <context:component-scan base-package="com.myProject" />

    <!--引入properties文件-->
    <context:property-placeholder location="classpath:jdbc.properties" />
    <!--配置DataSource-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>
    <!--配置QueryRunner-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
        <constructor-arg name="ds" ref="dataSource" />
    </bean>

    <!--开启自动代理-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

2）事务管理器（通知）

package com.myProject.utils;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 事务管理器工具类： 包含：开启事务、提交事务、回滚事务、释放事务
 * 通知类
 */
@Component("transactionManager")
@Aspect // 该类为切面类
public class TransactionManager {
    @Autowired
    private ConnectionUtils connectionUtils;

    // 环绕通知
    @Around("execution(* com.myProject.service.impl.AccountServiceImpl.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Exception{
        Object proceed = null;
        try {
            // 开启手动事务
            connectionUtils.getThreadConnection().setAutoCommit(false);

            // 切入点方法执行
            proceed = pjp.proceed();

            // 手动提交事务
            connectionUtils.getThreadConnection().commit();
        } catch (Throwable throwable) {
            throwable.printStackTrace();

            // 手动会滚事务
            connectionUtils.getThreadConnection().rollback();

        } finally {
            // 将手动事务改回自动提交事务
            connectionUtils.getThreadConnection().setAutoCommit(true);
            // 将连接归还到连接池
            connectionUtils.getThreadConnection().close();
            // 解除线程绑定
            connectionUtils.removeThreadConnection();
        }
        return proceed;
    }
}

Iliuhu

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring全栈式轻量级开源框架②

@TOC# 系列文章目录提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加例如：第一章 Python 机器学习入门之pandas的使用提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结前言提示：这里可以添加本文要记录的大概内容：例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例
复制链接

扫一扫