AOP

最新推荐文章于 2024-08-22 14:38:37 发布

小白的成长路

最新推荐文章于 2024-08-22 14:38:37 发布

阅读量131

点赞数

分类专栏： Spring 框架

Spring 框架专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1.定义

AOP：即面向切面编程，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了

多个类的公共行为封装到一个可重用模块，并将其命名为“Aspect”，即切面。所谓“切面”，简单说

就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低耦合度，利于未来的可操作性和可维护性。

2.AOP 核心观念：

1>.横切关注点

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

2>.切面（aspect）

类是对物体特征的抽象，切面就是对横切关注点的抽象

3>.连接点（joinpoint）

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

4>.切入点（pointcut）

对连接点进行拦截的定义

5>.通知（advice）

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

6>.目标对象

代理的目标对象

7>.织入（weave）

将切面应用到目标对象并导致代理对象创建的过程

8>.引入（introduction）

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

Spring 对 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文件模板，名字叫做aop.xml，之后的内容都在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">   
</beans>

基于Spring的AOP简单实现

注意一下，在讲解之前，说明一点：使用Spring AOP，要成功运行起代码，只用Spring提供给开发者的jar包是不够的，请额外上网下载两个jar包：

1、aopalliance.jar

2、aspectjweaver.jar

开始讲解用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());
   }
}

有这三个类就可以实现一个简单的Spring AOP了，看一下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

看到给HelloWorld接口的两个实现类的所有方法都加上了代理，代理内容就是打印时间。

基于Spring的AOP使用其他细节

1、增加一个横切关注点，打印日志，Java类为：

public class LogHandler
{
   public void LogBefore()
   {
       System.out.println("Log before method");
   }
   
   public void LogAfter()
   {
       System.out.println("Log after method");
   }
}

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" />
       <bean id="logHandler" class="com.xrq.aop.LogHandler" />
       
       <aop:config>
           <aop:aspect id="time" ref="timeHandler" order="1">
               <aop:pointcut id="addTime" expression="execution(* com.xrq.aop.HelloWorld.*(..))" />
               <aop:before method="printTime" pointcut-ref="addTime" />
               <aop:after method="printTime" pointcut-ref="addTime" />
           </aop:aspect>
           <aop:aspect id="log" ref="logHandler" order="2">
               <aop:pointcut id="printLog" expression="execution(* com.xrq.aop.HelloWorld.*(..))" />
               <aop:before method="LogBefore" pointcut-ref="printLog" />
               <aop:after method="LogAfter" pointcut-ref="printLog" />
           </aop:aspect>
       </aop:config>
</beans>

测试类不变，打印结果为：

CurrentTime = 1446130273734
Log before method
Enter HelloWorldImpl1.printHelloWorld()
Log after method
CurrentTime = 1446130273735

CurrentTime = 1446130273736
Log before method
Enter HelloWorldImpl1.doPrint()
Log after method
CurrentTime = 1446130273736

CurrentTime = 1446130273736
Log before method
Enter HelloWorldImpl2.printHelloWorld()
Log after method
CurrentTime = 1446130273736

CurrentTime = 1446130273737
Log before method
Enter HelloWorldImpl2.doPrint()
Log after method
CurrentTime = 1446130273737

要想让logHandler在timeHandler前使用有两个办法：

（1）aspect里面有一个order属性，order属性的数字就是横切关注点的顺序

（2）把logHandler定义在timeHandler前面，Spring默认以aspect的定义顺序作为织入顺序

2、我只想织入接口中的某些方法

修改一下pointcut的expression就好了：

<?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" />
       <bean id="logHandler" class="com.xrq.aop.LogHandler" />
       
       <aop:config>
           <aop:aspect id="time" ref="timeHandler" order="1">
               <aop:pointcut id="addTime" expression="execution(* com.xrq.aop.HelloWorld.print*(..))" />
               <aop:before method="printTime" pointcut-ref="addTime" />
               <aop:after method="printTime" pointcut-ref="addTime" />
           </aop:aspect>
           <aop:aspect id="log" ref="logHandler" order="2">
               <aop:pointcut id="printLog" expression="execution(* com.xrq.aop.HelloWorld.do*(..))" />
               <aop:before method="LogBefore" pointcut-ref="printLog" />
               <aop:after method="LogAfter" pointcut-ref="printLog" />
           </aop:aspect>
       </aop:config>
</beans>

表示 timeHandler 只会织入 HelloWorld 接口 print 开头的方法，logHandler 只会织入 HelloWorld 接口 do 开头的方法。

3、强制使用 CGLIB 生成代理

前面说过 Spring 使用动态代理或是 CGLIB 生成代理是有规则的，高版本的 Spring 会自动选择是使用动态代理还是 CGLIB 生成代理内容，当然我们也可以强制使用 CGLIB 生成代理，那就是里面有一个"proxy-target-class"属性，这个属性值如果被设置为true，那么基于类的代理将起作用，如果 proxy-target-class 被设置为 false 或者这个属性被省略，那么基于接口的代理将起作用。

小白的成长路

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
AOP

1.定义AOP：即面向切面编程，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为“Aspect”，即切面。所谓“切面”，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低耦合度，利于未来的可操作性和可维护性。2.AOP 核心观念：1&gt;.横切关注点对哪些方法进行拦截，...
复制链接

扫一扫

专栏目录