spring aop

AOP全称是Aspect Oriented Programing，通常译为面向切面编程。

几个重要术语：Joinpoint、Pointcut、Advice

Joinpoint：连接点，如类的某个方法调用前、调用后、抛出异常等，Spring仅支持方法的连接点。
Pointcut：切点，例如下文中的 "execution(( com.companyserver.controller..*(..)))" 是告诉Spring我们要找com.companyserver.controller包下所有controller的方法，返回值和参数格式不限。
Advice：增强(另一种直白的翻译是通知，但是增强更好理解一些，本身作用就是植入目标类添加额外的功能)里。当然，增强并不能是随便一段代码，还必须配合连接点的方位，例如MethodBeforeAdvice就只能织入方法调用前的位置，AfterReturningAdvice只能织入方法返回后的位置

Advice的几种用法

//后置增强，在方法正常完成后执行。
import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
public class BibiAdvice implements AfterReturningAdvice {
  @Override
  public void afterReturning(Object returnObj, Method method, Object[] args,Object obj)throws Throwable {
     System.out.println("方法完成");
   }
}
//前置增强
public class BeforeAdviceDemo implements MethodBeforeAdvice {
  @Override
  public void before(Method method, Object[] args, Object obj) throws Throwable {
    System.out.println("方法执行前");
    }
}
//环绕增强
public class AroundAdviceDemo implements MethodInterceptor {
  @Override
  public Object invoke(MethodInvocation invocation)throws Throwable {
    Object[] args = invocation.getArguments();
    String name = (String)args[0];
    System.out.println("Hi, "+ name);
    Object obj = invocation.proceed();//调用目标方法
    System.out.println("Goodbye! "+ name);
    return obj;
   }
}
//异常抛出
public class ThrowsAdviceDemo implements ThrowsAdvice {
  public void afterThrowing (Method method,  Object[] args,  Object target,  Exception ex) throws Throwable {
    System.out.println("抛出异常:"+ ex.getMessage());
    System.out.println("异常处理...");
  }
}

用代码创建代理（实际开发中不会使用这种代码的方式，Spring会帮我们完成自动创建代理工作）

public interface Test {
 void test();
}

public class MyTest implements Test {
  @Override
   public void test() {
    System.out.println("--正在执行--");
   }
}

import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.framework.ProxyFactory;
public class Client {
  public static void main(String[] args) {
    Test test =new MyTest();
    AfterReturningAdvice advice =new BibiAdvice();
    ProxyFactory pf =new ProxyFactory();
    pf.setTarget(test);
    pf.setInterfaces(test.getClass().getInterfaces());
    pf.addAdvice(advice);
    Test proxy = (Test)pf.getProxy();
    proxy.test();
   }
}

而在spring中，当配置aop时需要进行ProxyFactoryBean的配置，来看看它可配置的属性和用法。

target ：目标对象，ref另一个bean
proxyTargetClass ：是否对类进行代理(而不是对接口)，true或false，设置为true时，使用CGLib代理技术
interceptorNames ：织入目标对象的Advice(实现了Advisor或者MethodInterceptor接口的bean)
proxyInterfaces ：代理所要实现的接口，如果指定了proxyTargetClass=true，此属性会被忽略
optimize ：设置为true时，强制使用CGLib代理技术

前面的示例看起来让人沮丧，要记忆如此多的接口、类和继承关系，做各种复杂的配置。好在这些只是一种相对过时的实现方式，现在只需要使用@Aspect注解及表达式就可以轻松的使用POJO来定义切面，设计精妙正如Spring MVC的@Controller。

使用@Aspec即可使用拦截
@Aspec : 作用是把当前类标识为一个切面供容器读取
@Pointcut ：是指那些方法需要被执行"AOP
@Around : 环绕增强，相当于MethodInterceptor
@DeclareParents : 引介增强，相当于IntroductionInterceptor
@Before : 标识一个前置增强方法，相当于BeforeAdvice的功能，相似功能的还有
@After : final增强，不管是抛出异常或者正常退出都会执行
@AfterReturning : 后置增强，相当于AfterReturningAdvice，方法正常退出时执行
@AfterThrowing : 异常抛出增强，相当于ThrowsAdvice

