静态代理与动态代理

r囧r小猫 2022-09-24 04:29 227阅读 0赞

代理，就是代替原来的角色去做事，下面这张图对代理的解释很生动形象：

![这里写图片描述][20160727112123672]

静态代理

--------------------

23种设计模式中，代理模式是一种很经典的模式，当我们想改变一个类的行为的时候（比如添加额外的服务像添加日志等），可以创造一个跟这个类实现相同接口的类，重写对应的方法。这就相当于为一个类创建了一个“替身”。

代理模式的结构如下：

![这里写图片描述][20160726212059459]

比如要给原来的业务逻辑添加日志功能，则可以添加代理类，重写需要添加日志的业务类。

用户管理接口

public interface UserManager {
        public void addUser(User user);
    }

用户管理实现类

public class UserManagerImpl implements UserManager { 
        @Override
        public void addUser(User user) {
            System.out.println("---------addUser()---------");
        }
    }

用户管理代理类

public class UserManagerProxyImpl implements UserManager{ 
        private UserManager userManager;
        public UserManagerProxyImpl(UserManager userManager){
            this.userManager=userManager;
        }
        @Override
        public void addUser(User user) {
    
            userManager.addUser(user);
            //添加额外服务-日志功能
            logger.info("添加用户:"+user.getUserName());
        }
    }

此时调用这个新的方法，不会改变系统原来的稳定性。

动态代理

--------------------

上面的静态代理，每个代理类只能为一个业务类服务，如果放在实际应用中，肯定需要使用多个代理，同时会带来大量的重复代码。动态代理可以为任何类动态生成一个代理类来实现全部的代理功能。

静态代理由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。  
在程序运行时，运用反射机制动态创建而成。

JDK和Cglib都实现了动态代理，但略有差异，下面分别说明。

JDK动态代理

动态代理类克服了上面静态代理类需要继承唯一接口，并且要实现相应的方法的缺陷。他可以为任何类创建代理类并且在运行时动态创建代理对象。

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class LogHandler implements InvocationHandler{ 
        //被代理的目标类
        private Object targetObject;
        //创建代理
        public Object createProxyInstance(Object targetObject){
            this.targetObject=targetObject;
            return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),targetObject.getClass().getInterfaces(),this);
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            //代理服务方法
            insertLog(method,args);
            //调用目标方法（原业务逻辑）
            Object ret=method.invoke(targetObject, args);
            return ret;
        }
    
        private void insertLog(Method method,Object[] args){
            System.out.println("logInfo：【methodName:"+method.getName()+";args:"+args+"】");
        }
    }

实现动态代理，利用`Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)`方法获得代理类，`loader`就是被代理类的类加载器，`interfaces` 是被代理类实现的接口，它实现了几个接口，就会为其生成几个相应的代理类。此外必须要实现`InvocationHandler`接口，重写其`invoke`方法，用`java.lang.reflect.Method.invoke()`方法调用目标方法（可以在调用之前或者之后添加代理服务方法）。

客户端调用如下：

public class Client {
        public static void main(String[] args) {
            LogHandler logHandler=new LogHandler();
            UserManager userManager=(UserManager)logHandler.createProxyInstance(new UserManagerImpl());
            userManager.addUser(new User("Danny","123456"));
    
            OrderManager orderManager=(OrderManager)logHandler.createProxyInstance(new OrderManagerImpl());
            orderManager.addOrder(new Order("Danny","B20160726085911223004"));
        }
    }

如上，调用动态代理的时候，new一个动态代理的实例，通过动态代理来创建原业务类的代理类，然后直接调用接口就行。这样不仅可以为UserManager这一个接口服务了，其他接口的方法如果需要添加日志，都可以通过这一个动态代理类来实现。

Cglib动态代理

添加jar包asm-commons-2.2.2.jar、asm-util-2.2.2.jar、asm-2.2.2.jar、cglib-nodep-2.1\_3.jar。

注意：如果用了cglib-nodep-2.1\_3.jar，就不能用cglib-2.2.2.jar了，这两个jar包会冲突；而且Spring的asm-2.2.2.jar和Hibernate的asm.jar也会冲突，不能共存。否则会报如下的错：

java.lang.NoSuchMethodError: org.objectweb.asm.ClassWriter.<init>(Z)V

Cglib代理实现

import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    
    public class CglibProxy implements MethodInterceptor { 
        private Enhancer enhancer = new Enhancer();
        public Object getProxy(Class clazz) {
            // 设置需要创建子类的类
            enhancer.setSuperclass(clazz);
            enhancer.setCallback(this);
            // 通过字节码技术动态创建子类实例
            return enhancer.create();
        }
    
        // 实现MethodInterceptor接口方法
        public Object intercept(Object obj, Method method, Object[] args,MethodProxy proxy) throws Throwable {
            //代理服务方法
            insertLog(method,args);
            // 通过代理类调用父类中的方法
            Object result = proxy.invokeSuper(obj, args);
            return result;
        }
    
        private void insertLog(Method method,Object[] args){
            System.out.println("logInfo：【methodName:"+method.getName()+";args:"+args+"】");
        }
    }

客户端调用如下：

public class Client {
        public static void main(String[] args) {
            CglibProxy cglibProxy=new CglibProxy();
            UserManagerImpl userManager=(UserManagerImpl)cglibProxy.getProxy(UserManagerImpl.class);
            userManager.addUser(new User("Danny","123456"));
        }
    }

最后简单总结两点JDK和Cglib实现的动态代理的区别：

1、JDK实现动态代理的代理对象和目标对象必须实现相同的接口；Cglib实现动态代理的原理则是为目标对象创建一个子类座位代理对象。如果目标类实现了接口，则必须用JDK动态代理，否则，两个都可以用。

2、JDK在运算量小的时候性能优于Cglib，运算量大的时候Cglib性能较优。详参考[《Cglib 与 JDK动态代理的运行性能比较》][Cglib _ JDK]

--------------------

【 转载请注明出处——胡玉洋[《静态代理与动态代理》][Link 1]】

[20160727112123672]: /images/20220719/8eec78b634e74237857ea5033c68e49c.png
[20160726212059459]: /images/20220719/97a37348597c4089a6e2bbd2f7e57581.png
[Cglib _ JDK]: http://www.cnblogs.com/haiq/p/4304615.html
[Link 1]: http://blog.csdn.net/huyuyang6688/article/details/52025353