微信公众号：路人zhang
扫码关注微信公众号

回复“面试手册”，获取本站PDF版

回复“简历”，获取高质量简历模板

回复“加群”，加入程序员交流群

回复“电子书”，获取程序员类电子书

当前位置： 计算机基础 > 设计模式 > 代理模式

代理模式

代理模式算是比较难点的设计模式，在面试中出现的频率也是比较高的，需要掌握，尤其是动态代理

代理模式主要是为了控制对象的访问，简单来说就是为对象找个代理，通过代理来访问对象。

举个生活中常见的例子，比如租房这件事，房东是目标对象，租房的人是客户，中介就是代理对象，那中介有什么用呢？中介也是承担了房东的一些职责。所以代理对象可以为对目标对象进行增强。

代理模式的优点：

  • 代理对象可以扩展目标对象的功能
  • 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用
  • 代理模式将客户端和目标对象分离，降低代码耦合度

代理模式根据代理类的创建时机可以分为静态代理和动态代理

  • 静态代理：在程序运行前代理类就已经存在了，一般是有程序员创建的
  • 动态代理：在程序运行时，通过反射机制生成代理类的字节码文件

代理模式角色主要有三种：

  • Subject（抽象主题角色）：定义代理类和真实主题的公共对外方法（接口）
  • RealSubject（真实主题角色）：真正实现业务逻辑的类
  • Proxy（代理主题角色）：用来代理和封装真实主题

静态代理

这次通过一个卖方的场景来介绍下静态代理

先写接口（Subject）

interface  ISellHouse{
    void sell();
}

再写目标对象（RealSubject），房东

class SellHouse implements ISellHouse {

    @Override
    public void sell() {
        System.out.println("卖房");
    }
}

再写代理类（Proxy），中介

class SellHouseProxy implements ISellHouse {
    private ISellHouse target; 
    public SellHouseProxy(ISellHouse target) {
        this.target = target;
    }
    @Override
    public void sell() {  //增强目标对象
        System.out.println("静态代理开始");
        target.sell();
        System.out.println("静态代理结束");
    }

}

从上面代码可以看到代理类扩展了目标对象的功能（记录了开始和结束）

这时集齐了代理模式的三种就角色，就可以写客户类进行测试了

class Client {
    public static void main(String[] args) {
        //创建目标对象
        SellHouse sellHouse = new SellHouse();

        //创建代理对象, 将目标对象传递给代理对象
        SellHouseProxy sellHouseProxy = new SellHouseProxy(sellHouse);

        //通过代理对象，调用目标对象的方法
        sellHouseProxy.sell();
    }
}

输出

静态代理开始
卖房
静态代理结束

这时如果中介想请你吃饭，就需要再接口中添加一个吃饭的方法，因为代理类和目标对象都是实现的接口，也就是都得改，增加重写方法，如下

interface  ISellHouse{
    void sell();
    void eat();
}

class SellHouse implements ISellHouse {

    @Override
    public void sell() {
        System.out.println("卖房");
    }

    @Override
    public void eat() {
        System.out.println("吃饭");
    }
}

class SellHouseProxy implements ISellHouse {
    private ISellHouse target;
    public SellHouseProxy(ISellHouse target) {
        this.target = target;
    }
    @Override
    public void sell() {  //增强目标对象
        System.out.println("静态代理开始");
        target.sell();
        System.out.println("静态代理结束");
    }

    @Override
    public void eat() {
        System.out.println("静态代理开始");
        target.eat();
        System.out.println("静态代理结束");
    }

}

class Client {
    public static void main(String[] args) {
        //创建目标对象
        SellHouse sellHouse = new SellHouse();

        //创建代理对象, 将目标对象传递给代理对象
        SellHouseProxy sellHouseProxy = new SellHouseProxy(sellHouse);

        //通过代理对象，调用目标对象的方法
        sellHouseProxy.sell();
        sellHouseProxy.eat();
    }
}

从上面代码可以看到，接口、代理类和目标类都需要改动

为了解决这个问题，可以采取动态代理的方式，在运行时生成代理类，而不是像上面这样写死

动态代理

Java动态代理的实现主要使用两个类，java.lang.reflect.InvocationHandler和java.lang.reflect.Proxy

生成代理对象是通过Proxy.newProxyInstance()方法，改方法需要三个参数

  • ClassLoader loader：目标对象的类加载器
  • Class<?>[] interfaces：被代理类 的所有实现接口的Class对象
  • InvocationHandler handler：调用处理器，主要用于目标对象的方法逻辑实现和扩展

Proxy.newProxyInstance()方法会返回一个实现了所有指定接口的代理子类对象，该对象将方法调用分派给指定的调用处理器。

下面再说java.lang.reflect.InvocationHandler，实现InvocationHandler接口的同时还需要重写接口InvocationHandler中的invoke方法，invoke方法是增强目标对象方法的关键

下面就通过java.lang.reflect.InvocationHandler和java.lang.reflect.Proxy两个类来实现动态代理

先写接口

interface ISellHouse {
    void sell();
}

再写目标对象

class SellHouse implements ISellHouse {
    @Override
    public void sell() {
        System.out.println("卖房");
    }
}

最后写代理类，也是最关键的地方

class ProxyFactory {
    //维护一个目标对象, Object
    private Object target;
    //构造器，对target进行初始化
    public ProxyFactory(Object target) {
        this.target = target;
    }
    //动态生成一个代理对象
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),  //调用newProxyInstance方法
                target.getClass().getInterfaces(),
                new InvocationHandler() { //匿名类重写invoke方法  
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 重写invoke方法
                        System.out.println("动态代理开始");
                        Object returnVal = method.invoke(target, args); //反射机制调用目标对象的方法
                        System.out.println("动态代理结束");
                        return returnVal;
                    }
                });
    }
}

