spring aop

Posted 五色风车

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了spring aop相关的知识，希望对你有一定的参考价值。

 

什么是AOP

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

 

 

 

AOP使用场景

AOP用来封装横切关注点，具体可以在下面的场景中使用:

Authentication 权限

Caching 缓存

Context passing 内容传递

Error handling 错误处理

Lazy loading　懒加载

Debugging　　调试

logging, tracing, profiling and monitoring　记录跟踪　优化　校准

Performance optimization　性能优化

Persistence　　持久化

Resource pooling　资源池

Synchronization　同步

Transactions 事务

 

Spring AOP底层技术

Spring提供了两种方式来生成代理对象: JDKProxy和Cglib，具体使用哪种方式生成由AopProxyFactory根据AdvisedSupport对象的配置来决定。默认的策略是如果目标类是接口，则使用JDK动态代理技术，否则使用Cglib来生成代理。

 

动态代理利用反射的原理，给对象动态的生产代理对象，在执行的方法前后来执行相关内容：

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

public class DynamicProxy implements InvocationHandler{
    
    private Object target; // 需要代理的目标类
    
    public Object bind(Object target){
        this.target = target ;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        // 切面之前执行
        System.out.println("切面之前执行");
        // 执行业务
        result = method.invoke(target, args);
       // 切面之后执行
        System.out.println("切面之后执行");
        return result;
    }

}

 

CGLIB是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强。采用的是继承的方式

public class CglibProxy implements MethodInterceptor{

    private Object target;
    
    public Object getInstance(Object target){
        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        // 回调方法
        enhancer.setCallback(this);
        // 创建代理对象
        return enhancer.create();
    }
      
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        Object result = null;
        System.out.println("事物开始");
        result = methodProxy.invokeSuper(proxy, args);
        System.out.println("事物结束");
        return result;
    } 

}

 

 

AOP相关概念

方面（Aspect）：一个关注点的模块化，这个关注点实现可能另外横切多个对象。事务管理是J2EE应用中一个很好的横切关注点例子。方面用Spring的 Advisor或拦截器实现。

 @Aspect  声明一个类属于一个切面

 

连接点（Joinpoint）: 程序执行过程中明确的点，如方法的调用或特定的异常被抛出。

 

通知（Advice）: 在特定的连接点，AOP框架执行的动作。各种类型的通知包括“around”、“before”和“throws”通知。通知类型将在下面讨论。许多AOP框架包括Spring都是以拦截器做通知模型，维护一个“围绕”连接点的拦截器链。Spring中定义了四个advice: BeforeAdvice, AfterAdvice, ThrowAdvice和DynamicIntroductionAdvice

 

切入点（Pointcut）: 指定一个通知将被引发的一系列连接点的集合。AOP框架必须允许开发者指定切入点：例如，使用正则表达式。 Spring定义了Pointcut接口，用来组合MethodMatcher和ClassFilter，可以通过名字很清楚的理解， MethodMatcher是用来检查目标类的方法是否可以被应用此通知，而ClassFilter是用来检查Pointcut是否应该应用到目标类上。

 

引入（Introduction）: 添加方法或字段到被通知的类。 Spring允许引入新的接口到任何被通知的对象。例如，你可以使用一个引入使任何对象实现 IsModified接口，来简化缓存。Spring中要使用Introduction, 可有通过DelegatingIntroductionInterceptor来实现通知，通过DefaultIntroductionAdvisor来配置Advice和代理类要实现的接口

 

目标对象（Target Object）: 包含连接点的对象。也被称作被通知或被代理对象。POJO

 

AOP代理（AOP Proxy）: AOP框架创建的对象，包含通知。 在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。

 

织入（Weaving）: 组装方面来创建一个被通知对象。这可以在编译时完成（例如使用AspectJ编译器），也可以在运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。

 

几种实现方式

1、基于代理的AOP

2、纯简单java对象切面

3、@Aspect注解形式的

4、注入形式的Aspcet切面

 

 

