Spring最好的一篇文章——AOP容器

一、AOP的概念

⭐什么叫AOP

1. 面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
2. 也就是： 不通过修改源代码方式，在主干功能里面添加新功能。

⭐ AOP底层使用动态代理

1. 第一种情况是有接口的情况，使用JDK动态代理

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

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

创建子类的代理对象，增强类的方法。

1.1 AOP（JDK动态代理）

1. 使用JDK动态代理，使用Proxy类里面的方法创建代理对象

调用newProxyInstance方法。
该方法有三个参数：
第一个：类加载器。
第二个：增强方法所在的类，这个类实现的接口，支持多个接口。
第三个：实现这个接口InvocationHandler，创建代理对象，写增强方法。

2. 编写JDK动态代理代码

(1) 创建接口，定义方法

package com.jzq.spring5.mapper;
	public interface UserMapper {
	public int add(int a, int b);
	public String update(String id);
}

(2) 创建接口实现类，实现方法

package com.jzq.spring5.mapper;
public class UserMapperImpl implements UserMapper {
    @Override
    public int add(int a, int b) {
        System.out.println("add方法执行了...");
        return a + b;
    }

    @Override
    public String update(String id) {
        System.out.println("update方法执行了");
        return "id:" + id;
    }
}

(3) 使用Proxy类创建接口代理对象

package com.jzq.spring5.mapper;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class JDKProxy {
    public static void main(String[] args) {
        // 创建接口实现类代理对象
        Class[] interfaces = {UserMapper.class};

        // 这里可以通过IOC控制反转得到对象，但是我这里直接new了
        UserMapperImpl userMapperImpl = new UserMapperImpl();

        // 这里要进行AOP了，就是在不进行修改源码的情况，为代码增加逻辑

        UserMapper userMapper = (UserMapper)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserMapperProxy(userMapperImpl));
        int result = userMapper.add(1,2);
        String res = userMapper.update("EDDD-DSSS");
        System.out.println("result:" + result);
    }
}


// 创建代理对象代码
class UserMapperProxy implements InvocationHandler {
    // 1. 把创建的是谁的代理对象，把谁传进来
    // 有参数的构造

    private Object object;
    public UserMapperProxy(Object object) {
        this.object = object;
    }

    // 写增强的逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 方法之前
        System.out.println("方法执行之前： " + method.getName() + "传递的参数" + Arrays.toString(args));

        // 被增强的方法执行
        Object res = method.invoke(object, args);

        // 方法之后
        System.out.println("方法执行之后.."+object);

        // 返回res，增强的方法
        return res;
    }
}

1.2 AOP（术语）

⭐ 连接点

类里面哪些方法可以被增强，这些方法被称为连接点。

⭐ 切入点

实际被真正增强的方法，称为切入点。

⭐ 通知(增强)