写客户端测试

class Client {
    public static void main(String[] args) {
        //创建目标对象
        ISellHouse target = new SellHouse();

        //创建代理对象
        ISellHouse proxyInstance = (ISellHouse)new ProxyFactory(target).getProxyInstance();

        //通过代理对象，调用目标对象的方法
        proxyInstance.sell();
    }
}

输出结果

动态代理开始
卖房
动态代理结束

达到了和静态代理一样的效果，如果这时中介请吃饭呢，因为和静态代理不同，代理类是动态生成的，所以只需要改接口和目标对象就行了，不需要改代理类，因为代理类没有实现接口，如下

interface ISellHouse {
    void sell();
    void eat();
}

class SellHouse implements ISellHouse {
    @Override
    public void sell() {
        System.out.println("卖房");
    }

    @Override
    public void eat() {
        System.out.println("吃饭");
    }
}

class ProxyFactory {
    //维护一个目标对象 , Object
    private Object target;
    //构造器 ， 对target 进行初始化
    public ProxyFactory(Object target) {
        this.target = target;
    }
    //动态生成一个代理对象
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() { //匿名类重写invoke方法
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("动态代理开始");
                        Object returnVal = method.invoke(target, args);//反射机制调用目标对象的方法
                        System.out.println("动态代理结束");
                        return returnVal;
                    }
                });
    }
}

class Client {
    public static void main(String[] args) {
        //创建目标对象
        ISellHouse target = new SellHouse();

        //创建代理对象
        ISellHouse proxyInstance = (ISellHouse)new ProxyFactory(target).getProxyInstance();

        //内存中动态生成了代理对象
        System.out.println(proxyInstance.getClass());

        //通过代理对象，调用目标对象的方法
        proxyInstance.sell();
        proxyInstance.eat();
    }
}

从上面代码看起来好像费半天事，只是少改了代理类，还把代码搞复杂了很多，其实如果像这种简单业务场景，就增加一个方法，确实是静态代理更好些，但当代理类非常的多时，接口中需要增删的方法非常多时，动态代理的优势还是非常明显的。

上面的动态代理也就JDK动态代理，还有一种代理叫CGLIB动态代理，CGLIB动态代理和JDK动态代理的区别是JDK动态代理的目标对象需要实现接口，而CGLIB动态代理的目标对象不需要实现接口，但目标对象不能是final修饰的

CGLIB是一个高性能的代码生成包，它是在内存中构建一个子类对象从而实现对目标对象功能扩展，其原理是基于ASM机制实现，通过生成业务类的子类作为代理类，如果业务类（被代理的类）用final修饰，那就不能生成子类了，这也是被代理类（目标对象）不能用final修饰的原因

实现CGLIB动态代理的关键是实现MethodInterceptor接口和重写intercept方法

下面通过代码来实现下CGLIB动态代理

class SellHouse {
    public void sell() {
        System.out.println("卖房");
    }
}

class ProxyFactory implements MethodInterceptor {
    //目标对象
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }
    //返回target对象的代理对象
    public Object getProxyInstance() {
        //创建一个工具类
        Enhancer enhancer = new Enhancer();

        //设置父类
        enhancer.setSuperclass(target.getClass());

        //设置回调函数
        enhancer.setCallback(this);

        //创建子类对象，即代理对象
        return enhancer.create();
    }

    //重写intercept方法，会调用目标对象的方法
    @Override
    public Object intercept(Object arg0, Method method, Object[] args, MethodProxy arg3) throws Throwable {
        System.out.println("动态代理开始");
        Object returnVal = method.invoke(target, args);
        System.out.println("动态代理结束");
        return returnVal;
    }

}

class Client {
    public static void main(String[] args) {
        //创建目标对象
        SellHouse target = new SellHouse();

        //获取到代理对象，并且将目标对象传递给代理对象
        SellHouse proxyInstance = (SellHouse)new ProxyFactory(target).getProxyInstance();

        //执行代理对象的方法，触发intercept方法，从而实现对目标对象的调用
        proxyInstance.sell();
    }
}

输出

动态代理开始
卖房
动态代理结束

三种代理模式特点

最后简单总结下静态代理、JDK动态代理和CGLIB动态代理的特点：

静态代理：代理对象和目标对象都继承了同一个接口，

优点：就是开头介绍代理模式的优点，扩展目标对象的功能、保护目标对象、降低代码耦合度

缺点：不同的接口要有不同的代理类实现，代码会变得很冗余

JDK动态代理：实现 InvocationHandler 接口，重写 invoke 方法，然后反射生成代理类代理类字节码，并生成对象

优点：在静态代理的优点基础上，解决了静态代理的缺点

缺点：相比静态代理实现较为复杂，并且被代理的类必须实现接口，不实现接口不能使用JDK动态代理

CGLIB动态代理：通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑，来完成动态代理的实现。具体实现方式是实现 MethodInterceptor 接口，重写 intercept 方法，最后通过 Enhancer 类的回调方法来实现

优点：解决JDK动态代理存在的问题，无需接口也可以实现动态代理；采用字节码增强技术，性能较好

缺点：被代理的类不能被final修饰；技术实现上较为复杂

本站链接：https://www.mianshi.online，如需勘误或投稿，请联系微信：lurenzhang888

点击面试手册，获取本站面试手册PDF完整版

设计模式