动态代理与静态代理

什么是代理模式

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