代理模式

设想你的项目依赖第三方，但是你需要对其接口做一些数据检验、性能数据记录、异常处理等，合适的方法就是使用设计模式里的代理模式。

代理模式是常用的java设计模式，代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。

在java里可以有静态代理和动态代理.

静态代理

按照代理模式标准实现方法:

public interface API {        public void method();    }    public static class APIImpl implements API {        @Override        public void method() {            System.out.println("do work...");        }    }    public static class ProxyAPI implements API {        API api;        public ProxyAPI(API api){            this.api = api;        }        @Override        public void method() {            System.out.println("proxy start");            this.api.method();            System.out.println("proxy end");        }    }

静态代理的特点是代理类自己实现API接口，但是每一个方法调用的却是传入的api对象里的。如果接口方法较多，或者有多个接口需要代理，静态代理工作量会比较大，差评。

动态代理

既然静态代理存在使用麻烦，有更好的解决方案吗？那就是JDK提供的基于反射机制的动态代理。

Proxy类：

Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：

public static Object newProxyInstance(ClassLoader loader, Class
    [] interfaces,InvocationHandler h) throws IllegalArgumentException

参数说明：

• ClassLoader loader：类加载器
• Class<?>[] interfaces：接口
• InvocationHandler h：得到InvocationHandler接口的子类实例

实现

public static class APIProxy {        public static 
    
      T proxy(final T target) {            return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),                    target.getClass().getInterfaces(), new InvocationHandler() {                        @Override                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                            Object result = null;                            System.out.println("proxy start");                            //执行方法                            result = method.invoke(target, args);                            System.out.println("proxy end");                            return result;                        }                    });        }
    

或许你注意到了，JDK的动态代理依靠接口实现

但是有些类并没有实现接口，据不能使用JDK代理了，这是时候该cglib上场了。

cglib动态代理

JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

实现方法：

public static class CglibProxy implements MethodInterceptor {        private Object target;        static CglibProxy _instance = new CglibProxy();        /**         * 创建代理对象         *         * @param target         * @return         */        public static  
    
      T proxy(final T target) {            Enhancer enhancer = new Enhancer();            enhancer.setSuperclass(target.getClass());            // 回调方法            enhancer.setCallback(_instance);            // 创建代理对象            return (T) enhancer.create();        }        @Override        public Object intercept(Object obj, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {            System.out.println("proxy start");            Object result = methodProxy.invokeSuper(obj, objects);            System.out.println("proxy end");            return result;        }    }
    

cglib的原理，可以参见

测试

public static void main(String[] args) {        API api = new APIImpl();        // 静态代理        API proxyApi = new ProxyAPI(api);        proxyApi.method();        // jdk proxy        API proxyApi2 = APIProxy.proxy(api);        proxyApi2.method();        // cglib        API proxyApi3 = CglibProxy.proxy(api);        proxyApi3.method();    }