Spring之AOP

最新推荐文章于 2023-07-22 17:21:02 发布

快乐小石头

最新推荐文章于 2023-07-22 17:21:02 发布

阅读量185

点赞数

分类专栏： spring源码分析

本文链接：https://blog.youkuaiyun.com/weixin_43185598/article/details/97753216

版权

spring源码分析专栏收录该内容

1 篇文章

订阅专栏

一、AOP

AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

AOP技术恰恰相反，它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

使用"横切"技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事物。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

1、横切关注点
对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点

2、切面（aspect）
类似对物体特征的抽象，切面就是对横切关注点的抽象

3、连接点（joinpoint）
被拦截到的点，因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器

4、切入点（pointcut）
对连接点进行拦截的定义

5、通知（advice）
所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类

6、目标对象
代理的目标对象

7、织入（weave）
将切面应用到目标对象并导致代理对象创建的过程

8、引入（introduction）
在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或字段

二、AOP使用规则

Spring中AOP代理由Spring的IOC容器负责生成、管理，其依赖关系也由IOC容器负责管理。因此，AOP代理可以直接使用容器中的其它bean实例作为目标，这种关系可由IOC容器的依赖注入提供。Spring创建代理的规则为：
1、默认使用Java动态代理来创建AOP代理，这样就可以为任何接口实例创建代理了
2、当需要代理的类不是代理接口的时候，Spring会切换为使用CGLIB代理，也可强制使用CGLIB

AOP编程其实是很简单的事情，纵观AOP编程，程序员只需要参与三个部分：
1、定义普通业务组件
2、定义切入点，一个切入点可能横切多个业务组件
3、定义增强处理，增强处理就是在AOP框架为普通业务组件织入的处理动作

AOP编程的关键就是定义切入点和定义增强处理，一旦定义了合适的切入点和增强处理，AOP框架将自动生成AOP代理，即：代理对象的方法=增强处理+被代理对象的方法。

三、Spring AOP的XML实现方式

定义一个接口

public interface HelloWorld
{
    void printHelloWorld();
    void doPrint();
}

定义两个接口实现类：

public class HelloWorldImpl1 implements HelloWorld
{
    public void printHelloWorld()
    {
        System.out.println("Enter HelloWorldImpl1.printHelloWorld()");
    }
    
    public void doPrint()
    {
        System.out.println("Enter HelloWorldImpl1.doPrint()");
        return ;
    }
}

public class HelloWorldImpl2 implements HelloWorld
{
    public void printHelloWorld()
    {
        System.out.println("Enter HelloWorldImpl2.printHelloWorld()");
    }
    
    public void doPrint()
    {
        System.out.println("Enter HelloWorldImpl2.doPrint()");
        return ;
    }
}

横切关注点，这里是打印时间：

public class TimeHandler
{
    public void printTime()
    {
        System.out.println("CurrentTime = " + System.currentTimeMillis());
    }
}

aop.xml的配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
        
        <bean id="helloWorldImpl1" class="com.xrq.aop.HelloWorldImpl1" />
        <bean id="helloWorldImpl2" class="com.xrq.aop.HelloWorldImpl2" />
        <bean id="timeHandler" class="com.xrq.aop.TimeHandler" />
        
        <aop:config>
            <aop:aspect id="time" ref="timeHandler">
                <aop:pointcut id="addAllMethod" expression="execution(* com.xrq.aop.HelloWorld.*(..))" />
                <aop:before method="printTime" pointcut-ref="addAllMethod" />
                <aop:after method="printTime" pointcut-ref="addAllMethod" />
            </aop:aspect>
        </aop:config>
</beans>

main函数调用一下：

public static void main(String[] args)
{
    ApplicationContext ctx = 
            new ClassPathXmlApplicationContext("aop.xml");
        
    HelloWorld hw1 = (HelloWorld)ctx.getBean("helloWorldImpl1");
    HelloWorld hw2 = (HelloWorld)ctx.getBean("helloWorldImpl2");
    hw1.printHelloWorld();
    System.out.println();
    hw1.doPrint();
    
    System.out.println();
    hw2.printHelloWorld();
    System.out.println();
    hw2.doPrint();
}

运行结果：（代理内容就是打印时间）

CurrentTime = 1446129611993
Enter HelloWorldImpl1.printHelloWorld()
CurrentTime = 1446129611993

CurrentTime = 1446129611994
Enter HelloWorldImpl1.doPrint()
CurrentTime = 1446129611994