面先写一下几个基本的类。

接口类：

/**
* 定义一个接口
* @author 陈丽娜
* @version 2015年5月31日上午9:16:50
*/
public interface Sleepable {

/**
* 睡觉方法
* @author 陈丽娜
* @version 2015年5月31日上午9:17:14
*/
void sleep();

}
View Code

实现类：

/**
* 陈丽娜 本人实现睡觉接口
* @author 陈丽娜
* @version 2015年5月31日下午4:51:43
*/

public class ChenLliNa implements Sleepable {

@Override
public void sleep() {
// TODO Auto-generated method stub
        System.out.println("乖,该睡觉了！");
}
}
View Code

增强类：

/**
* 定义一个睡眠的增强 同时实现前置 和后置
* @author 陈丽娜
* @version 2015年5月31日上午9:24:43
*/

public class SleepHelper implements MethodBeforeAdvice, AfterReturningAdvice {
 
@Override
public void afterReturning(Object returnValue, Method method,Object[] args, Object target) throws Throwable {
   System.out.println("睡觉前要敷面膜");
}

 @Override
public void before(Method method, Object[] args, Object target)throws Throwable {
   System.out.println("睡觉后要做美梦");
}
}
View Code

 

1、基于代理的AOP

<!-- 创建一个增强 advice -->

       <bean id ="sleepHelper" class="com.tgb.springaop.aspect.SleepHelper"/>
       <bean id="lina" class="com.tgb.springaop.service.impl.ChenLliNa"/>
       <!-- 定义切点   匹配所有的sleep方法-->
       <bean id ="sleepPointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">
             <property name="pattern" value=".*sleep"></property>
       </bean>
     
       <!-- 切面 增强+切点结合 -->
       <bean id="sleepHelperAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
            <property name="advice" ref="sleepHelper"/>
            <property name="pointcut" ref="sleepPointcut"/>
       </bean>      

       <!-- 定义代理对象 -->
       <bean id="linaProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
               <property name="target" ref="lina"/>
               <property name="interceptorNames" value="sleepHelperAdvisor"/>
       </bean>

如配置文件中：

pattern属性指定了正则表达式，他匹配所有的sleep方法

使用org.springframework.aop.support.DefaultPointcutAdvisor的目的是为了使切点和增强结合起来形成一个完整的切面

最后配置完后通过org.springframework.aop.framework.ProxyFactoryBean产生一个最终的代理对象。

 

2、纯简单java对象切面

纯简单java对象切面这话怎么说呢，在我看来就是相对于第一种配置，不需要使用代理，，而是通过spring的内部机制去自动扫描，这时候我们的配置文件就该如下修改：

<!-- 创建一个增强 advice -->
       <bean id ="sleepHelper" class="com.tgb.springaop.aspect.SleepHelper"/>
       <!-- 目标类 -->
       <bean id="lina" class="com.tgb.springaop.service.impl.ChenLliNa"/>

       <!--  配置切点和通知-->
       <bean id ="sleepAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
            <property name="advice" ref="sleepHelper"></property>
            <property name="pattern" value=".*sleep"/>
       </bean>

       <!-- 自动代理配置 -->
       <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>

 

3、@Aspect注解形式

根据我们的经验也知道，注解的形式相对于配置文件是简单一些的，这时候需要在已有的方法或类上家注解

/**
* 通过注解的方式 添加增强
* @author 陈丽娜
* @version 2015年5月31日上午10:26:13
*/

@Aspect
@Component
public class SleepHelper03 { 

/*@Pointcut("execution(* com.tgb.springaop.service.impl..*(..))")*/
@Pointcut("execution(* *.sleep(..))")
public void sleeppoint(){}

@Before("sleeppoint()")
public void beforeSleep(){
   System.out.println("睡觉前要敷面膜");
}

@AfterReturning("sleeppoint()")
public void afterSleep(){
   System.out.println("睡觉后要做美梦");
}

