AOP

什么是AOP？

面向切面编程 ，不修改源代码基础上增加新功能

---

1.AOP底层原理

1.aop底层使用动态代理，有两种代理情况

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

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

这里的代理对象不是通过new创建的

2. 没有接口的情况，使用CGLIB动态代理

这里的代理对象也不是通过new创建的

2.JDK实现

定义UserDao接口和实现类

定义代理类

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 add = dao.add(1, 2);
        System.out.println("add方法计算完成");
        System.out.println(add);
    }

}
class UserDaoProxy implements InvocationHandler{
    //创建谁的代理对象把谁传递过来
    private Object obj;
    public UserDaoProxy(Object obj) {
        this.obj = obj;
    }


    //增强方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方法前执行
        System.out.println("方法前执行"+method.getName()+"方法参数"+args);
        //方法执行
        Object invoke = method.invoke(obj, args);
        //方法后执行
        System.out.println("方法后执行...");
        return invoke;
    }
}

---

2.AOP术语

1）连接点：能被增强的方法如上例的add,update

2）切入点：实际被增强的方法（add)

3）通知（增强）：实际增强的逻辑部分称为通知

通知类型：前置通知，后置通知，环绕通知，异常通知，后置返回通知

4）切面：把通知应用到切入点的过程

---

3.AOP操作

1.准备

1.Spring框架一般都是基础Aspectj进行AOP操作

1）Aspectj是独立的框架，一般Aspectj和Spring组合实现AOP操作

2.基于Aspectj实现AOP操作

1）xml方式实现

2）注解实现

3.引入相关依赖

<!-- 1. Spring AOP 核心依赖（Spring 原生 AOP 基础） -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.3.27</version>
</dependency>

<!-- 2. AspectJ 核心依赖（必须） -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.9.1</version>
</dependency>

<!-- 3. AspectJ 注解支持（可选，推荐，用于 @Aspect 等注解） -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.9.9.1</version>
</dependency>

4.切入点表达式

1）切入点表达式作用：知道对哪些类里面的哪个方法进行增强

2）语法结构：

execution([权限修饰符][返回类型（可省略）][类的全路径][方法名称][参数列表])

举例1：对com.demo.spring.dao.UserDao类里面的add方法进行增强

execution(* com.demo.spring.dao.UserDao.add(..))

举例2：对com.demo.spring.dao.UserDao所有方法进行增强

execution(* com.demo.spring.dao.UserDao.*(..))

举例3：对com.demo.spring.dao包里的所有方法进行增强

execution(* com.demo.spring.dao.*.*(..))

2.实现

1.创建类在类里面定义方法并注册bean

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

2.定义增强类，并创建5个方法代表5个通知类型

@Aspect
@Component
public class UserProxy {
    //前置通知
    @Before("execution(* com.demo.spring.aop.User.add())")
    public void before(){
        System.out.println("before...");
    }
    //后置通知
    @After("execution(* com.demo.spring.aop.User.add())")
    public void after(){
        System.out.println("after...");
    }
    //异常通知
    @AfterThrowing("execution(* com.demo.spring.aop.User.add())")
    public void afterThrowing(){
        System.out.println("afterThrowing...");
    }
    //后置返回通知
    @AfterReturning("execution(* com.demo.spring.aop.User.add())")
    public void afterReturning(){
        System.out.println("afterReturning...");
    }
    //环绕通知
    @Around("execution(* com.demo.spring.aop.User.add())")
    public void around(ProceedingJoinPoint jp){
        try {
            System.out.println("环绕前...");
            jp.proceed();
            System.out.println("环绕后...");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }
}

3.进行通知配置（二选一）

class配置

@Configuration
@ComponentScan("com.demo.spring")
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AopConfig {
}

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: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.demo.spring"></context:component-scan>
<!--开启代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

4.测试

class

@Test
    public void test2(){
        ApplicationContext context = new AnnotationConfigApplicationContext(AopConfig.class);
        User user = context.getBean("user", User.class);
        user.add();
    }

xml

    @Test
    public void test1(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        User user = context.getBean("user", User.class);
        user.add();
    }

3.相同切入点的抽取

//抽取相同切入点
    @Pointcut("execution(* com.demo.spring.aop.User.add())")
    public void pointCut(){

    }
    //前置通知
    @Before("pointCut()")
    public void before(){
        System.out.println("before...");
    }

4.AOP执行顺序

当这个切入点有多个增强时，可用Order设置他的执行顺序，值越小越先执行

5.xml实现

<bean id="book" class="com.atguigu.spring5.aopxml.Book"></bean>
<bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>

<!--配置aop增强-->
<aop:config>
    <!--切入点-->
    <aop:pointcut id="p" expression="execution(* com.atguigu.spring5.aopxml.Book.buy(..))"/>

    <!--配置切面-->
    <aop:aspect ref="bookProxy">
        <!--增强作用在具体的方法上-->
        <aop:before method="before" pointcut-ref="p"/>
    </aop:aspect>
</aop:config>