13.Proxy——代理模式

代理模式：在不改变类的同时扩展类，在代理类中调用被代理者的方法，增加代理自己的方法，将代理类提供给外界调用，达到扩展的效果

 

demo描述：老师有讲课的方法，在让老师讲课之前、进行时或之后要对老师的功能进行扩展，不能改老师类，可以通过加一层代理，让代理去代替老师扩展。

 

demo代码：

一、静态代理：

老师接口、老师，接口中放要被代理的方法：

public interface ITeacherDao {
    void teach();
}

//----------------------------------------------

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

代理，通过聚合接口让其能调用被代理的方法，从而方法之前、期间、之后扩展：

public class TeacherDaoProxy  implements ITeacherDao{
    //目标对象
    private ITeacherDao target;

    public TeacherDaoProxy(ITeacherDao target) {
        this.target = target;
    }

    //代理对象执行目标对象的方法，通过共同的接口来规范代理
    @Override
    public void teach() {
        System.out.println("代理开始：上课前备课");
        target.teach();
        System.out.println("代理结束：下课后留作业");
    }
}

客户端：

public class Client1 {
    public static void main(String[] args) {
        //被代理对象
        TeacherDao teacherDao = new TeacherDao();

        //代理对象，同时将被代理对象传递给代理对象
        TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDao);

        teacherDaoProxy.teach();
    }
}

demo类图：

类图分析：被代理类将被代理的方法抽象到接口中，代理类与被代理类实现共同的接口，从而让代理类可以调用方法，进行扩展；当被代理的方法增加后接口和代理类都要维护。1处可扩展，当需要不同的代理方式时可增加代理类达到不同的代理效果，但这种扩展多了后会使代理类庞大，难以维护，不如开始时就把被代理类设计好了，减少这种恶性扩展；可以让代理类动态生成，需要什么样的代理就生成什么样的代理，这样就能解决代理类庞大而难以维护的问题——动态代理：

 

二、JDK代理(接口代理)：

老师接口、老师：

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

//--------------------------------

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

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

代理，这里代理不在聚合老师接口，而是聚合一个不确定类型的类，这样代理类就不只是能代理老师了，还能代理其他类；通过工厂达到代理对象动态的效果，解决了代理类写死的后患，注意看注释：

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

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

    //***给目标对象生成一个代理对象(这样代理对象就根据不是固定类型的了，而是根据实际生成的类型)
    //代理对象执行的是目标对象的方法-拿到目标对象的接口与目标对象的类型(取代原来的代理对象实现接口)
    // *得到* 代理，并执行目标的方法
    public Object getProxyInstance() {
        // params:
        // 指定当前对象使用的类加载器，获取加载器的方法固定
        // ***目标对象实现的接口类型使用泛型方法确认
        // 事件处理，执行目标对象的方法时会触发事件处理器的方法，会把当前执行的目标对象方法作为参数传入
        //得到代理
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method,
                                         Object[] args) throws Throwable {
                        System.out.println("JDK代理开始");
                        //反射机制得到目标，调用目标对象的方法
                        Object invoke = method.invoke(target, args);
                        System.out.println("JDK代理提交");
                        return invoke;
                    }
                });
    }
}

客户端：

public class Client2 {
    public static void main(String[] args) {
        //创建目标对象
        TeacherDao 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("tom");
    }
}

demo类图：

类图分析：这个代理果然很JDK，充分利用了JDK的API(newProxyInstance(java.lang.reflect.Proxy))动态在内存中构建代理对象。代理类不用再实现被代理方法的接口了，类固定了，反过来来看，被代理类就写活了，实现接口的类都可以被代理。

 

三、Cglib代理(子类代理)：

老师：

public class TeacherDao {
    public void teach() {
        System.out.println("老师授课中。。。cglib代理不用实现接口");
    }
}

代理：

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

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

    //给目标对象生成一个代理对象
    public Object getProxyInstance() {
        //创建一个工具类
        Enhancer enhancer = new Enhancer();
        // ***设置父类，根据传入的目标生成——动态
        enhancer.setSuperclass(target.getClass());
        // 设置回调函数
        enhancer.setCallback(this);
        // 创建子类对象
        return enhancer.create();
    }

    //重写拦截方法
    //会调用目标对象的方法
    @Override
    public Object intercept(Object o, Method method, Object[] args,
                            MethodProxy methodProxy) throws Throwable {
        System.out.println("Cglib代理模式~~开始");
        Object invoke = method.invoke(target, args);
        System.out.println("Cjlib代理模式~~提交");
        return invoke;
    }
}

客户端：

public class Client3 {
    //相当于通过被代理对象创建一个和被代理对象同样的对象，用这个对象去做方法的扩展
    public static void main(String[] args) {
        //创建目标对象
        TeacherDao teacherDao = new TeacherDao();
        //用目标对象获取代理对象，目标对象起一个类型约束的作用
        //并将目标对象传递给代理对象，绕过目标类生成一个目标对象，对此目标对象进行扩展
        TeacherDao proxyInstance =
                (TeacherDao) new ProxyFactory(teacherDao).getProxyInstance();
        //执行代理对象的方法，触发intecept方法，从而实现对目标对象的调用
        proxyInstance.teach();
    }
}

demo类图：

类图分析：Cglib代理让被代理类摆脱了要抽象出接口的限制，代理的范围大了；被代理类不能为final，被代理的方法为final或static时不会被拦截，不会执行被代理对象额外的业务，会让代理失效。代理类要实现JDK的接口，在内存中构建一个目标对象(绕过了new创建对象的方式)从而实现对被代理对象的功能的扩展。这种思想在我们玩Linux时经常用：安装mysql、redis等后，都是复制一份配置文件，改复制后的配置文件用，留着自带的配置文件做恢复，这里复制文件就相当于原件的代理，对原件做了扩展。

 

适用场景：类不能改但又需要扩展时可用代理；被代理类实现接口时用JDK代理，被代理类不实现接口时用Cglib代理

 

总结：代理模式从加一层、让代理类动态生成、“复制”被代理类，用复制的对象三个方向实现扩展被代理对象方法的效果，Spring中用代理实现AOP，在我们写代码的时候还是先做好设计吧，避免一些不必要的代理。