JoinPoint ： 表示目标类连接点对象

任何一个增强方法都可以通过将第一个入参声明为JoinPoint访问到连接点上下文的信息。我们先来了解一下这两个接口的主要方法：

1)JoinPoint

java.lang.Object[] getArgs()：获取连接点方法运行时的入参列表；
Signature getSignature() ：获取连接点的方法签名对象；
java.lang.Object getTarget() ：获取连接点所在的目标对象；
java.lang.Object getThis() ：获取代理对象本身；

2)ProceedingJoinPoint

ProceedingJoinPoint继承JoinPoint子接口，它新增了两个用于执行连接点方法的方法：

java.lang.Object proceed() throws java.lang.Throwable：通过反射执行目标对象的连接点处的方法；
java.lang.Object proceed(java.lang.Object[] args) throws java.lang.Throwable：通过反射执行目标对象连接点处的方法，不过使用新的入参替换原来的入参。
MethodSignature ：连接点的方法签名对象
execution切点函数

execution函数用于匹配方法执行的连接点，语法为：execution(方法修饰符(可选) 返回类型 方法名 参数 异常模式(可选))

参数部分允许使用通配符：

• * 匹配任意字符，但只能匹配一个元素
• .. 匹配任意字符，可以匹配任意多个元素，表示类时，必须和*联合使用
• + 必须跟在类名后面，如Horseman+，表示类本身和继承或扩展指定类的所有类

示例: * chop(..)解读为：
1.方法修饰符 : 无
2.返回类型 :     \*匹配任意数量字符，表示返回类型不限
3.方法名 :         chop表示匹配名称为chop的方法
4. 参数   :            (..)表示匹配任意数量和类型的输入参数
5. 异常模式:       不限

更多示例：

void chop(String,int)

配目标类任意修饰符方法、返回void、方法名chop、带有一个String和一个int型参数的方法

public void chop(*)

匹配目标类public修饰、返回void、方法名chop、带有一个任意类型参数的方法

public String *o*(..)

匹配目标类public修饰、返回String类型、方法名中带有一个o字符、带有任意数量任意类型参数的方法

public void *o*(String,..)

匹配目标类public修饰、返回void、方法名中带有一个o字符、带有任意数量任意类型参数，但第一个参数必须有且为String型的方法,
也可以指定类：

public void examples.chap03.Horseman.*(..)

匹配Horseman的public修饰、返回void、不限方法名、带有任意数量任意类型参数的方法

public void examples.chap03.*man.*(..)

匹配以man结尾的类中public修饰、返回void、不限方法名、带有任意数量任意类型参数的方法
指定包：

public void examples.chap03.*.chop(..)

匹配examples.chap03包下所有类中public修饰、返回void、方法名chop、带有任意数量任意类型参数的方法

public void examples..*.chop(..)

匹配examples.包下和所有子包中的类中public修饰、返回void、方法名chop、带有任意数量任意类型参数的方法

可以用这些表达式替换StorageAdvisor中的代码并观察效果

除了execution()，Spring中还支持其他多个函数，这里列出名称和简单介绍，以方便根据需要进行更详细的查询

1. @annotation() :表示标注了指定注解的目标类方法

例如 @annotation(org.springframework.transaction.annotation.Transactional) 表示标注了@Transactional的方法

2. args() : 通过目标类方法的参数类型指定切点

例如 args(String) 表示有且仅有一个String型参数的方法

3. @args()通过目标类参数的对象类型是否标注了指定注解指定切点

如 @args(org.springframework.stereotype.Service) 表示有且仅有一个标注了@Service的类参数的方法

4. within()通过类名指定切点

如 with(examples.chap03.Horseman) 表示Horseman的所有方法

5. target()通过类名指定，同时包含所有子类

