设计模式：动态代理与静态代理

妖狐艹你老母 2022-05-24 04:15 249阅读 0赞

# 动态代理与静态代理 #

## 什么是代理模式 ##

代理模式即一个类（代理类）具有另一个类（被代理类）的所有行为。代理类可以在不更改业务逻辑的情况下扩展被代理类的方法，达到让被代理类更加专注的去处理本身所具有的业务逻辑。  
代理模式包括动态代理和静态代理。  
静态代理是指在程序运行之前已经存在的代理类及代理实现，即开发者需要在程序运行之前就写好代理类及代理实现。动态代理是指程序运行之后，根据业务逻辑需求，动态的获取、创建被代理类的功能。可以采用JDK、CGLIB来实现动态代理。

## 静态代理编码实现 ##

创建被代理类接口

package cn.tyrone.java.designpattern.staticproxy;
    
    /** * 电脑厂商接口 * @author shanglishuai * */
    public interface IPCBrand { 
    
        /** * 生产电脑 * @param pcModel 电脑型号 */
        public void makePC(String pcModel);
    
        /** * 出售电脑 * @param pcModel 电脑型号 */
        public void sellPC(String pcModel);
    }

创建被代理类

package cn.tyrone.java.designpattern.staticproxy;
    
    /** * 联想电脑厂商 * @author shanglishuai * */
    public class LenevoPCBrand implements IPCBrand { 
    
    
        @Override
        public void makePC(String pcModel) {
            System.out.println("新研发的的电脑型号:" + pcModel);
        }
    
        @Override
        public void sellPC(String pcModel) {
            System.out.println("出售最新的电脑型号：" + pcModel);
        }
    
    }

创建代理类

package cn.tyrone.java.designpattern.staticproxy;
    
    /** * 联想电脑厂商代理商 * @author shanglishuai * */
    public class LenevoPCBrandProxy implements IPCBrand { 
    
        // 
        private IPCBrand pcBrand;
    
        public LenevoPCBrandProxy(IPCBrand pcBrand) {
            this.pcBrand = pcBrand;
        }
    
        /** * 代理联想电脑厂商生产电脑 */
        @Override
        public void makePC(String pcModel) {
            System.out.println("我是联想电脑厂商的代理商");
            pcBrand.makePC(pcModel);
        }
    
        /** * 代理联想电脑厂商出售电脑 */
        @Override
        public void sellPC(String pcModel) {
            System.out.println("我是联想电脑厂商的代理商");
            pcBrand.sellPC(pcModel);
        }
    
    }

测试类

package cn.tyrone.java.designpattern.staticproxy;
    
    /** * 静态代理测试 * * @author shanglishuai * */
    public class StaticProxyTest { 
    
        public static void main(String[] args) {
            IPCBrand lenevoPCBrand = new LenevoPCBrand();
    
            IPCBrand lenevoPCBrandProxy = new LenevoPCBrandProxy(lenevoPCBrand);
    
            String pcModel = "G470-New";
    
            lenevoPCBrand.makePC(pcModel);
            lenevoPCBrand.makePC(pcModel);
            System.out.println("\n");
            lenevoPCBrandProxy.makePC(pcModel);
            lenevoPCBrandProxy.makePC(pcModel);
    
        }
    
    }

## JDK方式实现动态代理 ##

创建被代理类接口

package cn.tyrone.java.designpattern.dynamicproxy.jdk;
    
    /** * 电脑厂商接口 * @author shanglishuai * */
    public interface IPCBrand { 
    
        /** * 生产电脑 * @param pcModel 电脑型号 */
        public void makePC(String pcModel);
    
        /** * 出售电脑 * @param pcModel 电脑型号 */
        public void sellPC(String pcModel);
    }

创建被代理类

package cn.tyrone.java.designpattern.dynamicproxy.jdk;
    
    /** * 联想电脑厂商 * @author shanglishuai * */
    public class LenevoPCBrand implements IPCBrand { 
    
    
        @Override
        public void makePC(String pcModel) {
            System.out.println("新研发的的电脑型号:" + pcModel);
        }
    
        @Override
        public void sellPC(String pcModel) {
            System.out.println("出售最新的电脑型号：" + pcModel);
        }
    
    }