 @Around   表示环绕增加，在方法执行前执行后 ,可以使用ProceedingJoinPoint 代表一个连接点，proceed()，注意的是，这个只能在@Around 中使用（java.lang.IllegalArgumentException异常）

 @Before 表示在对象方法的执行前进行干预

 @After 表示在对象方法的执行后进行干预

 

@Pointcut   定义一个切入点

定义规则：

execution(modifiers-pattern?    ret-type-pattern    declaring-type-pattern?  name-pattern(param-pattern)   throws-pattern?)
  • 修饰符匹配（modifier-pattern?）
  • 返回值匹配（ret-type-pattern）可以为*表示任何返回值,全路径的类名等
  • 类路径匹配（declaring-type-pattern?）
  • 方法名匹配（name-pattern）可以指定方法名 或者 *代表所有, set* 代表以set开头的所有方法
  • 参数匹配（(param-pattern)）可以指定具体的参数类型，多个参数间用“,”隔开，各个参数也可以用“*”来表示匹配任意类型的参数，如(String)表示匹配一个String参数的方法；(*,String) 表示匹配有两个参数的方法，第一个参数可以是任意类型，而第二个参数是String类型；可以用(..)表示零个或多个任意参数
  • 异常类型匹配（throws-pattern?）
  • 其中后面跟着“?”的是可选项

取值可以取以下的情景：

execution：用于匹配方法执行的连接点；
within：用于匹配指定类型内的方法执行；
this：用于匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口也类型匹配；
target：用于匹配当前目标对象类型的执行方法；注意是目标对象的类型匹配，这样就不包括引入接口也类型匹配；
args：用于匹配当前执行的方法传入的参数为指定类型的执行方法；
@within：用于匹配所以持有指定注解类型内的方法；
@target：用于匹配当前目标对象类型的执行方法，其中目标对象持有指定的注解；
@args：用于匹配当前执行的方法传入的参数持有指定注解的执行；
@annotation：用于匹配当前执行方法持有指定注解的方法；
bean：Spring AOP扩展的，AspectJ没有对于指示符，用于匹配特定名称的Bean对象的执行方法；
reference pointcut：表示引用其他命名切入点，只有@ApectJ风格支持，Schema风格不支持。

 

配置文件中只需写：

<!--扫描包 -->
       <context:component-scan base-package="com.tgb" annotation-config="true"/> 
       <!-- ASPECTJ注解 -->
       <aop:aspectj-autoproxy  proxy-target-class="true" />  
      
       <!-- 目标类 -->
       <bean id="lina" class="com.tgb.springaop.service.impl.ChenLliNa"/>

 

4、注入形式的Aspcet切面

个人感觉这个是最简单的也是最常用的，也是最灵活的。配置文件如下：<!-- 目标类 -->

<!-- 目标类 -->
<bean id="lina" class="com.tgb.springaop.service.impl.ChenLliNa"/>
<bean id ="sleepHelper" class="com.tgb.springaop.aspect.SleepHelper02"/>
      
<aop:config>
   <aop:aspect ref="sleepHelper">
         <aop:before method="beforeSleep" pointcut="execution(* *.sleep(..))"/>
         <aop:after method="afterSleep" pointcut="execution(* *.sleep(..))"/>
   </aop:aspect>
</aop:config>

 

配置文件中提到的SleepHelper02类如下：

public class SleepHelper02 {

public void beforeSleep(){
   System.out.println("睡觉前要敷面膜");
}

public void afterSleep(){
   System.out.println("睡觉后要做美梦");
}
}

 

 

 

 

参考：https://www.cnblogs.com/ityouknow/p/5329550.html

原文：  https://www.jianshu.com/p/17017dbeb95d

以上是关于spring aop的主要内容，如果未能解决你的问题，请参考以下文章

JAVA之AOP

Spring AOP

Spring源码高级笔记之——Spring AOP应用

2018.12.24 Spring中的aop演示

Spring框架 AOP

Spring的AOP面向切面编程