2021-08-18 AOP,静态代理，动态代理

Spring AOP

代理模式
代理模式的定义 代理模式 ：代理模式又叫 委托模式 ，是为某个对象提供一个代理对象，并且由代理对象控制对原对象的访问。
代理模式的两个设计原则：
1. 代理类 与 委托类 具有相似的行为（共同）
2. 代理类增强委托类的行

静态代理

1. 静态代理的特点
   1、目标角色固定
   2、在应用程序执行前就得到目标角色
   3、代理对象会增强目标对象的行为
   4、有可能存在多个代理 引起"类爆炸"（缺点）
2. 静态代理的实现
   1、定义接口

   /**
   * 定义行为
   */
   public interface Marry {
   	public void toMarry();
   }
   

   2、目标对象

   /**
   * 静态代理 ——> 目标对象
   */
   public class You implements Marry {
   	// 实现行为
   	@Override
   	public void toMarry() {
   	System.out.println("我要结婚了...");
   	}
   }
   

   3、 代理对象（实现行为、增强目标对象的行为）

   /**
   * 静态代理 ——> 代理对象
   */
   public class MarryCompanyProxy implements Marry {
   	// 目标对象
   	private Marry marry;
   	// 通过构造器将目标对象传入
   	public MarryCompanyProxy(Marry marry) {
   		this.marry = marry;
   	}
   	// 实现行为
   	@Override
   	public void toMarry() {
   		// 增强行为
   	before();
   	// 执行目标对象中的方法
   	marry.toMarry();
   	// 增强行为
   	after();
   }
   	/**
   	* 增强行为
   	*/
   	private void after() {
   		System.out.println("新婚快乐，早生贵子！");
   	}
   	/**
   	* 增强行为
   	*/
   	private void before() {
   		System.out.println("场地正在布置中...");
   		}
   }
   
   

   4、通过代理对象实现目标对象的功能

   // 目标对象
   You you = new You();
   // 构造代理角色同时传入真实角色
   MarryCompanyProxy marryCompanyProxy = new MarryCompanyProxy(you);
   // 通过代理对象调用目标对象中的方法
   marryCompanyProxy.toMarry();
   

动态代理

动态代理的两种实现方式：
1. JDK 动态代理
2. CGLIB动态代理
动态代理的特点

1. 目标对象不固定
2. 在应用程序执行时动态创建目标对象
3. 代理对象会增强目标对象的行为

JDK动态代理

注：JDK动态代理的目标对象必须有接口实现

public class JdkHandler implements InvocationHandler {

	//目标对象
	// 目标对象的类型不固定，创建时动态生成
    private Object target;
	//通过构造器将目标对象赋值
    public JdkHandler(Object target) {
        this.target = target;
    }
   	/**
	* 1、调用目标对象的方法（返回Object）
	* 2、增强目标对象的行为
	* @param proxy 调用该方法的代理实例
	* @param method 目标对象的方法
	* @param args 目标对象的方法形参
	* @return
	* @throws Throwable
	*/
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法前执行===========》");

        Object result = method.invoke(target, args);

        System.out.println("方法后执行===========》");

        return result;
    }

    /**
     * 动态生成代理对象的方法
     * @return
     * loader : 用哪个类加载器去加载代理对象
     * interfaces: 动态代理类需要实现的接口
     * h:InvocationHandler 类型动态代理方法在执行时，会调用h里面的invoe方法执行
     */
    public Object getTarget() {
        Object o = Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
        return o;
    }
    /*
        public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h) {
        Objects.requireNonNull(h);
	*/
}

通过代理对象实现目标对象的功能

// 目标对象
You you = new You();
// 获取代理对象
JdkHandler jdkHandler = new JdkHandler(you);
Marry marry = (Marry) jdkHandler.getProxy();
// 通过代理对象调用目标对象中的方法
marry.toMarry();

问：Java动态代理类中的invoke是怎么调用的？
答：在生成的动态代理类$Proxy0.class中，构造方法调用了父类Proxy.class的构造方法，给成员变量invocationHandler赋值，$Proxy0.class的static模块中创建了被代理类的方法，调用相应方法时方法体中调用了父类中的成员变量InvocationHandler的invoke()方法。