CurrentTime = 1446129611994
Enter HelloWorldImpl2.printHelloWorld()
CurrentTime = 1446129611994

CurrentTime = 1446129611994
Enter HelloWorldImpl2.doPrint()
CurrentTime = 1446129611994

四。从原生到AOP的使用拓展进化

（有一个接口Dao有insert、delete、update三个方法，在insert与update被调用的前后，打印调用前的毫秒数与调用后的毫秒数）

1、原始代码实现

定义一个Dao接口：

		public interface Dao {
 5 
 6     public void insert();
 7     
 8     public void delete();
 9     
10     public void update();
11     
12 }

定义一个实现类DaoImpl：

public class DaoImpl implements Dao {
 5 
 6     @Override
 7     public void insert() {
 8         System.out.println("DaoImpl.insert()");
 9     }
10 
11     @Override
12     public void delete() {
13         System.out.println("DaoImpl.delete()");
14     }
15 
16     @Override
17     public void update() {
18         System.out.println("DaoImpl.update()");
19     }
20     
21 }

调用insert()与update()方法前后分别打印时间，就只能定义一个新的类包一层

public class ServiceImpl {
 5 
 6     private Dao dao = new DaoImpl();
 7     
 8     public void insert() {
 9         System.out.println("insert()方法开始时间：" + System.currentTimeMillis());
10         dao.insert();
11         System.out.println("insert()方法结束时间：" + System.currentTimeMillis());
12     }
13     
14     public void delete() {
15         dao.delete();
16     }
17     
18     public void update() {
19         System.out.println("update()方法开始时间：" + System.currentTimeMillis());
20         dao.update();
21         System.out.println("update()方法结束时间：" + System.currentTimeMillis());
22     }
23     
24 }

缺点：
1、方法调用前后输出时间的逻辑无法复用，如果有别的地方要增加这段逻辑就得再写一遍
2、如果Dao有其它实现类，那么必须新增一个类去包装该实现类，这将导致类数量不断膨胀

2、装饰器模式实现

饰器模式的核心就是实现Dao接口并持有Dao接口的引用

 public class LogDao implements Dao {
 5 
 6     private Dao dao;
 7     
 8     public LogDao(Dao dao) {
 9         this.dao = dao;
10     }
11 
12     @Override
13     public void insert() {
14         System.out.println("insert()方法开始时间：" + System.currentTimeMillis());
15         dao.insert();
16         System.out.println("insert()方法结束时间：" + System.currentTimeMillis());
17     }
18 
19     @Override
20     public void delete() {
21         dao.delete();
22     }
23 
24     @Override
25     public void update() {
26         System.out.println("update()方法开始时间：" + System.currentTimeMillis());
27         dao.update();
28         System.out.println("update()方法结束时间：" + System.currentTimeMillis());
29     }
30 
31 }

在使用的时候，可以使用"Dao dao = new LogDao(new DaoImpl())"的方式，
优点：
1、透明，对调用方来说，它只知道Dao，而不知道加上了日志功能
2、类不会无限膨胀，如果Dao的其它实现类需要输出日志，只需要向LogDao的构造函数中传入不同的Dao实现类即可

缺点：
1、输出日志的逻辑还是无法复用
2、输出日志的逻辑与代码有耦合，如果我要对delete()方法前后同样输出时间，需要修改LogDao

3、代理模式实现

定义一个InvocationHandler，我将它命名为LogInvocationHandler，其实现为：

public class LogInvocationHandler implements InvocationHandler {
 5 
 6     private Object obj;
 7     
 8     public LogInvocationHandler(Object obj) {
 9         this.obj = obj;
10     }
11     
12     @Override
13     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
14         String methodName = method.getName();
15         if ("insert".equals(methodName) || "update".equals(methodName)) {
16             System.out.println(methodName + "()方法开始时间：" + System.currentTimeMillis());
17             Object result = method.invoke(obj, args);
18             System.out.println(methodName + "()方法结束时间：" + System.currentTimeMillis());
19             
20             return result;
21         }
22         
23         return method.invoke(obj, args);
24     }
25     
26 }

main函数：

public static void main(String[] args) {
 5     Dao dao = new DaoImpl();
 6         
 7     Dao proxyDao = (Dao)Proxy.newProxyInstance(LogInvocationHandler.class.getClassLoader(), new Class<?>[]{Dao.class}, new LogInvocationHandler(dao));
 8         
 9     proxyDao.insert();
10     System.out.println("----------分割线----------");
11     proxyDao.delete();
12     System.out.println("----------分割线----------");
13     proxyDao.update();
14 }

