Spring入门02-AOP

一、导图

 二、代理模式

        代理模式在 Java 开发中是一种比较常见的设计模式。设计目的旨在为服务类与客户类之间插入其他功能，插入的功能对于调用者是透明的，起到伪装控制的作用。如租房的例子：房客、中介、房东。对应于代理模式中即：客户类、代理类 、委托类（被代理类）。

        为某一个对象（委托类）提供一个代理（代理类），用来控制对这个对象的访问。委托类和代理类有一个共同的父类或父接口。代理类会对请求做预处理、过滤，将请求分配给指定对象。

代理模式的两个设计原则：

1.  代理类 与 委托类 具有相似的行为（共同）
2.  代理类增强委托类的行为

常用的代理模式： 1. 静态代理 2. 动态代理

一、静态代理

        某个对象提供一个代理，代理角色固定，以控制对这个对象的访问。代理类和委托类有共同的父类或父接口，这样在任何使用委托类对象的地方都可以用代理对象替代。代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执行完请求后的后续处理。

代理的三要素： 

        a、有共同的行为（结婚） - 接口

        b 、目标角色（新人） - 实现行为

        c 、代理角色（婚庆公司） - 实现行为 增强目标对象行为

静态代理的实现思路：

1.定义行为（共同） 定义接口

2.目标对象（实现行为）

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

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

静态代理的特点：

        1、目标角色固定

        2、在应用程序执行前就得到目标角色

        3、代理对象会增强目标对象的行为

        4、有可能存在多个代理 引起 " 类爆炸 " （缺点）

注：静态代理对于代理的角色是固定的，如 dao 层有 20 个 dao 类，如果要对方法的访问权限进行代理，此时需要创建20 个静态代理角色，引起类爆炸，无法满足生产上的需要，于是就催生了动态代理的思想。

二、动态代理

相比于静态代理，动态代理在创建代理对象上更加的灵活， 动态代理类的字节码在程序运行时，由
Java反射机制动态产生。它会根据需要，通过反射机制在程序运行期，动态的为目标对象创建代理对象，无需程序员手动编写它的源代码。动态代理不仅简化了编程工作，而且提高了软件系统的可扩展性，因为反射机制可以生成任意类型的动态代理类。代理的行为可以代理多个方法，即满足生产需要的同时又达到代码通用的目的。

动态代理的两种实现方式：

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

2. CGLIB 动态代理

动态代理的特点

        1. 目标对象不固定

        2. 在应用程序执行时动态创建目标对象

        3. 代理对象会增强目标对象的行为

1.JDK动态代理

        a、每一个代理类都需要实现InvocationHandler接口

        b、Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下操作方法：

/*
返回一个指定接口的代理类的实例方法调用分派到指定的调用处理程序。 (返回代理对象)
loader：一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
interfaces：一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果 我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
h：一个InvocationHandler接口，表示代理实例的调用处理程序实现的接口。每个代理实例都具有一个 关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的invoke方法（传入InvocationHandler接口的子类）
*/
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,
InvocationHandler h)

JDK动态代理类：

1.把目标对象传给代理类，调用getProxy()方法(里面调用了Proxy.newProxyInstance()生成了一个代理)得到代理对象

//目标对象
Owner owner = new Owner();
//得到代理类
JdkHandler jdkHandler1 = new JdkHandler(owner);
//得到代理对象
RentHouse rentHouse = (RentHouse) jdkHandler1.getProxy();
//通过代理对象调用目标对象的方法
rentHouse.toRentHouse();

2.因为JdkHandler implements InvocationHandler；只要通过代理对象调用的方法，最终会由它的底层代码转向调用invoke()方法。即上面rentHouse.toRentHouse();最终执行invoke。

3.代码如下：

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

/**
 * JDK动态代理类
 *      每一个代理类都需要实现InvocationHandler接口
 */
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("invoke方法的proxy参数："+proxy.getClass().getName());
        //用户的增强行为
        System.out.println("------方法执行前------");
        //调用目标对象的方法（返回Object类型）
        Object obj = method.invoke(target, args);
        //用户的增强行为
        System.out.println("------方法执行后------");

