SSM之Sping系列（五）---- Spring中AOP的引入及相关概念
文章目录
- AOP的引入
-
- 案例中存在的问题
- 解决办法
- 新的问题
- 新问题的解决
-
- 动态代理介绍
- 基于接口的动态代理
- 基于子类的动态代理
- Spring 中的 AOP
-
- 什么是 AOP
- AOP 中的术语
- 学习 spring 中的 AOP 要明确的事
AOP的引入
在上一篇文章中传送门，我们做了一个账户的 CRUD 的小案例，在讲 AOP 之前，我们先来分析该案例，一步一步地了解为什么要有 AOP 以及什么是 AOP。
案例中存在的问题
- 回顾上篇文章中的业务层代码：
package com.cz.service.impl;
import com.cz.dao.AccountDao;
import com.cz.domain.Account;
import com.cz.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 账户的业务层实现类
*/
package com.cz.service.impl;
import com.cz.dao.AccountDao;
import com.cz.domain.Account;
import com.cz.service.AccountService;
import java.util.List;
/**
* 账户的业务层实现类
*/
public class AccountServiceImpl implements AccountService {
private AccountDao accountDao;
public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}
public List<Account> findAllAccount() {
return accountDao.findAllAccount();
}
public Account findAccountById(Integer accountId) {
return accountDao.findAccountById(accountId);
}
public void saveAccount(Account account) {
return accountDao.saveAccount(account);
}
public void updateAccount(Account account) {
return accountDao.updateAccount(account);
}
public void removeAccount(Integer accountId) {
return accountDao.removeAccount(accountId);
}
}
问题就是：
事务被自动提交了。换言之，我们使用了 connection对象的 setAutoCommit(true)此方式控制事务，如果我们每次都执行一条 sql 语句，没有问题，但是如果业务方法一次要执行多条 sql语句，这种方式就无法实现功能了。请看下面的演示：
- 修改业务层和持久层，添加一个转账方法
业务层：
/**
* 账户业务层接口
*/
public interface AccountService {
/**
* 转账
* @param sourceName 转出账户名称
* @param targetName 转入账户名称
* @param money 转账金额
*/
void transfer(String sourceName,String targetName,Float money);
}
/**
* 账户的业务层实现类
*/
public class AccountServiceImpl implements AccountService {
private AccountDao accountDao;
public void transfer(String sourceName, String targetName, Float money) {
//1.根据名称查询转出账户
Account source = accountDao.findAccountByName(sourceName);
//2.根据名称查询转入账户
Account target = accountDao.findAccountByName(targetName);
//3.转出账户减钱
source.setMoney(source.getMoney()-money);
//4.转入账户加钱
target.setMoney(target.getMoney()+money);
//5.更新转出账户
accountDao.updateAccount(source);
int i=1/0; //模拟转账异常
//6.更新转入账户
accountDao.updateAccount(target);
}
}
持久层：
/**
* 账户的持久层接口
*/
public interface AccountDao {
/**
* 根据名称查询账户
* @param accountName
* @return 如果有唯一结果，就返回。如果没有结果就返回null；
* 如果结果集超过一个就抛异常
*/
Account findAccountByName(String accountName);
}
/**
* 账户的持久层实现类
*/
public class AccountDaoImpl implements AccountDao {
public Account findAccountByName(String accountName) {
try{
List<Account> accounts = runner.query("select * from account where name = ?",new BeanListHandler<Account>(Account.class),accountName);
if (accounts == null || accounts.size() == 0){
return null;
}
if (accounts.size() > 1){
throw new RuntimeException("结果集不为1，数据异常");
}
return accounts.get(0);
}catch (Exception e){
throw new RuntimeException(e);
}
}
}
实现类：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {
@Autowired
private AccountService accountService;
@Test
public void testTransfer(){
accountService.transfer("张三","李四",200f);
}
}
由于执行有异常，转账失败。但是因为每次执行持久层方法都是独立事务，导致无法实现事务控制 （ 不符合事务的一致性）
解决办法
为了解决这个问题，我们可以让业务层来控制事务的提交和回滚。
首先我们先对业务层的实现类的代码进行分析：
- 创建工具类
ConnectionUtils，该类用于获取和线程绑定的Connection对象，保证每个线程中只能有一个控制事务的Connection对象
package com.cz.utils;
import javafx.scene.chart.PieChart;
import javax.sql.DataSource;
import java.sql.Connection;
/**
* 连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定
*/
public class ConnectionUtils {
private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
private DataSource dataSource;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
/**
* 获取当前线程上的连接
* @return
*/
public Connection getThreadConnection(){
try {
//1.先从ThredLocal获取
Connection conn = tl.get();
//2.判断当前线程上是否有连接
if (conn == null){
//3.从数据源上获取一个连接，并且存入ThreadLocal中
conn = dataSource.getConnection();
// 与当前线程绑定
tl.set(conn);
}
//4.返回当前线程上的连接
return conn;
}catch (Exception e){
throw new RuntimeException(e);
}
}
/**
* 将连接和线程解绑
*/
public void removeConnection() {
tl.remove();
}
}
- 创建事务控制类
TransactionManager
package com.cz.utils;
import java.sql.Connection;
/**
* 和事务管理相关的工具类，它包含了开启事务，提交事务，回滚事务和释放连接
*/
public class TransactionManager {
private ConnectionUtils connectionUtils;
public void setConnectionUtils(ConnectionUtils connectionUtils) {
this.connectionUtils = connectionUtils;
}
/**
* 开启事务
*/
public void beginTransaction(){
try{
connectionUtils.getThreadConnection().setAutoCommit(false);
}catch (Exception e){
e.printStackTrace();
}
}
/**
* 提交事务
*/
public void commit(){
try{
connectionUtils.getThreadConnection().commit();
}catch (Exception e){
e.printStackTrace();
}
}
/**
* 回滚事务
*/
public void rollback(){
try{
connectionUtils.getThreadConnection().rollback();
}catch (Exception e){
e.printStackTrace();
}
}
/**
* 释放连接
*/
public void release(){
try{
//将连接还回连接池
connectionUtils.getThreadConnection().close();
//将连接与线程解绑，防止下次使用报错。因为连接被关闭后不能再调用
connectionUtils.removeConnection();
}catch (Exception e){
e.printStackTrace();
}
}
}
要注意
release()方法中，因为使用连接池，所以调用Connection对象的close()方法后，是将连接归还到连接池中，所以要把连接与绑定的线程解绑，不然下次从线程池中取出该线程，并获取绑定的连接进行使用时，由于连接被调用过close()方法，会抛出异常You can't operate on a closed Connection（问题存在于 WEB 工程中）
- 修改业务层代码，为所有方法加上事务管理
package com.cz.service.impl;
import com.cz.dao.AccountDao;
import com.cz.domain.Account;
import com.cz.service.AccountService;
import com.cz.utils.TransactionManager;
import java.util.List;
/**
* 账户的业务层实现类
* 事务控制都在业务层
*/
public class AccountServiceImpl implements AccountService {
private AccountDao accountDao;
private TransactionManager tsManager;
public void setTsManager(TransactionManager tsManager) {
this.tsManager = tsManager;
}
public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}
public List<Account> findAllAccount() {
try{
//1.开启事务
tsManager.beginTransaction();
//2.执行操作
List<Account> accounts = accountDao.findAllAccount();
//3.提交事务
tsManager.commit();
//4.返回结果
return accounts;
}catch (Exception e){
//5.回滚操作
tsManager.rollback();
throw new RuntimeException(e);
}finally {
//6.释放连接
tsManager.release();
}
}
public Account findAccountById(Integer accountId) {
try{
//1.开启事务
tsManager.beginTransaction();
//2.执行操作
Account account = accountDao.findAccountById(accountId);
//3.提交事务
tsManager.commit();
//4.返回结果
return account;
}catch (Exception e){
//5.回滚操作
tsManager.rollback();
throw new RuntimeException(e);
}finally {
//6.释放连接
tsManager.release();
}
}
public void saveAccount(Account account) {
try{
//1.开启事务
tsManager.beginTransaction();
//2.执行操作
accountDao.saveAccount(account);
//3.提交事务
tsManager.commit();
}catch (Exception e){
//4.回滚操作
tsManager.rollback();
throw new RuntimeException(e);
}finally {
//5.释放连接
tsManager.release();
}
}
public void updateAccount(Account account) {
try{
//1.开启事务
tsManager.beginTransaction();
//2.执行操作
accountDao.updateAccount(account);
//3.提交事务
tsManager.commit();
}catch (Exception e){
//4.回滚操作
tsManager.rollback();
throw new RuntimeException(e);
}finally {
//5.释放连接
tsManager.release();
}
}
public void removeAccount(Integer accountId) {
try{
//1.开启事务
tsManager.beginTransaction();
//2.执行操作
accountDao.removeAccount(accountId);
//3.提交事务
tsManager.commit();
}catch (Exception e){
//4.回滚操作
tsManager.rollback();
throw new RuntimeException(e);
}finally {
//5.释放连接
tsManager.release();
}
}
public void transfer(String sourceName, String targetName, Float money) {
try{
//1.开启事务
tsManager.beginTransaction();
//2.执行操作
//2.1根据名称查询转出账户
Account source = accountDao.findAccountByName(sourceName);
//2.2根据名称查询转入账户
Account target = accountDao.findAccountByName(targetName);
//2.3转出账户减钱
source.setMoney(source.getMoney()-money);
//2.4转入账户加钱
target.setMoney(target.getMoney()+money);
//2.5更新转出账户
accountDao.updateAccount(source);
int i=1/0; //模拟转账异常
//2.6更新转入账户
accountDao.updateAccount(target);
//3.提交事务
tsManager.commit();
}catch (Exception e){
//4.回滚操作
tsManager.rollback();
}finally {
//5.释放连接
tsManager.release();
}
}
}
- 修改持久层代码，因为我们现在的
Connection对象是由ConnectionUtils工具类来提供的（与线程绑定），而不是让QueryRunner对象自动去连接池中取（没有与线程绑定），所以QueryRunner对象不再需要注入数据源了。
package com.cz.dao.impl;
import com.cz.dao.AccountDao;
import com.cz.domain.Account;
import com.cz.utils.ConnectionUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import java.util.List;
/**
* 账户的持久层实现类
*/
public class AccountDaoImpl implements AccountDao {
private QueryRunner runner;
private ConnectionUtils connectionUtils;
public void setConnectionUtils(ConnectionUtils connectionUtils) {
this.connectionUtils = connectionUtils;
}
public void setRunner(QueryRunner runner) {
this.runner = runner;
}
public List<Account> findAllAccount() {
try{
return runner.query(connectionUtils.getThreadConnection(),"select * from account",new BeanListHandler<Account>(Account.class));
}catch (Exception e){
throw new RuntimeException(e);
}
}
public Account findAccountById(Integer accountId) {
try{
return runner.query(connectionUtils.getThreadConnection(),"select * from account where id = ?",new BeanHandler<Account>(Account.class),accountId);
}catch (Exception e){
throw new RuntimeException(e);
}
}
public int saveAccount(Account account) {
try{
return runner.update(connectionUtils.getThreadConnection(),"insert into account(name,money)values(?,? )",account.getName(),account.getMoney());
}catch (Exception e){
throw new RuntimeException(e);
}
}
public int updateAccount(Account account) {
try{
return runner.update(connectionUtils.getThreadConnection(),"update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
}catch (Exception e){
throw new RuntimeException(e);
}
}
public int removeAccount(Integer accountId) {
try{
return runner.update(connectionUtils.getThreadConnection(),"delete from account where id=?",accountId);
}catch (Exception e){
throw new RuntimeException(e);
}
}
public Account findAccountByName(String accountName) {
try{
List<Account> accounts = runner.query(connectionUtils.getThreadConnection(),"select * from account where name = ?",new BeanListHandler<Account>(Account.class),accountName);
if (accounts == null || accounts.size() == 0){
return null;
}
if (accounts.size() > 1){
throw new RuntimeException("结果集不为1，数据异常");
}
return accounts.get(0);
}catch (Exception e){
throw new RuntimeException(e);
}
}
}
- 编写配置文件，管理依赖关系
<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">
<bean id="accountService" class="com.cz.service.impl.AccountServiceImpl">
<property name="accountDao" ref="accountDao">property>
<property name="tsManager" ref="tsManager"/>
bean>
<bean id="accountDao" class="com.cz.dao.impl.AccountDaoImpl">
<property name="runner" ref="runner">property>
<property name="connectionUtils" ref="connectionUtils"/>
bean>
<bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">bean>
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring?serverTimezone=UTC&characterEncoding=utf-8"/>
<property name="user" value="root"/>
<property name="password" value="7107883"/>
bean>
<bean id="connectionUtils" class="com.cz.utils.ConnectionUtils">
<property name="dataSource" ref="dataSource"/>
bean>
<bean id="tsManager" class="com.cz.utils.TransactionManager">
<property name="connectionUtils" ref="connectionUtils"/>
bean>
beans>
新的问题
通过对业务层加上事务控制，此时的转账方法已经可以正常运行，但是由于我们的业务层每个方法都加上了事务控制，所以显得业务层的方法特别臃肿，业务核心代码可能就 accountDao.removeAccount(accountId); 这么一句，其余的都是和事务有关，这样也就造成了业务层方法的耦合度很高。
如果此时我们的 TransactionManager 类中的方法名进行了更改，那么我们需要在每处调用的地方都进行修改，这样不利于我们后期的开发。
新问题的解决
那么如何解决呢？这里我们可以使用动态代理，把事务的控制交给代理对象,所以下面我们先来看看关于动态代理的基本使用。
动态代理介绍
之前在讲mybatis的入门案例的时候也给大家贴过两篇其他大佬写的动态代理，下面我们简单的了解一下，想深入的朋友可以去看看那两篇文章。
什么是动态代理：
简单来说就是使用反射动态创建代理对象，使用代理对象来代替目标对象，因此达到增强目标对象的功能
动态代理的特点
字节码随用随创建，随用随加载。它与静态代理的区别也在于此，因为静态代理是字节码一上来就创建好，并完成加载。装饰者模式就是静态代理的一种体现。
动态代理的常用两种方式
基于接口的动态代理
基于子类的动态代理
基于接口的动态代理
提供者：JDK 官方的 Proxy 类。
要求：被代理类最少实现一个接口。
-
在这里我们使用厂家的例子：以前厂家不仅要对产品进行售后处理，还得负责销售的环节，把产品卖给客户。但是随着时间的推移，出现了一个新的角色：代理商，这时候厂家只需要负责对产品的售后处理，销售的事情交给代理商即可。如果客户需要售后维修，那么只需要将产品交给代理商，由代理商送往厂家进行维修。如下图：
-
定义接口，表示厂家需要具备的功能（销售以及售后）
package com.cz.proxy;
/**
* 生产厂家需要实现的接口
*/
public interface IProducer {
/**
* 销售
* @param money
*/
void saleProduct(float money);
/**
* 售后
* @param money
*/
void afterService(float money);
}
- 定义厂家类
package com.cz.proxy;
/**
* 一个生产者
*/
public class Producer implements IProducer{
/**
* 销售
* @param money
*/
public void saleProduct(float money){
System.out.println("销售产品，并拿到钱：" +money);
}
/**
* 售后
* @param money
*/
public void afterService(float money){
System.out.println("提供售后服务，并拿到钱："+money);
}
}
- 定义测试类，进行动态代理
package com.cz.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 消费者
*/
public class Client {
public static void main(String[] args) {
//厂家
final Producer producer = new Producer();
// 该对象相当于代理商
IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
producer.getClass().getInterfaces(),
new InvocationHandler() {
/**
* 作用：执行被代理对象的任何方法都会被该方法拦截到
* @param proxy 代理对象的引用
* @param method 当前执行的方法
* @param args 当前执行方法所需的参数
* @return 返回值类型与被代理对象方法一致
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//提供增强代码
Object returnValue = null;
//1.获取方法执行的参数
Float money = (Float)args[0];
//2.判断当前方法是不是销售
if ("saleProduct".equals(method.getName())){
System.out.println("消费者花了 " + money + "元购买商品...");
// 对参数进行增强，代理商需要抽取 2 成利润
returnValue = method.invoke(producer,money*0.8f);
}
return returnValue;
}
});
proxyProducer.saleProduct(10000f);
}
}
- 运行结果如图
使用
Proxy.newProxyInstance()创建代理对象，参数如下：
ClassLoader：类加载器，用于加载代理对象字节码，和被代理对象使用相同的类加载器。固定写法：被代理对象.getClass().getClassLoader()Class[]：字节码数组，用于让代理对象和被代理对象具有相同的接口方法。固定写法：被代理对象.getClass().getInterfaces()InvocationHandler： 处理器，用于提供增强的代码，一般都是编写一个该接口的匿名内部类。此接口的实现类都是谁用谁写。
invoke()方法用于拦截被代理对象的方法，执行被代理对象的任何方法都会被该方法拦截到，参数如下：
Object proxy：代理对象的引用Method method：当前执行的方法Object[] args：当前执行方法所需的参数- 返回值类型与被代理对象方法一致
匿名内部类访问外部方法的成员变量时都要求外部成员变量添加
final修饰符，final修饰变量代表该变量只能被初始化一次，以后不能被修改。参考链接：
匿名内部类如何访问外部类的成员变量
匿名内部类访问方法成员变量需要加final的原因及证明
基于子类的动态代理
要求：被代理对象不能是最终类
- 还是使用上面的例子
- 基于子类的动态代理是使用第三方库
CGLIB提供的Enhancer类，要求被代理类不能是被final 修饰的类（最终类） - 导入第三方库依赖
CGLIB或者手动导入jar 包cglib-2.1.3.jar和asm.jar
<dependency>
<groupId>cglibgroupId>
<artifactId>cglibartifactId>
<version>2.1_3version>
dependency>
老样子，报错的看这两篇文章传送门1
传送门2
- 厂家类无需实现接口
package com.cz.cglib;
/**
* 一个生产者
*/
public class Producer{
/**
* 销售
* @param money
*/
public void saleProduct(float money){
System.out.println("销售产品，厂家拿到钱：" +money);
}
/**
* 售后
* @param money
*/
public void afterService(float money){
System.out.println("提供售后服务，并拿到钱："+money);
}
}
- 编写测试类
package com.cz.cglib;
import com.cz.proxy.IProducer;
import com.cz.proxy.Producer;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 消费者
*/
public class Client {
public static void main(String[] args) {
//厂家
final Producer producer = new Producer();
Producer cglibProducer = (Producer) Enhancer.create(producer.getClass(),
new MethodInterceptor() {
/**
*执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何方法进行增强。
* @param proxy
* @param method
* @param args
* 前三个和基于接口的动态代理是一样的。
* @param methodProxy 当前执行方法的代理对象。
* @return 当前执行方法的返回值
* @throws Throwable
*/
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
//提供增强代码
Object returnValue = null;
//1.获取方法执行的参数
Float money = (Float)args[0];
//2.判断当前方法是不是销售
if ("saleProduct".equals(method.getName())){
System.out.println("消费者花了 " + money + "元购买商品...");
// 对参数进行增强，代理商需要抽取 2 成利润
returnValue = method.invoke(producer,money*0.8f);
}
return returnValue;
}
});
cglibProducer.saleProduct(120000f);
}
}
- 使用
Enhancer.create()创建代理对象，参数如下：
Class： 字节码，用于指定被代理对象的字节码。固定写法：被代理对象.getClass()Callback： 回调接口，用于提供增强的代码，一般都是编写该接口的子接口实现类MethodInterceptorintercept()方法用于拦截被代理对象的方法，执行被代理对象的任何方法都会被该方法拦截到，参数如下：
Object proxy：代理对象的引用Method method：当前执行的方法Object[] args：当前执行方法所需的参数MethodProxy methodProxy：当前执行方法的代理对象- 返回值类型与被代理对象方法一致
动态代理的基本使用就讲到这了，接下来我们回归正题。如何解决问题：
- 修改业务层代码，将其恢复原样，不再添加事务的控制代码
- 创建代理工厂，用于获取 service 的代理对象
package com.cz.factory;
import com.cz.service.AccountService;
import com.cz.utils.TransactionManager;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 用于创建Service的代理对象的工厂
*/
public class BeanFactory {
private AccountService accountService;
private TransactionManager tsManager;
public void setTsManager(TransactionManager tsManager) {
this.tsManager = tsManager;
}
public final void setAccountService(AccountService accountService) {
this.accountService = accountService;
}
/**
* 获取Service代理对象
*/
public AccountService getAccountService() {
return (AccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(), accountService.getClass().getInterfaces(),
new InvocationHandler() {
/**
* 添加对事务的支持
*
* @param proxy
* @param method
* @param args
* @return
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object rtValue = null;
try {
//1.开启事务
tsManager.beginTransaction();
//2.执行操作
rtValue = method.invoke(accountService, args);
//3.提交事务
tsManager.commit();
//4.返回结果
return rtValue;
} catch (Exception e) {
//5.回滚操作
tsManager.rollback();
throw new RuntimeException(e);
} finally {
//6.释放连接
tsManager.release();
}
}
});
}
}
- 修改配置文件
<bean id="proxyAccountService" factory-bean="beanFactory" factory-method="getAccountService">bean>
<bean id="beanFactory" class="com.cz.factory.BeanFactory">
<property name="accountService" ref="accountService"/>
<property name="tsManager" ref="tsManager"/>
bean>
<bean id="accountService" class="com.cz.service.impl.AccountServiceImpl">
<property name="accountDao" ref="accountDao">property>
bean>
到这里的时候，改造已经完成，通过代理对象一样可以控制住事务，同时业务层不再需要编写一堆的重复事务控制代码。但是如果每次管理事务的时候，我们都要像这样自己创建代理对象，那不是也挺麻烦的吗？有没有更好的方法呢？这时候就需要 AOP 的出场了。
Spring 中的 AOP
什么是 AOP
- AOP 即面向切面编程，英文全称为 Aspect Oriented Programming
- 简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，
使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。
- 简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，
- 作用
在程序运行期间，不修改源码对已有方法进行增强。
- 优势
- 减少重复代码
- 提高开发效率
- 维护方便
AOP 中的术语
Joinpoint (连接点)
- 所谓连接点是指那些
被拦截到的方法，在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点 - 比如说，我们的业务层中的方法都是连接点，因为我们对业务层中的所有方法都进行了拦截
Pointcut (切入点)
-
所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义，简单来说就是
被增强的方法 -
比如说，我们在业务层新增了一个方法
test()，但是在代理工厂中，我们不对该方法进行增强，而是直接放行，那么此时的test()就不是切入点，仅仅是一个连接点，而其他的方法都被事务管理，也就是切入点
Advice (通知/ 增强)
- 所谓通知是指拦截到方法之后所要做的事情，简单来说就是
对切入点进行的增强操作 - 通知的类型：前置通知，后置通知，异常通知，最终通知，环绕通知
Introduction (引介)
- 引介是一种特殊的通知，在不修改类代码的前提下，Introduction 可以在运行期为类动态地添加一些方法或 Field
Target (目标对象)
- 被代理的对象
Weaving (织入)
- 是指把增强应用到目标对象来创建新的代理对象的过程
Proxy (代理)
- 一个类被 AOP 织入增强后，就产生一个结果代理类
Aspect (切面)
- 是切入点和通知（引介）的结合
学习 spring 中的 AOP 要明确的事
- 开发阶段（我们做的）
编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求。
把公用代码抽取出来，制作成通知。（开发阶段最后再做）：AOP 编程人员来做。
在配置文件中，声明切入点与通知间的关系，即切面。：AOP 编程人员来做。 - 运行阶段（Spring 框架完成的）
Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对
象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。
这篇文章就到这了，有点长，能看完的都很了不起。下一篇文章将讲解Spring 中基于注解的 AOP 配置