优点：
1、输出日志的逻辑被复用起来，如果要针对其他接口用上输出日志的逻辑，只要在newProxyInstance的时候的第二个参数增加Class<?>数组中的内容即可

缺点：
1、JDK提供的动态代理只能针对接口做代理，不能针对类做代理
2、代码依然有耦合，如果要对delete方法调用前后打印时间，得在LogInvocationHandler中增加delete方法的判断

4、CGLIB代码模式实现

使用CGLIB只需要实现MethodInterceptor接口即可：

public class DaoProxy implements MethodInterceptor {
 5 
 6     @Override
 7     public Object intercept(Object object, Method method, Object[] objects, MethodProxy proxy) throws Throwable {
 8         String methodName = method.getName();
 9         
10         if ("insert".equals(methodName) || "update".equals(methodName)) {
11             System.out.println(methodName + "()方法开始时间：" + System.currentTimeMillis());
12             proxy.invokeSuper(object, objects);
13             System.out.println(methodName + "()方法结束时间：" + System.currentTimeMillis());
14             
15             return object;
16         }
17         
18         proxy.invokeSuper(object, objects);
19         return object;
20     }
21 
22 }

代码调用方式为：

public static void main(String[] args) {
 5     DaoProxy daoProxy = new DaoProxy();
 6     
 7     Enhancer enhancer = new Enhancer();
 8     enhancer.setSuperclass(DaoImpl.class);
 9     enhancer.setCallback(daoProxy);
10         
11     Dao dao = (DaoImpl)enhancer.create();
12     dao.insert();
13     System.out.println("----------分割线----------");
14     dao.delete();
15     System.out.println("----------分割线----------");
16     dao.update();
17 }

缺点：
1、无论使用Java代理还是使用CGLIB，编写这部分代码都稍显麻烦
2、代码之间的耦合还是没有解决，像要针对delete()方法加上这部分逻辑就必须修改代码

5、使用AOP模式实现

定义一个时间处理类，我将它命名为TimeHandler：

public class TimeHandler {
 5     
 6     public void printTime(ProceedingJoinPoint pjp) {
 7         Signature signature = pjp.getSignature();
 8         if (signature instanceof MethodSignature) {
 9             MethodSignature methodSignature = (MethodSignature)signature;
10             Method method = methodSignature.getMethod();
11             System.out.println(method.getName() + "()方法开始时间：" + System.currentTimeMillis());
12             
13             try {
14                 pjp.proceed();
15                 System.out.println(method.getName() + "()方法结束时间：" + System.currentTimeMillis());
16             } catch (Throwable e) {
17                 
18             }
19         }
20     }
21     
22 }

aop.xml的配置：

<?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:aop="http://www.springframework.org/schema/aop"
 5     xmlns:tx="http://www.springframework.org/schema/tx"
 6     xsi:schemaLocation="http://www.springframework.org/schema/beans
 7         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 8         http://www.springframework.org/schema/aop
 9         http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
10 
11     <bean id="daoImpl" class="org.xrq.spring.action.aop.DaoImpl" />
12     <bean id="timeHandler" class="org.xrq.spring.action.aop.TimeHandler" />
13 
14     <aop:config>
15         <aop:pointcut id="addAllMethod" expression="execution(* org.xrq.spring.action.aop.Dao.*(..))" />
16         <aop:aspect id="time" ref="timeHandler">
17             <aop:before method="printTime" pointcut-ref="addAllMethod" />
18             <aop:after method="printTime" pointcut-ref="addAllMethod" />
19         </aop:aspect>
20     </aop:config>
21     
22 </beans>

测试代码

public class AopTest {
 5 
 6     @Test
 7     @SuppressWarnings("resource")
 8     public void testAop() {
 9         ApplicationContext ac = new ClassPathXmlApplicationContext("spring/aop.xml");
10         
11         Dao dao = (Dao)ac.getBean("daoImpl");
12         dao.insert();
13         System.out.println("----------分割线----------");
14         dao.delete();
15         System.out.println("----------分割线----------");
16         dao.update();
17     }
18     
19 }

AOP的几个优点：
1、切面的内容可以复用，比如TimeHandler的printTime方法，任何地方需要打印方法执行前的时间与方法执行后的时间，都可以使用TimeHandler的printTime方法
2、避免使用Proxy、CGLIB生成代理，这方面的工作全部框架去实现，开发者可以专注于切面内容本身
3、代码与代码之间没有耦合，如果拦截的方法有变化修改配置文件即可