如 target(examples.chap03.Horseman) 且Elephantman extends Horseman，则两个类的所有方法都匹配

6. @within()匹配标注了指定注解的类及其所有子类

如 @within(org.springframework.stereotype.Service) 给Horseman加上@Service标注，则Horseman和Elephantman 的所有方法都匹配

7. @target()所有标注了指定注解的类

如 @target(org.springframework.stereotype.Service) 表示所有标注了@Service的类的所有方法

8. this()大部分时候和target()相同，区别是this是在运行时生成代理类后，才判断代理类与指定的对象类型是否匹配

表达式可由多个切点函数通过逻辑运算组成

1. &&

与操作，求交集，也可以写成and

例如 execution(* chop(..)) && target(Horseman) 表示Horseman及其子类的chop方法

2. ||

或操作，求并集，也可以写成or

例如 execution(* chop(..)) || args(String) 表示名称为chop的方法或者有一个String型参数的方法

3. !

非操作，求反集，也可以写成not

例如 execution(* chop(..)) and !args(String) 表示名称为chop的方法但是不能是只有一个String型参数的方法

package com.companyserver.interceptor;
import com.companyserver.security.JwtTokenUtil;
import com.companyserver.utils.TimeProvider;
import com.companyserver.vo.Result;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.Date;
import java.util.LinkedHashSet;
import java.util.Set;
/**
* 拦截器：记录用户操作日志，检查用户token是否需要属刷新……
*@author lpfasd
*/
@Aspect
@Component
public classControllerInterceptor {
  private static final Logger logger= LoggerFactory.getLogger(ControllerInterceptor.class);
  @Value("${jwt.header}")
  private String tokenHeader;
  @Autowired
  private JwtTokenUtil jwtTokenUtil;
  @Autowired
  privateTimeProvider timeProvider;
  /**
  * 定义拦截规则：拦截com.companyserver.controller包下面的所有类中方法。
  */
  @Pointcut("execution(* com.companyserver.controller..*(..))")
  public void controllerMethodPointcut(){}
  /**
  * 拦截器具体实现
  * @parampjp
  * @return Result（被拦截方法的执行结果，或需要登录的错误提示。）
  */
  @Around("controllerMethodPointcut()")//指定拦截器规则；也可以直接把“execution(* com.companyserver.........)”写进这里
  public ObjectInterceptor(ProceedingJoinPoint pjp){
    logger.info("{}",pjp);
    long beginTime = System.currentTimeMillis();
    MethodSignature signature = (MethodSignature) pjp.getSignature();
    Method method = signature.getMethod();//获取被拦截的方法
    String methodName = method.getName();//获取被拦截的方法名
    Set allParams =newLinkedHashSet<>();//保存所有请求参数，用于输出到日志中
    logger.info("请求开始，方法：{}",methodName);
    Object result =null;
    Object[] args = pjp.getArgs();
    HttpServletRequest request =null;
    for(Object arg : args){
      if(arg instanceofHttpServle tRequest){
         request = (HttpServletRequest) arg;
        }
       logger.info("参数列表 ： "+ arg);
      }
    try{
      if(result ==null){
        // 一切正常的情况下，继续执行被拦截的方法
        result = pjp.proceed();
      }
    }catch(Throwable e) {
      logger.info("exception: ",e);
      result = Result.FAIL("服务器错误");
     }
    if(resultinstanceofResult){
      String authToken = request.getHeader(tokenHeader);
      Date expiration =jwtTokenUtil.getExpirationDateFromToken(authToken);
      if(expiration.before(timeProvider.now()) && new Date(expiration.getTime() + 30*60*1000 ) .after(timeProvider.now())){
          String refreshToken =jwtTokenUtil.refreshToken(authToken);
          ((Result) result).setToken(refreshToken);
        }
        long costMs = System.currentTimeMillis() - beginTime;
        logger.info("{}请求结束，耗时：{}ms",methodName,costMs);
      }
      return result;
   }
}