//        return null;
        return obj;
    }

    /**
     * 获取代理对象
     *  public static Object newProxyInstance(ClassLoader loader,
     *                                       Class[] interfaces,
     *                                       InvocationHandler h)
     *   loader：类加载器
     *   interfaces：接口数组
     *          target.getClass().getInterfaces()：目标对象的接口数组
     *   h：InvocationHandler接口（传入InvocationHandler接口的实现类）
     *
     * @return
     */
    public Object getProxy(){
        Object obj = Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
        System.out.println("getProxy返回的代理对象："+obj.getClass().getName());
        return obj;
    }

}

问：Java动态代理类中的invoke是怎么调用的？

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

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

2. CGLIB动态代理

JDK 的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能使用 JDK 的动态代理， cglib 是针对类来实现代理的，它的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

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

<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>

而jdk代理不需要添加依赖：

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

3.JDK代理与CGLIB代理的区别

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

三、Spring AOP

什么是AOP？

Aspect Oriented Programing 面向切面编程，相比较 oop 面向对象编程来说， Aop 关注的不再是程

序代码中某个类，某些方法，而 aop 考虑的更多的是一种面到面的切入，即层与层之间的一种切入，所 以称之为切面。联想大家吃的汉堡（中间夹肉）。那么aop 是怎么做到拦截整个面的功能呢？考虑前面 学到的servlet filter /* 的配置 ，实际上也是 aop 的实现。

AOP能做什么？

AOP 主要应用于日志记录，性能统计，安全控制 , 事务处理等方面，实现公共功能性的重复使用。

AOP的特点

1. 降低模块与模块之间的耦合度，提高业务代码的聚合度。（高内聚低耦合）

2. 提高了代码的复用性。

3. 提高系统的扩展性。（高版本兼容低版本）

4. 可以在不影响原有的功能基础上添加新的功能

AOP的底层实现：动态代理（JDK + CGLIB）

AOP基本概念

1 连接点 Joint point:

类里面那些可以被增强的方法,这些方法称之为连接点

2 切入点 Pointcut: 
实际被增强的方法,称之为切入点

3 通知 Advice: 
实际增强的逻辑部分称为通知 (增加的功能)

1. 前置通知 （前置增强） — before() 执行方法前通知

2. 返回通知（返回增强） — afterReturn 方法正常结束返回后的通知

3. 异常抛出通知（异常抛出增强） — afetrThrow()

4. 最终通知 — after 无论方法是否发生异常，均会执行该通知。

5. 环绕通知 — around 包围一个连接点（ join point ）的通知，如方法调用。这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

4 目标对象 Target：被增强功能的对象(被代理的对象)
织入 Advice 的目标对象

5 切面Aspect： 表现为功能相关的一些advice方法放在一起声明成的一个Java类
Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。

6 织入 Weaving：创建代理对象并实现功能增强的声明并运行过程
将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程

7.Introduction（引入）

在不修改原有应用程序代码的情况下，在程序运行期为类动态添加方法或者字段的过程称为引入

两种实现：

1.注解实现

2.xml实现

四Spring AOP总结

代理模式实现三要素

1. 接口定义

2. 目标对象与代理对象必须实现统一接口

3. 代理对象持有目标对象的引用 增强目标对象行为

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

1. 静态代理：手动为目标对象制作代理对象，即在程序编译阶段完成代理对象的创建

2. 动态代理：在程序运行期动态创建目标对象对应代理对象。

3. jdk 动态代理：被代理目标对象必须实现某一或某一组接口 实现方式 通过回调创建代理对象。

4. cglib 动态代理：被代理目标对象可以不必实现接口，继承的方式实现。

动态代理相比较静态代理，提高开发效率，可以批量化创建代理，提高代码复用率。

Aop 理解

1. 面向切面，相比 oop 关注的是代码中的层 或面

2. 解耦，提高系统扩展性

3. 提高代码复用

Aop 关键词

1. 连接点 : 每一个方法

2. 切入点 : 匹配的方法集合

3. 切面：连接点与切入点的集合决定了切面，横切关注点的抽象

4. 通知 : 几种通知

5. 目标对象 : 被代理对象

6. 织入：程序运行期将切面应用到目标对象 并生成代理对象的过程

7. 引入 : 在不修改原始代码情况下，在程序运行期为程序动态引入方法或字段的过程