AOP（面向切面编程）

概念：面向切面编程（面向方面编程）利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

通俗描述：不通过修改源代码方式，在主干功能里添加新功能

底层原理

AOP底层使用动态代理方式 有两种情况的动态代理有接口情况，使用JDK动态代理没有接口情况，使用CGLIB动态代理

有接口情况，使用JDK动态代理

创建UserDao接口实现类代理对象，增强类的方法

没有接口情况,使用CGLIB动态代理

创建当前类子类的代理对象

AOP（JDK动态代理）

使用JDK动态代理，使用Proxy类里面的方法创建代理对象调用newProxyInstance方法来实现，有三个参数 类加载器增强方法所在的类，类实现的接口，支持多个接口实现这个接口InvocationHandler，创建代理对象，写增强的方法

编写JDK动态代理代码

创建接口，定义方法

public interface UserDao { int add(int a,int b); String update(String id); }

创建接口实现类，实现方法

public class UserDaoImpl implements UserDao{ public int add(int a, int b) { return a+b; } public String update(String id) { return id; } }

使用Proxy创建接口的代理对象

public class JDKProxy { public static void main(String[] args) { //创建接口实现类的代理对象 UserDao userDao = new UserDaoImpl(); Class[] interfaces = {UserDao.class}; UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao)); int res = dao.add(1, 2); System.out.println("result = "+res); } } //创建代理对象代码 class UserDaoProxy implements InvocationHandler { //把创建的代理对象的本体传递过来 //有惨构造进行传递 private Object obj; public UserDaoProxy(Object obj) { this.obj = obj; } //增强的逻辑 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //方法之前 System.out.println("方法前执行 : " + method.getName() + "传递的参数：" + Arrays.toString(args)); //被增强的方法执行 Object res = method.invoke(obj, args); //方法之后 System.out.println("方法后执行 : " + obj); return res; } }

AOP术语

连接点，类里面哪些方法可以被增强，这些方法称为连接点切入点，实际被增强的方法，称为切入点通知（增强）， 实际增强的逻辑部分称为通知（增强）通知有多种类型，前置通知,后置通知,环绕通知,异常通知，最终通知（finally） 切面:把通知应用到切入点的过程

AOP操作（准备）

Spring框架中，一般基于AspectJ实现AOP操作

AspectJ：不是spring组成部分，独立AOP框架，一半把AspectJ与Spring框架一起使用。进行AOP相关操作

基于AspectJ实现AOP操作

基于xml配置文件基于注解方式（使用）

在项目工程中引入AOP相关依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> <version>5.2.9.RELEASE</version> </dependency>

切入点表达式

切入点表达式的作用：知道对哪个类里面的哪个方法进行增强语法结构execution([权限修饰符][返回类型][全类名][方法名称]([参数列表])

举例1：对com.yang.dao.Book类里面的add进行增强

execution(* com.yang.dao.Book.add(..))

举例2：对com.yang.dao.Book类里面的所有方法进行增强

execution(* com.yang.dao.Book.*(..))

举例3：对com.yang.dao包里面的所有类里面的所有包进行增强

execution(* com.yang.dao.*.*(..))

AOP操作（AspectJ注解）

创建类，在类里面定义方法，

public class User { public void add(){ System.out.println("add,,,,"); } }

创建增强类(编写增强的逻辑)

在增强类里面创建方法，让不同方法代表不同通知类型

//增强的类 public class UserProxy { //前置通知 public void before(){ System.out.println("before........"); } }

进行通知的配置

在Spring配置文件中，开启注解扫描

<?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:context="http://www.springframework.org/schema/context" 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/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!--开启注解扫描--> <context:component-scan base-package="com.yang.aopanno"/> </beans>

使用注解创建Userh和UserProxy对象

package com.yang.aopanno; import org.springframework.stereotype.Component; //被增强类 @Component public class User { public void add(){ System.out.println("add,,,,"); } } package com.yang.aopanno; import org.springframework.stereotype.Component; //增强的类 @Aspect @Component public class UserProxy { //前置通知 public void before(){ System.out.println("before........"); } }

在增强类上面添加注解@Aspect

在Spring配置文件中，开启生成代理对象

<aop:aspectj-autoproxy/>

配置不同类型的通知

在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式

package com.yang.aopanno; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component; //增强的类 @Component @Aspect //生成代理对象 public class UserProxy { //前置通知 //@Before注解表示作为前置通知 @Before(value = "execution(* com.yang.aopanno.User.add(..))") public void before() { System.out.println("before........"); } //最终通知 @After(value = "execution(* com.yang.aopanno.User.add(..))") public void after() { System.out.println("after........."); } //后置通知（返回通知），有异常不执行 @AfterReturning(value = "execution(* com.yang.aopanno.User.add(..))") public void afterReturning() { System.out.println("afterReturning...."); } @AfterThrowing(value = "execution(* com.yang.aopanno.User.add(..))") public void afterThrowing() { System.out.println("afterThrowing...."); } @Around(value = "execution(* com.yang.aopanno.User.add(..))") public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{ System.out.println("环绕之前。。。"); proceedingJoinPoint.proceed(); System.out.println("环绕之后。。。"); } }

公共切入点提取

//相同切入点抽取 @Pointcut(value = "execution(* com.yang.aopanno.User.add(..))") public void pointDemo(){ } @Before(value = "pointDemo()") public void before() { System.out.println("before........"); }

有多个增强类对同一个方法进行增强，设置增强类优先级

在增强类上面添加注解@Order(数字类型值),数字类型值越小，优先级越高

@Component//对象创建 @Aspect//代理对象创建 @Order(1) public class PersonProxy { @Before(value = "execution(* com.yang.aopanno.User.add(..))") public void before(){ System.out.println("Person before......"); } } @ComponentScan(basePackages = {"com.yang"}) @Configuration @EnableAspectJAutoProxy(proxyTargetClass = true) public class MyConfig { }

AOP操作（AspectJ配置文件）

创建两个类，增强类和被增强类，创建方法

在spring配置文件中创建两个类对象

<!-- 创建对象--> <bean id="book" class="com.yang.aopxml.Book"/> <bean id="bookProxy" class="com.yang.aopxml.BookProxy"/>

在spring配置文件中配置切入点

<!-- 创建对象--> <bean id="book" class="com.yang.aopxml.Book"/> <bean id="bookProxy" class="com.yang.aopxml.BookProxy"/> <!-- 配置aop增强--> <aop:config> <!-- 配置切入点--> <aop:pointcut id="p" expression="execution(* com.yang.aopxml.Book.buy(..))"/> <!-- 配置切面--> <aop:aspect ref="bookProxy"> <!-- 增强在具体的方法上--> <aop:before method="before" pointcut-ref="p"/> </aop:aspect> </aop:config>