创建JDK动态代理类  
JDK动态代理需要实现InvocationHandler接口来实现

package cn.tyrone.java.designpattern.dynamicproxy.jdk;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /** * 使用jdk实现动态代理方法 * @author shanglishuai * */
    public class JDKProxy implements InvocationHandler { 
    
        // 真实对象
        private Object target = null;
    
        /** * 建立代理对象与真实对象的代理关系，并返回代理对象 * @param target 真实对象 * @return 代理对象 */
        public Object bind(Object target) {
            this.target = target;
            return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
                    target.getClass().getInterfaces(), this);
        }
    
        /** * 代理方法逻辑 * @param proxy 代理对象 * @param method 当前调度方法 * @param args 当前方法参数 * @return 代理结果返回 * @throws Throwable 异常 */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("调用真实对象的业务方法之前的业务逻辑");
            Object obj = method.invoke(target, args); // 调用真实对象的业务处理方法
            System.out.println("调用真实对象的业务方法之后的业务逻辑");
            System.out.println("\n");
            return obj;
        }
    
    }

JDK动态代理测试类

package cn.tyrone.java.designpattern.dynamicproxy.jdk;
    
    public class JDKProxyTest {
        public static void main(String[] args) {
            IPCBrand pcBrand = new LenevoPCBrand();
    
            JDKProxy jdkProxy = new JDKProxy();
            // 绑定真实对象
            IPCBrand pcBrandProxy = (IPCBrand)jdkProxy.bind(pcBrand);
    
            String pcModel = "G470-New";
            pcBrandProxy.makePC(pcModel);
            pcBrandProxy.sellPC(pcModel);
        }
    }

## 采用CGLIB实现动态代理 ##

创建被代理类

package cn.tyrone.java.designpattern.dynamicproxy.cglib;
    
    /** * 联想电脑厂商 * @author shanglishuai * */
    public class LenevoPCBrand { 
    
        public void makePC(String pcModel) {
            System.out.println("新研发的的电脑型号:" + pcModel);
        }
    
        public void sellPC(String pcModel) {
            System.out.println("出售最新的电脑型号：" + pcModel);
        }
    
    }

创建CGLIB动态代理类

package cn.tyrone.java.designpattern.dynamicproxy.cglib;
    
    import java.lang.reflect.Method;
    
    import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    
    /** * Cglib实现动态代理 * 使用Cglib实现动态代理需要实现MethodInterceptor接口 * @author shanglishuai * */
    public class CglibProxy implements MethodInterceptor { 
    
        /** * 生成Cglib代理对象 * @param cls 代理类 * @return 代理类的代理对象 */
        public Object getProxy(Class cls) {
    
            // Cglib enhancer 增加类对象
            Enhancer enhancer = new Enhancer();
            // 设置增强类型
            enhancer.setSuperclass(cls);
            // 定义代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor接口
            enhancer.setCallback(this);
            // 创建并返回代理对象
            return enhancer.create();
        }
    
        /** * @param proxy 代理对象 * @param method 方法 * @param args 方法参数 * @param methodProxy 方法代理 * @return result 代理逻辑返回 * @throws Throwable 异常 */
        @Override
        public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            System.out.println("执行真实对象方法之前可以添加的业务逻辑");
            Object result = methodProxy.invokeSuper(proxy, args);
            System.out.println("执行真实对象方法之后可以添加的业务逻辑\n");
            return result;
        }
    
    }

创建CGLIB动态代理测试类

package cn.tyrone.java.designpattern.dynamicproxy.cglib;
    
    public class CglibProxyTest {
        public static void main(String[] args) {
            CglibProxy cglibProxy = new CglibProxy();
            LenevoPCBrand lenevoPCBrandProxy = (LenevoPCBrand)cglibProxy.getProxy(LenevoPCBrand.class);
    
            String pcModel = "G470-New";
    
            lenevoPCBrandProxy.makePC(pcModel);
            lenevoPCBrandProxy.sellPC(pcModel);
        }
    }