AOP的全称是Aspect-Oriented Programming，即面向切面编程（也称面向方面编程）。它是面向对象编程（OOP）的一种补充，目前已成为一种比较成熟的编程方式。
aop 解决的问题就是将共同重复的代码就行抽离（日志，事务，鉴权）
什么是切面？切面就是一个类，类里面包含类某一类具体业务（日志，事务，鉴权），用这个类 去拦截/增强 你需要监控的方法或者业务
AOP的使用，使开发人员在编写业务逻辑时可以专心于核心业务，而不用过多的关注于其他业务逻辑的实现，这不但提高了开发效率，而且增强了代码的可维护性。
Proxy（代理）：将通知应用到目标对象之后，被动态创建的对象。
Weaving（织入）：将切面代码插入到目标对象上，从而生成代理对象的过程。
Advice（通知/增强处理）：AOP框架在特定的切入点执行的增强处理，即在定义好的切入点处所要执行的程序代码。可以将其理解为切面类中的方法。
Target Object（目标对象）：指所有被通知的对象，也被称为被增强对象。如果AOP框架采用的是动态的AOP实现，那么该对象就是一个被代理对象。
Aspect（切面）：封装的用于横向插入系统功能（如事务、日志等）的类
Joinpoint（连接点）：在程序执行过程中的某个阶段点
Pointcut（切入点）：切面与程序流程的交叉点，即那些需要处理的连接点
实现两种
基于自身的ProxyFactoryBean 实现aop功能借助于aspectj第三方aop框架实现aspectj 也是一个优秀的aop框架内
JDK动态代理
JDK动态代理是通过java.lang.reflect.Proxy 类来实现的，我们可以调用Proxy类的newProxyInstance()方法来创建代理对象。对于使用业务接口的类，Spring默认会使用JDK动态代理来实现AOP。
CGLIB代理
JDK的动态代理用起来非常简单，但它是有局限性的，使用动态代理的对象必须实现一个或多个接口。
为了实现类的代理可以使用CGLIB代理
CGLIB（Code Generation Library）是一个高性能开源的代码生成包，它采用非常底层的字节码技术，对指定的目标类生成一个子类，并对子类进行增强。
ProxyFactoryBean是FactoryBean接口的实现类，FactoryBean负责实例化一个Bean，而ProxyFactoryBean负责为其他Bean创建代理实例。在Spring中，使用ProxyFactoryBean是创建AOP代理的基本方式。
可以配置的属性
ProxyTargetClass (是否强制使用CGLIB来实现代理)
(true : 强制使用CGLIB来实现代理)
(false : 不强制使用CGLIB来实现代理，首选JDK来实现代理)（默认值）
isOptimize (是否对生成代理策略进行优化)
(true : 进行优化，如果有接口就代理接口(使用JDK动态代理)，没有接口代理类（CGLIB代理）)
(false : 不进行优化) （默认值）
实现：
1.jdk 只能代理类实现的接口的类，而没有实现接口类必须使用CGLIB 2.从性能来说： CGLIB：创建慢，执行块（CGLIB 要生成对应的代理的代码，在创建代理对象） JDK：创建快，执行慢（反射本身执行就比正常代码的慢）
AspectJ是一个基于Java语言的AOP框架，它提供了强大的AOP功能。Spring 2.0以后，Spring AOP引入了对AspectJ的支持，并允许直接使用AspectJ进行编程，而Spring自身的AOP API也尽量与AspectJ保持一致。新版本的Spring框架，也建议使用AspectJ来开发AOP。
使用AspectJ实现AOP有两种方式：
基于XML的声明式AspectJ基于注解的声明式AspectJSpring按照通知在目标类方法的连接点位置，可以分为5种类型，具体如下：
org.springframework.aop.MethodBeforeAdvice（前置通知） 在目标方法执行前实施增强，可以应用于权限管理等功能。org.springframework.aop.AfterReturningAdvice（后置通知） 在目标方法执行后实施增强，可以应用于关闭流、上传文件、删除 临时文件等功能。org.aopalliance.intercept.MethodInterceptor（环绕通知） 在目标方法执行前后实施增强，可以应用于日志、事务管理等功能。org.springframework.aop.ThrowsAdvice（异常抛出通知） 在方法抛出异常后实施增强，可以应用于处理异常记录日志等功能。org.springframework.aop.IntroductionInterceptor（引介通知） 在目标类中添加一些新的方法和属性，可以应用于修改老版本程序。1.引入依赖
<!--引入 aspectj依赖--> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjrt</artifactId> <version>1.6.12</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.6.12</version> </dependency>2.创建切面
package com.yth.aspectj; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; /** * 切面类 * @author yth * @date 2020/10/21 - 17:26 */ public class MyAspectj { /** * 前置通知，在目标对象调用之前调用 */ public void myBefore(JoinPoint joinPoint){ // joinPoint 连接点 在这里我们得到的是 切入点 他们都是方法 //joinPoint.getSignature().getName() 获取目标对象执行的方法名 System.out.println("myBefore--------"+joinPoint.getSignature().getName()); } /** * 后置通知，在目标对象之后调用 * 目标对象, 能在执行完毕之后执行,并获得结果 */ public void myAfterReturning(JoinPoint joinPoint,Object result){ //joinPoint.getTarget() 获取目标对象 //System.out.println(joinPoint.getTarget()); System.out.println("myAfterReturning--------"+joinPoint.getSignature().getName()); System.out.println("方法执行的结果------"+result); } /** * 环绕通知 */ public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { System.out.println("myAround--------"+proceedingJoinPoint.getSignature().getName()); // 让 目标对象执行 相应的方法 如果不执行代表 被拦截 // 返回值 目标对象执行 的结果 Object result = proceedingJoinPoint.proceed(); System.out.println(result); // 必须将 目标对象执行结果 返回给代理 return result; } /** * 异常通知 */ public void myAfterThrowing(JoinPoint joinPoint,Throwable e){ System.out.println("myAfterThrowing-被调用的方法名："+joinPoint.getSignature().getName()); //得到异常信息 System.out.println("myAfterThrowing-异常信息："+e.getMessage()); } /** * 最终通知, 相当于finally无论是否异常都会执行的代码 */ public void myAfter(JoinPoint joinPoint){ System.out.println("myAfter--------"+joinPoint.getSignature().getName()); } }2.创建xml文件
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"> <!--声明切面--> <bean class="com.yth.aspectj.MyAspectj" id="myAspectj"></bean> <!--目标对象--> <bean class="com.yth.dao.impl.StudentDaoImpl" id="studentDao"></bean> <!-- 基于aspectj xml 实现 所有织入实现功能都必须写在 aop:config --> <aop:config> <!-- 配置 切点 全局切点 可以被多个切面所应用 切点 就是要拦截的方法 expression="execution() 切点表达式 就是找到那些需要被拦截的方法 --> <aop:pointcut id="myPoint" expression="execution(* com.yth.dao.*.*.*(..))"/> <!-- 配置切面 切面就是一个类 里面的方法主要用于拦截/增强 目标对象 ref="myAspect" 引用切面实例 进行织入 过程 --> <aop:aspect id="aopAspectj" ref="myAspectj"> <!-- 前置通知 和 切点绑定 --> <aop:before method="myBefore" pointcut-ref="myPoint"></aop:before> <!-- 后置通知 和 切点绑定 returning="result" 指定后置通知用那个参数 接收目标对象返回的结果 --> <aop:after-returning method="myAfterReturning" pointcut-ref="myPoint" returning="result"></aop:after-returning> <!-- 环绕通知 和 切点绑定 --> <aop:around method="myAround" pointcut-ref="myPoint"></aop:around> <!-- 异常通知 和 切点绑定 throwing="e" 指定异常通知用那个参数 接收异常信息 --> <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPoint" throwing="e"></aop:after-throwing> <!-- 最终通知 和 切点绑定 --> <aop:after method="myAfter" pointcut-ref="myPoint"></aop:after> </aop:aspect> </aop:config> </beans>3.测试
public static void main(String[] args) { ApplicationContext applicationContext = new ClassPathXmlApplicationContext("aspectj\\Aspectj.xml"); StudentDao studentDao = (StudentDao) applicationContext.getBean("studentDao"); studentDao.fingStudentById(100); }AspectJ框架为AOP的实现提供了一套注解，用以取代Spring配置文件中为实现AOP功能所配置的臃肿代码。AspectJ的注解及其描述如下所示：
1.创建切面
package com.yth.aspectj_annotation; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component; /** * @author yth * @date 2020/10/21 - 20:20 */ @Component @Aspect public class AspectJAnnotation { @Pointcut("execution(* com.yth.dao.*.*.*(..))") public void pointCut(){} /** * 前置通知，在目标对象调用之前调用 */ @Before("pointCut()") public void myBefore(JoinPoint joinPoint){ // joinPoint 连接点 在这里我们得到的是 切入点 他们都是方法 //joinPoint.getSignature().getName() 获取目标对象执行的方法名 System.out.println("myBefore--------"+joinPoint.getSignature().getName()); } /** * 后置通知，在目标对象之后调用 * 目标对象, 能在执行完毕之后执行,并获得结果 */ @AfterReturning(value = "pointCut()",returning = "result") public void myAfterReturning(JoinPoint joinPoint,Object result){ //joinPoint.getTarget() 获取目标对象 //System.out.println(joinPoint.getTarget()); System.out.println("myAfterReturning--------"+joinPoint.getSignature().getName()); System.out.println("方法执行的结果------"+result); } /** * 环绕通知 */ @Around("pointCut()") public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { System.out.println("myAround--------"+proceedingJoinPoint.getSignature().getName()); // 让 目标对象执行 相应的方法 如果不执行代表 被拦截 // 返回值 目标对象执行 的结果 Object result = proceedingJoinPoint.proceed(); System.out.println(result); // 必须将 目标对象执行结果 返回给代理 return result; } /** * 异常通知 */ @AfterThrowing(value = "pointCut()",throwing = "e") public void myAfterThrowing(JoinPoint joinPoint,Throwable e){ System.out.println("myAfterThrowing-被调用的方法名："+joinPoint.getSignature().getName()); // 得到异常信息 System.out.println("myAfterThrowing-异常信息："+e.getMessage()); } /** * 最终通知, 相当于finally无论是否异常都会执行的代码 */ @After("pointCut()") public void myAfter(JoinPoint joinPoint){ System.out.println("myAfter--------"+joinPoint.getSignature().getName()); } }2.创建xml文件
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <aop:aspectj-autoproxy></aop:aspectj-autoproxy> <context:component-scan base-package="com.yth"></context:component-scan> </beans>3.测试
public static void main(String[] args) { ApplicationContext applicationContext = new ClassPathXmlApplicationContext("aspectj_annotation\\Aspectj_Annotation.xml"); StudentDao studentDao = applicationContext.getBean(StudentDao.class); studentDao.fingStudentById(100); }