前言：
在很多场景下有一个共同的业务模块。比如用户在网站购物时，加入商品到购物车，下单，支付，等等，但是所有的业务都需要打日志，但是每个业务重写一遍日志又比较麻烦。此时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详细概念：
附录2，spring aop官方网站介绍资料：http://docs.spring.io/spring/docs/current/spring-framework-reference/html/aop.html