(1) 实际增强的逻辑部分称为通知(增强)
(2）通知有多种类型: 前置通知、后置通知、环绕通知、异常通知、最终通知 finally

⭐ 切面(是动作)

(1) 把通知应用到切入点过程

1.3 AOP操作（准备）

⭐ spring框架一般都是基于AspectJ实现AOP操作

AspectJ不是spring的组成部分，独立AOP框架，一般把AspectJ和spring框架一起使用，进行AOP操作。

⭐ 切入点表达式

1.4 AOP操作（AspectJ注解）

⭐1. 创建类，在类里面定义方法

package com.jzq.spring5.aopseven;

import org.springframework.stereotype.Component;

public class User {
    public void add() {
        System.out.println("增加了一个用户");
    }
}

⭐2. 创建增强类(编写增强逻辑)
(1) 在增强类里面，创建方法，让不同方法代表不同通知(增强)。

package com.jzq.spring5.aopseven;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

public class UserProxy {
    public void before(){
        System.out.println("前置通知");
    }

}

⭐3. 进行通知的配置
(1) 在spring配置文件中，开启注解扫描(IOC)。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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.jzq.spring5.aopseven"></context:component-scan>

</beans>

(2) 使用注解创建User和UserProxy。在增强类UserProxy上面添加注释@Aspect。

注解开发，IOC控制反转知识

User类 配置
//IOC注解
@Component : (xml 配置了包扫描<context:component-scan>)

package com.jzq.spring5.aopseven;

import org.springframework.stereotype.Component;


//IOC注解
@Component  
public class User {
    public void add() {
        System.out.println("增加了一个用户");
    }
}

@Component : IOC控制反转 (xml 配置了包扫描<context:component-scan>)
@Aspect： 生成代理对象 （在xml配置了 <aop:aspectj-autoproxy/>）

package com.jzq.spring5.aopseven;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

//IOC注解
@Component
// 生成代理对象
@Aspect
public class UserProxy {

    // 前置通知
    // @Before注解表示前置通知
    @Before(value = "execution(* com.jzq.spring5.aopseven.User.add(..))")
    public void before(){
        System.out.println("前置通知");
    }
}

(3) 在spring配置文件中开启生成代理对象。

开启Aspect生成代理对象, 他会寻找带有@Aspect注解的类
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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.jzq.spring5.aopseven"></context:component-scan>

<!--  开启Aspect生成代理对象, 他会寻找带有@Aspect注解的类  -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

⭐4. 配置不同类型的通知(增强)

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

⭐⭐ 几种通知配置
前置通知配置 @Before (value = "execution(* com.jzq.spring5.aopseven.User.add(…))
后置通知（返回通知）：@AfterReturning(value = “execution(* com.jzq.spring5.aopseven.User.add(…))”)
最终通知：@After(value = “execution(* com.jzq.spring5.aopseven.User.add(…))”)
异常通知： @AfterThrowing(value = “execution(* com.jzq.spring5.aopseven.User.add(…))”)
环绕通知： @Around(value = “execution(* com.jzq.spring5.aopseven.User.add(…))”) // 这个需要传参ProceedingJoinPoint

（2）正常情况下执行顺序

环绕前通知 Around
前置通知 Before
增加了一个
环绕后通知 Around
最终通知 After
后置通知 AfterReturning

(3) 有异常的情况下执行顺序

环绕前通知 Around
前置通知 Before
最终通知 After
异常通知 AfterThrowing

package com.jzq.spring5.aopseven;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

//IOC注解
@Component
// 生成代理对象
@Aspect
public class UserProxy {

    // 前置通知
    // @Before注解表示前置通知
    @Before(value = "execution(* com.jzq.spring5.aopseven.User.add(..))")
    public void before() {
        System.out.println("前置通知");
    }

    //后置通知（返回通知）
    @AfterReturning(value = "execution(* com.jzq.spring5.aopseven.User.add(..))")
    public void afterReturning() {
        System.out.println("后置通知");
    }

    // 最终通知
    @After(value = "execution(* com.jzq.spring5.aopseven.User.add(..))")
    public void after() {
        System.out.println("最终通知");
    }

    // 异常通知
    @AfterThrowing(value = "execution(* com.jzq.spring5.aopseven.User.add(..))")
    public void afterThrowing() {
        System.out.println("异常通知");
    }

    // 环绕通知
    @Around(value = "execution(* com.jzq.spring5.aopseven.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕前通知");

        // 被增强的方法执行
        proceedingJoinPoint.proceed();

        System.out.println("环绕后通知");
    }

}

1.5 AOP（相同切入点抽取）

注解： @Pointcut(value = “execution(* com.jzq.spring5.aopseven.User.add(…))”)
指的是别的切入点指定表达式的时候可以通过一个函数来指定

// 仙童切入点抽取
    @Pointcut(value = "execution(* com.jzq.spring5.aopseven.User.add(..))")
    public void pointdemo() {
        // 指的是别的切入点指定表达式的时候可以通过这个函数来指定
    }

1.6 AOP (多个增强类对同一个方法进行增强时，设置增强类的优先级)

通过注解 @Order(-1) 设置， 数值越小优先级越高

package com.jzq.spring5.aopseven;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Aspect
@Order(-2)
public class PersonProxy {


    @Before(value = "execution(* com.jzq.spring5.aopseven.User.add(..))")
    public void before() {
        System.out.println("person前置切入");
    }

}

1.7 全注解开发AOP

不需要xml配置文件，但是需要一个配置类
@EnableAspectJAutoProxy(proxyTargetClass = true) 表示开启Aspect

package com.jzq.spring5.config;


import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan(basePackages = {"com.jzq.spring5.aopseven"})

// == <aop:aspectj-autoproxy></aop:aspectj-autoproxy> <!--  开启Aspect生成代理对象, 他会寻找带有@Aspect注解的类  -->
@EnableAspectJAutoProxy(proxyTargetClass = true)

public class ConfigPrr {
}

1.8 AOP（配置文件实现）

1. 创建增强类(…Proxy) 与被增强类
2. 在spring配置文件中创建两个bean(类对象)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
                          ">
    <!--  IOC 配置对象  -->
    <bean id="book" class="com.jzq.spring5.aopxml.Book"></bean>
    <bean id="bookPorxy" class="com.jzq.spring5.aopxml.BookProxy"></bean>
</beans>

3. 在spring配置文件配置切入点

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
                          ">


    <!--  IOC 配置对象  -->
    <bean id="book" class="com.jzq.spring5.aopxml.Book"></bean>
    <bean id="bookPorxy" class="com.jzq.spring5.aopxml.BookProxy"></bean>

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

        <!--  配置切面(把通知应用到切入点的过程)  -->
        <aop:aspect ref="bookPorxy">
            <!--  增强作用在具体的方法  -->
            <aop:before method="before" pointcut-ref="p"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>