认识设计模式（三）---代理模式（Spring AOP）

代理模式简单介绍

（1）什么是代理模式？
给一个对象提供一个替身，通过这个替身来访问这个对象
（2）使用代理对象的好处是什么？
不仅仅可以实现目标对象，还能通过代理对象扩展目标对象的功能
（3）被代理对象的种类
远程对象
光剑开销大的对象
需要安全控制的对象
（4）代理模式的不同形式
主要有三种：静态代理、动态代理(JDK代理、接口代理)、Cglib代理(可以在内存里动态的创建对象，而且不需要实现接口，属于动态代理)

静态代理

基本介绍

需要定义接口或者父类，目标对象和代理对象一起实现相同的接口，或者是继承相同的父类。

思路分析

1. 定义一个接口，给目标对象和代理对象一起实现
2. 创建目标对象实现接口
3. 创建代理对象实现接口
4. 使用的时候通过调用代理对象的方法来调用目标对象

代码示例

（1）接口ITeacherDao
提供一个方法teach

public interface ITeacherDao {
    void teach();
}

（2）目标对象类
实现接口，并且完成方法的实现

public class TeacherDao implements ITeacherDao {
    @Override
    public void teach() {
        System.out.println("老师授课中...");
    }
}

（3）代理对象类
1-实现接口
2-创建私有对象，在构造器里完成对象实例化
3-实现接口的方法，方法的实现不是自己写的，而是用过接口的对象去调用目标对象的方法

注意，这里的ITeacherDao target接口对象只是一个例子，其实它代表着所有接口的实现类对象都可以作为参数传进去

public class TeacherDaoProxy implements ITeacherDao {

    //要代理的目标对象，通过接口来聚合
    private ITeacherDao target;

    //构造器
    public TeacherDaoProxy(ITeacherDao target) {
        this.target = target;
    }

    @Override
    public void teach() {
        //1-额外的，共通的代码写在代理类里
        System.out.println("开始代理...");
        //2-特有的代码写在被代理对象里
        target.teach();
        //3-额外的，共通的代码写在代理类里
        System.out.println("结束提交...");

    }
}

（4）测试类
1-创建目标对象
2-创建代理对象
3-把目标对象放进代理对象的构造器，这样代理对象就能调用目标对象的方法了

public class Client {
    public static void main(String[] args) {
        //创建对象，被代理的对象
        TeacherDao teacherDao=new TeacherDao();
        //创建对象，代理对象
        TeacherDaoProxy teacherDaoProxy=new TeacherDaoProxy(teacherDao);
        teacherDaoProxy.teach();
    }
}

UML图

静态代理的优缺点

• 优点：通过代理对象调用目标对象，还可以对目标对象进行功能扩展，整个过程不需要改动目标对象的代码
• 缺点一：因为代理对象要和目标对象实现相同的接口，如果任务量大的时候就会有很多代理类。
• 缺点二：代理对象通过相同的方法去调用目标对象，一旦接口增加了一个方法，目标对象和代理对象都要改动，去实现新的方法

动态代理

基本介绍

1. 代理对象不需要实现接口，但是目标对象需要实现接口
2. 代理对象的生成，是利用JDK的API，动态的在内存中创建代理对象。因此动态代理也叫做JDK代理、接口代理

思路分析

使用JDK的代理类Proxy，只需要使用newProxyInstance方法，接收三个参数即可。

源码是：

public static Object newProxyInstance(ClassLoader var0, Class<?>[] var1, InvocationHandler var2) {
        Objects.requireNonNull(var2);
        Class var3 = System.getSecurityManager() == null ? null : Reflection.getCallerClass();
        Constructor var4 = getProxyConstructor(var3, var0, var1);
        return newProxyInstance(var3, var4, var2);
    }

1. ClassLoader loader：指定当前目标对象使用的类加载器，获取加载器的方法固定
2. Class<?>[] interfaces：目标对象实现的接口类型，使用泛型方法确认类型
3. InvocationHandler handler：事件处理，执行目标对象的方法时，会触发事情处理器方法

代码示例

（1）接口（只给目标对象实现，代理对象使用JDK的，因此不需要实现接口）

public interface ITeacherDao {
    void teach();
    void sayHello(String name);
}

（2）目标对象类

public class TeacherDao implements ITeacherDao {
    @Override
    public void teach() {
        System.out.println("老师授课中...");
    }

    @Override
    public void sayHello(String name) {
        System.out.println("hello"+name);
    }
}

（3）代理工厂类

1. 1-创建私有对象，注意这个对象不再是接口的对象，而是Object类型，也就是说可以传进来任意类型的对象
2. 在构造器里完成对象实例化，把传进来的对象实例化给已经创建好的对象
3. 开始创建代理
   target.getClass().getClassLoader()====目标对象类加载，获取目标对象的类（TeacherDao类）
   target.getClass().getInterfaces()====获取目标对象实现的接口（ITeacherDao接口）
   new InvocationHandler()====在这里对目标对象的方法进行调用和扩展

public class ProxyFactory {
    //维护一个目标对象，Object
    private Object target;

    //构造器，对target进行初始化
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //给目标对象生成一个代理对象
    public Object getProxyInstance(){
        //ClassLoader loader：指定当前目标对象使用的类加载器，获取加载器的方法固定
        //Class<?>[] interfaces：目标对象实现的接口类型，使用泛型方法确认类型
        //InvocationHandler handler：事件处理，执行目标对象的方法时，会触发事情处理器方法
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                        System.out.println("JDK代理开始...");
                        //反射机制调用目标对象的方法
                        Object returnVal=method.invoke(target,objects);
                        System.out.println("JDK代理提交...");

                        return returnVal;
                    }
                });
    }
}

（4）测试类

1. 创建目标对象（被代理的对象）
2. 创建代理对象ProxyFactory，把目标对象传进构造器，并且调用getProxyInstance方法，最后类型转换成ITeacherDao

public class Client {
    public static void main(String[] args) {
        //创建目标对象
        ITeacherDao target= new TeacherDao();
        //给目标对象，创建代理对象
        ITeacherDao proxyInstance= (ITeacherDao) new ProxyFactory(target).getProxyInstance();

        //proxyInstance=class com.sun.proxy.$Proxy0 是内存中动态生成了代理对象
        System.out.println("proxyInstance="+proxyInstance.getClass());

        //通过代理对象，调用目标对象的方法
        proxyInstance.teach();
        proxyInstance.sayHello("老王");
    }
}

UML图

优点分析

当需要新增方法的时候，只需要在目标对象里加方法就行了，代理对象里通过反射获取目标对象里的方法。

Cglib代理

基本介绍

1. 静态代理和JDK地阿里模式都要求目标对象实现一个接口，但是有时候目标对象知识一个单独的对象，并没有实现任何的接口，这个时候可使用目标对象子类来实现代理，这就是Cglib代理
2. 如上，Cglib代理也叫作子类代理
3. Cglib是一个强大的高性能的代码生成包，可以在运行期间扩展java类与实现java接口，常见的应用在AOP的框架中，如Spring AOP，实现方法拦截
4. 在AOP中选择代理模式：1-目标对象需要实现接口，就用JDK代理。2-目标对象不需要实现接口，就用Cglib代理
5. Cglib包的底层是通过使用字节码处理框架ASM来转换字节码并生成新的类

思路分析

需要引入jar文件
…有机会用maven来实现以下

Spring AOP源码分析