设计模式——代理模式（Proxy Pattern）

╰+哭是因爲堅強的太久メ 2022-11-12 01:45 130阅读 0赞

代理模式是指为其他对象对象提供一个代理，控制对这个对象的访问，保护目标对象。代理对象在目标对象和客户端之间起中介作用。属于结构型设计模式。

生活中的代理模式：房产中介、快递小哥、黄牛党。

**适应场景：**当需要保护目标对象，增强目标对象功能时需要用到代理模式。

**代理模式的优点：**

*  代理模式能将代理对象与真实被调用目标对象分离
 *  一定程度上降低了系统的耦合程度，易于扩展
 *  代理可以起到保护目标对象，增强目标对象职责的作用

**代理模式的缺点：**

*  代理会造成系统中类的数量增加
 *  在客户端和目标对象之间增加了一个代理对象，请求处理速度变慢
 *  增加了系统的复杂度

**Spring中应用代理的原则：**

*  当Bean有实现接口时，Spring就会用JDK的动态代理
 *  当Bean没有实现接口时，Spring就会使用CGLib代理
 *  Spring可以通过配置强制使用CGLib，只需要在Spring的配置文件中加入以下代码  
    <aop:aspectj-autoproxy proxy-target-class="true"/>

**静态代理与动态代理的区别：**

*  使用静态代理，如果被代理类增加了新的方法，代理类需要同步增加，违背了开闭原则
 *  动态代理采用在运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开闭原则
 *  若动态代理需要对目标类的增强逻辑进行扩展，无须修改代理类的代码

# 静态代理 #

静态代理，每个被代理的对象都需要一个对应的代理类。如下面例子，张三父亲就是替张三找对象的代理，李四父亲就是替李四找对象的代理，如果王五需要找对象，那么也需要一个人作为他的代理，这样代理类很多。所以需要一个专门做这种事情的人或者行业来代理大家找对象，比如媒婆、红娘、婚恋网之类的代理。所以动态代理因此引入。

public interface IPerson {
        void findLove();
    }
    public class ZhangSan implements IPerson {
        @Override
        public void findLove() {
            System.out.println("张三找对象：胸大腰细屁股翘");
        }
    }
    // 张三的父亲就是替张三找对象的代理
    public class ZhangSanFather implements IPerson {
        private ZhangSan zhangSan;
        public ZhangSanFather(ZhangSan zhangSan) {
            this.zhangSan = zhangSan;
        }
        @Override
        public void findLove() {
            System.out.println("张三父亲到处打听物色儿媳妇");
            zhangSan.findLove();
            System.out.println("感觉可以，开始交往");
        }
    }
    public class LiSi implements IPerson {
        @Override
        public void findLove() {
            System.out.println("李四找对象：肤白貌美大长腿");
        }
    }
    // 李四的父亲就是替李四找对象的代理
    public class LiSiFather implements IPerson {
        private LiSi liSi;
        public LiSiFather(LiSi liSi) {
            this.liSi = liSi;
        }
        @Override
        public void findLove() {
            System.out.println("李四父亲到处打听无色儿媳妇");
            liSi.findLove();
            System.out.println("感觉不错开始交往");
        }
    }
    public class Test {
        public static void main(String[] args) {
            ZhangSanFather zhangSanFather = new ZhangSanFather(new ZhangSan());
            zhangSanFather.findLove();
            LiSiFather liSiFather = new LiSiFather(new LiSi());
            liSiFather.findLove();
        }
    }

# 动态代理 #

目前现成的动态代理有JDK提供的还有Cglib提供的动态代理组件。

## JDK Proxy ##

public interface IPerson {
        void findLove();
    }
    public class ZhangSan implements IPerson {
        @Override
        public void findLove() {System.out.println("张三找对象：胸大腰细屁股翘");}
    }
    public class LiSi implements IPerson {
        @Override
        public void findLove() {System.out.println("李四找对象：肤白貌美大长腿");    }
    }
    
    public class JdkProxy implements InvocationHandler {
        private IPerson person;
        public IPerson getInstance(IPerson person) {
            this.person = person;
            Class<?> clazz = person.getClass();
            return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
        }
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            before();
            Object object = method.invoke(this.person, args);
            after();
            return object;
        }
        private void after() { System.out.println("after"); }
        private void before() { System.out.println("before"); }
    }
    public class Test {
        public static void main(String[] args) {
            JdkProxy jdkProxy = new JdkProxy();
            IPerson zhangsan = jdkProxy.getInstance(new ZhangSan());
            zhangsan.findLove();
            IPerson lisi = jdkProxy.getInstance(new LiSi());
            lisi.findLove();
        }
    }

## Cglib Proxy ##

public interface IPerson {
        void findLove();
    }
    public class ZhangSan implements IPerson {
        @Override
        public void findLove() {System.out.println("张三找对象：胸大腰细屁股翘");}
    }
    public class LiSi implements IPerson {
        @Override
        public void findLove() {System.out.println("李四找对象：肤白貌美大长腿");}
    }
    
    public class CglibProxy implements MethodInterceptor {
        public Object getInstance(Class<?> clazz) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(clazz);
            enhancer.setCallback(this);
            return enhancer.create();
        }
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            before();
            Object object = methodProxy.invokeSuper(o, objects);
            after();
            return object;
        }
        private void after() { }
        private void before() { }
    }
    public class Test {
        public static void main(String[] args) {
            ZhangSan zhangSan = (ZhangSan) new CglibProxy().getInstance(ZhangSan.class);
            zhangSan.findLove();
        }
    }

**JDK proxy和Cglib proxy的区别：**

*  JDK采用实现的方式，读取接口的信息，必须要求代理目标实现一个接口  
    Cglib采用继承的方式，覆盖父类方法
 *  思想都是通过生成字节码，生成一个新类，去实现增强代码逻辑的功能
 *  JDK proxy对于用户而言，依赖性更强，必须要有一个接口实现，调用相对复杂  
    Cglib对目标类没有任何要求，但是不能代理final修饰的方法
 *  Cglib生成代理逻辑复杂，但是调用效率高，性能也高，底层没有用到反射  
    JDK proxy生成代理逻辑简单，执行效率较低，每次都要反射动态调用