AOP面向切面编程是纵向编程，在spring框架中很多注解都是基于aop做的功能增强，原理是java的动态代理模式。
先理解一下基本概念
切入点(PointCut)
在需要做增强功能的方法上添加自定义注解实现功能增强，这个方法就是切入点，@Pointcut。
切面(Aspect)
有了切入点，把需要增强的功能写入到某个实现类里，这个类就叫做切面，里面可以声明前置增强、后置增强、环绕增强、发生异常处理等操作
连接点(JoinPoint)
在切点（即指需要增强的方法）上的哪一个执行阶段加入增加代码，这个执行阶段就叫连接点，比如：方法调用前@Before，方法调用后@After，发生异常时@AfterThrowing等等。
通知(Advice)
连接点里面声明的代码处理就是通知，如@Before注解方法里面的具体代码操作。
目标对象(Target Object)
被一个或多个切面所通知的对象，即为目标对象。
AOP代理对象(AOP Proxy Object)
AOP代理是AOP框架所生成的对象，该对象是目标对象的代理对象。代理对象能够在目标对象的基础上，在相应的连接点上调用通知。
织入(Weaving)
将切面切入到目标方法之中，使目标方法得到增强的过程被称之为织入。
示例：
maven在普通springboot的基础上引入切面jar包
org.aspectj
aspectjweaver
1.9.6
runtime
aspectj
aspectjrt
1.5.4
在springboot中新建一个TestController,在controller里声明一个自定义注解
package com.zhaohy.app.controller;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.zhaohy.app.service.TestService;
import com.zhaohy.app.sys.annotation.RecordLog;
@Controller
public class TestController {
@Autowired
TestService testService;
@RecordLog(module="moduleTest")
@RequestMapping("/test/test.do")
public void test(HttpServletRequest request) {
String userId = request.getParameter("userId");
try {
testService.test(userId);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
TestService:
package com.zhaohy.app.service;
public interface TestService {
public String doSearch(String userId, String keyword);
public void test(String userId) throws Exception;
}
TestServiceImpl:
package com.zhaohy.app.service.impl;
import org.springframework.stereotype.Service;
import com.zhaohy.app.service.TestService;
import com.zhaohy.app.sys.annotation.RecordLog;
@Service("TestService")
public class TestServiceImpl implements TestService {
public void test(String userId) throws Exception {
System.out.println(userId + "====执行操作");
throw new Exception();
}
}
新建注解类：
package com.zhaohy.app.sys.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 日志记录注解类
* @author zhaohy
*
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RecordLog {
/**
* 何种场景下的通用日志打印
*
* @return
*/
String module();
}
切面类：
package com.zhaohy.app.sys.annotation;
import java.lang.reflect.Method;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import com.alibaba.fastjson.JSON;
/**
* 定义日志切面
* @author zhaohy
*@Lazy 注解:容器一般都会在启动的时候实例化所有单实例 bean，如果我们想要 Spring 在启动的时候延迟加载 bean，需要用到这个注解
*value为true、false 默认为true,即延迟加载，@Lazy(false)表示对象会在初始化的时候创建
*/
@Aspect
@Component
@Lazy(false)
public class LoggerAspect {
/**
* 定义切入点：对要拦截的方法进行定义与限制，如包、类
*
* 1、execution(public * *(..)) 任意的公共方法
* 2、execution（* set*（..）） 以set开头的所有的方法
* 3、execution（* com.zhaohy.app.sys.annotation.LoggerApply.*（..））com.zhaohy.app.sys.annotation.LoggerApply这个类里的所有的方法
* 4、execution（* com.zhaohy.app.sys.annotation.*.*（..））com.zhaohy.app.sys.annotation包下的所有的类的所有的方法
* 5、execution（* com.zhaohy.app.sys.annotation..*.*（..））com.zhaohy.app.sys.annotation包及子包下所有的类的所有的方法
* 6、execution(* com.zhaohy.app.sys.annotation..*.*(String,?,Long)) com.zhaohy.app.sys.annotation包及子包下所有的类的有三个参数，第一个参数为String类型，第二个参数为任意类型，第三个参数为Long类型的方法
* 7、execution(@annotation(com.zhaohy.app.sys.annotation.RecordLog))
*/
@Pointcut("@annotation(com.zhaohy.app.sys.annotation.RecordLog)")
private void cutMethod() {
}
/**
* 前置通知：在目标方法执行前调用
*/
@Before("cutMethod()")
public void begin() {
System.out.println("==@Before== begin");
}
/**
* 后置通知：在目标方法执行后调用，若目标方法出现异常，则不执行
*/
@AfterReturning("cutMethod()")
public void afterReturning() {
System.out.println("==@AfterReturning== after returning");
}
/**
* 后置/最终通知：无论目标方法在执行过程中出现一场都会在它之后调用
*/
@After("cutMethod()")
public void after() {
System.out.println("==@After== finally returning");
}
/**
* 异常通知：目标方法抛出异常时执行
*/
@AfterThrowing("cutMethod()")
public void afterThrowing() {
System.out.println("==@AfterThrowing== after throwing");
}
/**
* 环绕通知：灵活自由的在目标方法中切入代码
*/
@Around("cutMethod()")
public void around(ProceedingJoinPoint joinPoint) throws Throwable {
// 获取目标方法的名称
String methodName = joinPoint.getSignature().getName();
// 获取方法传入参数
Object[] params = joinPoint.getArgs();
RecordLog recordLog = getDeclaredAnnotation(joinPoint);
HttpServletRequest request = (HttpServletRequest) params[0];
System.out.println("==@Around== --》 method name :'" + methodName + "' args :" + this.getRequestParams(request));
// 执行源方法
joinPoint.proceed();
// 模拟进行验证
if (params != null && params.length > 0 && params[0].equals("Blog Home")) {
System.out.println("==@Around== --》 " + recordLog.module() + " auth success");
} else {
System.out.println("==@Around== --》 " + recordLog.module() + " auth failed");
}
}
private String getRequestParams(HttpServletRequest request) {
Enumeration enu=request.getParameterNames();
Map paramsMap = new HashMap();
while(enu.hasMoreElements()){
String paraName=(String)enu.nextElement();
paramsMap.put(paraName, request.getParameter(paraName));
}
return JSON.toJSONString(paramsMap);
}
/**
* 获取方法中声明的注解
*
* @param joinPoint
* @return
* @throws NoSuchMethodException
*/
public RecordLog getDeclaredAnnotation(ProceedingJoinPoint joinPoint) throws NoSuchMethodException {
// 获取方法名
String methodName = joinPoint.getSignature().getName();
// 反射获取目标类
Class targetClass = joinPoint.getTarget().getClass();
// 拿到方法对应的参数类型
Class[] parameterTypes = ((MethodSignature) joinPoint.getSignature()).getParameterTypes();
// 根据类、方法、参数类型（重载）获取到方法的具体信息
Method objMethod = targetClass.getMethod(methodName, parameterTypes);
// 拿到方法定义的注解信息
RecordLog annotation = objMethod.getDeclaredAnnotation(RecordLog.class);
// 返回
return annotation;
}
}
这样代码基本写的差不多了，浏览器访问`
http://127.0.0.1:8081/test/test.do?userId=杨过
控制台打印结果：
==@Around== --》 method name :'test' args :{"userId":"杨过"}
==@Before== begin
杨过====执行操作
java.lang.Exception
==@Around== --》 moduleTest auth failed
==@After== finally returning
==@AfterReturning== after returning
切面生效啦，如果在controller里不捕捉那个exception，则会触发
/**
* 异常通知：目标方法抛出异常时执行
*/
@AfterThrowing("cutMethod()")
public void afterThrowing() {
System.out.println("==@AfterThrowing== after throwing");
}
总结：
aop的思想类似过滤器、拦截器等，都是纵向编程，在方法执行前或者后或者前后或者抛出异常后等的后续处理操作，也用到java的反射机制根据类路径拿到类，拿到注解类的属性，拿到参数，解析参数，就可以做很多事情。
参考：https://www.cnblogs.com/lingyejun/p/9941350.html