spring-101-springAOP

r囧r小猫 2021-12-17 06:17 280阅读 0赞

前言：

> 在很多场景下有一个共同的业务模块。比如用户在网站购物时，加入商品到购物车，下单，支付，等等，但是所有的业务都需要打日志，但是每个业务重写一遍日志又比较麻烦。此时springAOP可以适用这样的情况。

> AOP（Aspect Oriented Programming），即面向切面编程（也叫面向方面编程，面向方法编程）。其主要作用是，在不修改源代码的情况下给某个或者一组操作添加额外的功能。像日志记录，事务处理，权限控制等功能，都可以用AOP来“优雅”地实现，使这些额外功能和真正的业务逻辑分离开来，软件的结构将更加清晰。

springAOP概念较多，但是最为关键的有2个：

*  Advice  
    `通知，多个业务模块都用到一个共同的功能，那么这个共同的功能，比如打日志，这个就是通知。`
 *  Pointcut  
    `切入点，多个业务模块都用到一个共同的功能，那么这个多个业务模块，比如加入商品到购物车，这个就是切入点。`

spring为了方便，对这两个进行了组合

*  Advisor  
    `这个其实是Advice和Pointcut的组合，Advice和Pointcut组成的独立的单元。 也就是说，多个业务模块都用到一个共同的功能，那么这个整体就叫Advisor`

--------------------

就依用户网站购物，加入商品到购物车，下单，支付都用到了加入日志为例子做一个DEMO。

**1.用户多业务场景**

用户在网站购物三个业务模块，加入商品到购物车，下单，支付代码，如下，代码清单1：

package wang.conge.springdemo.aop.service;
    
    import org.springframework.stereotype.Component;
    
    import wang.conge.springdemo.aop.annotation.AopLogAnnotation;
    
    @Component
    public class UserService {
        
        @AopLogAnnotation
        public void addCar() {
            System.out.println("加入购物车");
        }
        
        @AopLogAnnotation
        public void createOrder() {
            System.out.println("下单");
        }
        
        @AopLogAnnotation
        public void pay() {
            System.out.println("付款");
        }
    }

代码清单1 用到了注解作为切入点的最小单元，先列出来，下面说明，代码清单2:

package wang.conge.springdemo.aop.annotation;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface AopLogAnnotation {
        String value() default "";
    }

**2.共同业务模块**

用户在网站购物三个业务模块，加入商品到购物车，下单，支付代码，但是都用到了加入日志，如下，代码清单3：

package wang.conge.springdemo.aop.service;
    
    import java.lang.reflect.Method;
    import java.util.Optional;
    
    import org.aopalliance.aop.Advice;
    import org.aopalliance.intercept.MethodInterceptor;
    import org.aopalliance.intercept.MethodInvocation;
    import org.springframework.aop.Pointcut;
    import org.springframework.aop.support.AbstractPointcutAdvisor;
    import org.springframework.aop.support.StaticMethodMatcherPointcut;
    import org.springframework.stereotype.Component;
    
    import wang.conge.springdemo.aop.annotation.AopLogAnnotation;
    
    @Component
    public class CommonLogAdvisor extends AbstractPointcutAdvisor{
        private static final long serialVersionUID = 1L;
        
        @Override
        public Pointcut getPointcut() {
            return new StaticMethodMatcherPointcut() {
                
                @Override
                public boolean matches(Method method, Class<?> targetClass) {
                    //TODO matches targetClass 
                    //if(targetClass matches AopTargetClass) return true;
                    
                    //TODO matches method 
                    //if(method matches AopMethod) return true;
                    
                    if(method.isAnnotationPresent(AopLogAnnotation.class)) {
                        return true;
                    }
                    
                    return false;
                }
                
            };
        }
    
        @Override
        public Advice getAdvice() {
            return new MethodInterceptor() {
                @Override
                public Object invoke(MethodInvocation invocation) throws Throwable {
                    Object ret = null;
                    try {
                        //TODO before
                        System.out.println("=====SpringAopAdvisor-调用前before逻辑===");
                        
                        ret = invocation.proceed();
                        
                        //TODO after
                        System.out.println("=====SpringAopAdvisor-调用后after逻辑===");
                        
                        return ret;
                    } catch (Exception e) {
                        //TODO throw
                        System.out.println("=====SpringAopAdvisor-调用异常throw逻辑===");
                        return Optional.empty();
                    } finally {
                        //TODO finally
                        System.out.println("=====SpringAopAdvisor-调用最终结束逻辑===");
                    }
                }
            };
        }
        
    }