注：JDK的动态代理依靠接口实现，如果有些类并没有接口实现，则不能使用JDK代理。

CGLIB 动态代理

1. 添加依赖
   在pom.xml文件中引入cglib的相关依赖

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
	<groupId>cglib</groupId>
	<artifactId>cglib</artifactId>
	<version>2.2.2</version>
</dependency>

public class CglibInterceptor implements MethodInterceptor {

    //目标对象
    private Object target;
    //通过构造器传入目标对象
    public CglibInterceptor(Object target) {
        this.target = target;
    }

    /**
     * 拦截器
     * 1、目标对象的方法调用
     * 2、增强行为
     * @param object 由CGLib动态生成的代理类实例
     * @param method 实体类所调用的被代理的方法引用
     * @param objects 参数值列表
     * @param methodProxy 生成的代理类对方法的代理引用
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object object, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        // 增强行为
        System.out.println("方法前增强。。。");
        // 调用目标对象的方法（返回Object）
        Object result = methodProxy.invoke(target, objects);
        // 增强行为
        System.out.println("方法后增强。。。");
        
        return result;
    }

    public Object getTarget() {
        // 通过Enhancer对象的create()
        // 方法可以生成一个类，用于生成代理对象
        Enhancer enhancer = new Enhancer();
        // 设置父类 (将目标类作为其父类)
        enhancer.setSuperclass(target.getClass());
        // 设置拦截器 回调对象为本身对象
        enhancer.setCallback(this);
        // 生成一个代理类对象，并返回
        // 这时返回的就是增强过的目标类
        return enhancer.create();
    }
}

3. 调用方法

// 目标对象
You you = new You();
CglibInterceptor cglibInterceptor = new CglibInterceptor(you);
Marry marry = (Marry) cglibInterceptor.getProxy();
marry.toMarry();
User user = new User();
CglibInterceptor cglibInterceptor = new CglibInterceptor(user);
User u = (User) cglibInterceptor.getProxy();
u.test();

JDK代理与CGLIB代理的区别

• JDK动态代理实现接口，Cglib动态代理继承思想
• JDK动态代理（目标对象存在接口时）执行效率高于Ciglib
• 如果目标对象有接口实现，选择JDK代理，如果没有接口实现选择Cglib代理

Spring AOP

	Aspect Oriented Programing 面向切面编程，相比较 oop 面向对象编程来说，Aop关注的不再是程序代码中某个类，某些方法，而aop考虑的更多的是一种面到面的切入，即层与层之间的一种切入，所以称之为切面

1、作用
AOP主要应用于日志记录，性能统计，安全控制,事务处理等方面，实现公共功能性的重复使用。
2、AOP特点
1. 降低模块与模块之间的耦合度，提高业务代码的聚合度。（高内聚低耦合）
2. 提高了代码的复用性。
3. 提高系统的扩展性。（高版本兼容低版本）
4. 可以在不影响原有的功能基础上添加新的功能
3、底层实现
动态代理（JDK + CGLIB）
4、AOP基本概念
1. Joinpoint（连接点）
被拦截到的每个点，spring中指被拦截到的每一个方法，spring aop一个连接点即代表一个方法的执行。
2. Pointcut（切入点）
对连接点进行拦截的定义（匹配规则定义 规定拦截哪些方法，对哪些方法进行处理），spring 有专门的表达式语言定义。
3. Advice（通知）
拦截到每一个连接点即（每一个方法）后所要做的操作
> 1. 前置通知 （前置增强）— before() 执行方法前通知
> 2. 返回通知（返回增强）— afterReturn 方法正常结束返回后的通知
> 3. 异常抛出通知（异常抛出增强）— afetrThrow()
> 4. 最终通知 — after 无论方法是否发生异常，均会执行该通知。
> 5. 环绕通知 — around 包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类 型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的 返回值或抛出异常来结束执行。
4. Aspect（切面）
切入点与通知的结合，决定了切面的定义，切入点定义了要拦截哪些类的哪些方法，通知则定义了拦截过方法后要做什么，切面则是横切关注点的抽象，与类相似，类是对物体特征的抽象，切面则是横切
关注点抽象。
5. Target（目标对象）
被代理的目标对象
6. Weave（织入）
将切面应用到目标对象并生成代理对象的这个过程即为织入
7. Introduction（引入）
在不修改原有应用程序代码的情况下，在程序运行期为类动态添加方法或者字段的过程称为引入

Spring AOP的实现

1. 坐标依赖引入与环境配置

<!--Spring AOP-->
<dependency>
	<groupId>org.aspectj</groupId>
	<artifactId>aspectjweaver</artifactId>
	<version>1.8.9</version>
</dependency>

添加命名空间

xmlns:aop=“http://www.springframework.org/schema/aop”
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd

1、注解实现
配置AOP代理

aop:aspectj-autoproxy/
定义切面

/**
 * 切面
 * 切入点和通知的抽象 （与面向对象中的 类 相似）
 * 定义 切入点和通知 （切入点定义了要拦截哪些类的哪些方法，通知则定义了拦截过方法后要做什么）
 */
@Component // 将对象交给IOC容器去实例化
@Aspect // 声明当前类是一个切面
public class LogCut {
    /**
     * 切入点：
     * 匹配规则。规定什么方法被拦截、需要处理什么方法
     * 定义切入点
     * @Pointcut("匹配规则")
     *
     * Aop 切入点表达式简介
     * 1. 执行任意公共方法：
     * execution(public *(..))
     * 2. 执行任意的set方法
     * execution(* set*(..))
     * 3. 执行com.xxxx.service包下任意类的任意方法
     * execution(* com.xxxx.service.*.*(..))
     * 4. 执行com.xxxx.service 包 以及子包下任意类的任意方法
     * execution(* com.xxxx.service..*.*(..))
     *
     * 注：表达式中的第一个* 代表的是方法的修饰范围
     * 可选值：private、protected、public （* 表示所有范围）
     */
    @Pointcut("execution (* com.xxxx.service..*.*(..) )")
    public void cut(){}
    /**
     * 声明前置通知 并将通知应用到定义的切入点上
     * 目标类方法执行前 执行该通知
     *
     */
    @Before(value = "cut()")
    public void before() {
        System.out.println("前置通知.....");
    }
    /**
     * 声明返回通知 并将通知应用到定义的切入点上
     * 目标类方法（无异常）执行后 执行该通知
     *
     */
    @AfterReturning(value = "cut()")
    public void afterReturn() {
        System.out.println("返回通知.....");
    }
    /**
     * 声明最终通知 并将通知应用到定义的切入点上
     * 目标类方法（无异常或有异常）执行后 执行该通知
     *
     */
    @After(value = "cut()")
    public void after() {
        System.out.println("最终通知.....");
    }
    /**
     * 声明异常通知 并将通知应用到定义的切入点上
     * 目标类方法出现异常时 执行该通知
     */
    @AfterThrowing(value="cut()",throwing = "e")
    public void afterThrow(Exception e) {
        System.out.println("异常通知....." + " 异常原因：" + e.getCause());
    }
    /**
     * 声明环绕通知 并将通知应用到切入点上
     * 方法执行前后 通过环绕通知定义相应处理
     * 需要通
     * @param pjp
     * @return
     */
    @Around(value = "cut()")
    public Object around(ProceedingJoinPoint pjp) {
        System.out.println("前置通知...");
        Object object = null;
        try {
            object = pjp.proceed();
            System.out.println(pjp.getTarget() + "======" + pjp.getSignature());
        // System.out.println("返回通知...");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("异常通知...");
        }
        System.out.println("最终通知...");
        return object;
    }
}

2、XML实现
配置文件（spring.xml）

<!--aop相关配置-->
<aop:config>
    <!--aop切面-->
    <aop:aspect ref="logCut02">
        <!-- 定义aop 切入点 -->
        <aop:pointcut id="cut" expression="execution(* com.xxxx.service..*.*(..))"/>
        <!-- 配置前置通知 指定前置通知方法名 并引用切入点定义 -->
        <aop:before method="before" pointcut-ref="cut"/>
        <!-- 配置返回通知 指定返回通知方法名 并引用切入点定义 -->
        <aop:after-returning method="afterReturn" pointcut-ref="cut"/>
        <!-- 配置异常通知 指定异常通知方法名 并引用切入点定义 -->
        <aop:after-throwing method="afterThrow" throwing="e" pointcutref="cut"/>
        <!-- 配置最终通知 指定最终通知方法名 并引用切入点定义 -->
        <aop:after method="after" pointcut-ref="cut"/>
        <!-- 配置环绕通知 指定环绕通知方法名 并引用切入点定义 -->
        <aop:around method="around" pointcut-ref="cut"/>
    </aop:aspect>
</aop:config>

定义切面

/**
 * 切面
 * 切入点和通知的抽象 （与面向对象中的 类 相似）
 * 定义 切入点和通知 （切入点定义了要拦截哪些类的哪些方法，通知则定义了拦截过方法后要做什么）
 */
@Component // 将对象交给IOC容器去实例化
public class LogCut02 {
    public void cut(){}
    /**
     * 声明前置通知 并将通知应用到定义的切入点上
     * 目标类方法执行前 执行该通知
     *
     */
    public void before() {
        System.out.println("前置通知.....");
    }
    /**
     * 声明返回通知 并将通知应用到定义的切入点上
     * 目标类方法（无异常）执行后 执行该通知
     *
     */
    public void afterReturn() {
        System.out.println("返回通知.....");
    }
    /**
     * 声明最终通知 并将通知应用到定义的切入点上
     * 目标类方法（无异常或有异常）执行后 执行该通知
     *
     */
    public void after() {
        System.out.println("最终通知.....");
    }
    /**
     * 声明异常通知 并将通知应用到定义的切入点上
     * 目标类方法出现异常时 执行该通知
     */
    public void afterThrow(Exception e) {
        System.out.println("异常通知....." + " 异常原因：" + e.getCause());
    }
    /**
     * 声明环绕通知 并将通知应用到切入点上
     * 方法执行前后 通过环绕通知定义相应处理
     * 需要通过显式调用对应的方法，否则无法访问指定方法 (pjp.proceed();)
     * @param pjp
     * @return
     */
    public Object around(ProceedingJoinPoint pjp) {
        System.out.println("前置通知...");
        Object object = null;
        try {
            object = pjp.proceed();
            System.out.println(pjp.getTarget() + "======" + pjp.getSignature());
            // System.out.println("返回通知...");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("异常通知...");
        }
        System.out.println("最终通知...");
        return object;
    }
}

代理模式实现三要素

1. 接口定义
2. 目标对象与代理对象必须实现统一接口
3. 代理对象持有目标对象的引用 增强目标对象行为

代理模式实现分类以及对应区别

1. 静态代理：手动为目标对象制作代理对象，即在程序编译阶段完成代理对象的创建
2. 动态代理：在程序运行期动态创建目标对象对应代理对象。
3. jdk动态代理：被代理目标对象必须实现某一或某一组接口 实现方式 通过回调创建代理对象。
4. cglib 动态代理：被代理目标对象可以不必实现接口，继承的方式实现。
   动态代理相比较静态代理，提高开发效率，可以批量化创建代理，提高代码复用率。

Aop 理解

1. 面向切面，相比oop 关注的是代码中的层 或面
2. 解耦，提高系统扩展性
3. 提高代码复用

Aop 关键词
4. 连接点:每一个方法
5. 切入点:匹配的方法集合
6. 切面：连接点与切入点的集合决定了切面，横切关注点的抽象
7. 通知:几种通知
8. 目标对象:被代理对象
9. 织入：程序运行期将切面应用到目标对象 并生成代理对象的过程
10. 引入:在不修改原始代码情况下，在程序运行期为程序动态引入方法或字段的过程