下面对代码说明，为整个DEMO中核心代码：

*  public Advice getAdvice() ;该方法就是返回共同的业务所做的事情，在业务调用时就会在合适的逻辑之前，或之后，或发生异常，去完成相应的共同逻辑处理。
 *  public Pointcut getPointcut() ; 该方法返回拦截业务的规则，事实上，加入商品到购物车，下单，支付并不是切入点，而加入商品到购物车，下单，支付这几个业务怎样在哪里加入共同日志的方式，或者规则，才叫切入点。方法里利用注解的方式，如果方法上注解了AopLogAnnotation，就会拦截，否则不拦截。也可以进进一步从类的Class做拦截的规则，这个看具体业务拦截的方式了。

**3.配置代码**

剩下的代码则是对上述代码进行组织运行了。  
配置代码，启用EnableAspectJAutoProxy支持。代码清单4：

package wang.conge.springdemo.aop.config;
    
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.EnableAspectJAutoProxy;
    
    @Configuration
    @EnableAspectJAutoProxy(proxyTargetClass=true)
    @ComponentScan("wang.conge.springdemo.aop.service")
    public class AppConfig {
        
    }

运行主代码，代码清单5：

package wang.conge.springdemo.aop;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    import wang.conge.springdemo.aop.config.AppConfig;
    import wang.conge.springdemo.aop.service.UserService;
    
    public class AppStart {
    
        public static void main(String[] args) {
            ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
            
            UserService myService = applicationContext.getBean(UserService.class);
            myService.addCar();
            
            myService.createOrder();
        }
    
    }

OK,整个DEMO就结束了，紧紧抓住AOP的主题思想：

*  多个业务有共同功能，多个业务切入点，也就是被拦截的地方，或者拦截这些多个业务的规则
 *  多个业务共同的功能，也就是该共同功能所做的事情。

--------------------

上述代码是以springAOP做实例，事实上spring也支持aspectj ，但是运行的方式还是根据代理的形式。  
而spring实现AOP的技术，主要分为两大类：

> 一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；  
> 二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。

--------------------

如果要是原生的aspectj 还是比较复杂，牵扯到织入的细节。aspectj是aop的Java实现方案。下面是几点关于aspectj的描述：

*  AspectJ是一个代码生成工具（CodeGenerator），其中AspectJ语法就是用来定义代码生成规则的语法。基于自己的语法编译工具，编译的结果是Java Class文件，运行的时候classpath需要包含AspectJ的一个jar文件（Runtime lib），支持编译时织入切面，即所谓的CTW机制，可以通过一个Ant或Maven任务来完成这个操作。
 *  AspectJ有自己的类装载器，支持在类装载时织入切面，即所谓的LTW机制。使用AspectJ LTW有两个主要步骤，第一，通过JVM的-javaagent参数设置LTW的织入器类包，以代理JVM默认的类加载器；第二，LTW织入器需要一个 aop.xml文件，在该文件中指定切面类和需要进行切面织入的目标类
 *  AspectJ同样也支持运行时织入，运行时织入是基于动态代理的机制。（默认机制）

--------------------

附录1，AOP详细概念：  
![865091-20160519112401982-1029040888.png][]

附录2，spring aop官方网站介绍资料：http://docs.spring.io/spring/docs/current/spring-framework-reference/html/aop.html

转载于:https://www.cnblogs.com/conge/p/5508066.html

[865091-20160519112401982-1029040888.png]: /images/20211217/25eb6c7d736748b5be8b4e37b7a5c1ac.png