【Java基础】——JDK动态代理VSCGLIB动态代理

约定不等于承诺〃 2022-05-30 06:24 184阅读 0赞

##  前提 ##

之前分别写过[代理模式][Link 1]和[反射机制][Link 2]，这篇文章主要总结一下两者结合使用的产物动态代理。

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

##  JDK动态代理 ##

JDK实现动态代理需要实现类通过实现接口定义业务方法完成。  
实现方式

public interface HelloService { 
        public void sayHello(String name);
    }
    
    public class HelloServiceImpl implements HelloService { 
        @Override
        public void sayHello(String name) {
            System.err.println("hello"+name);
        }
    }
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /** * @author 贾文静-JDK实现动态代理 * @DESCRIPTION:$ * @Date: **/
    public class HelloServiceProxy implements InvocationHandler { 
    
    // 真实服务对象
        private Object target;
    
        /** * 绑定委托对象并返回代理对象 * @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.err.println("#####我是jdk代理");
            Object result = null;
            System.err.println("我准备说Hello。");
            result = method.invoke(target, args);
            System.err.println("我说Hello了");
            return result;
        }
    }
    /** * @author 贾文静 * @DESCRIPTION:$ * @Date: **/
    public class HelloServiceMain { 
        public static void main(String[] args) {
    // 创建代理对象
            HelloServiceProxy helloServiceProxy = new HelloServiceProxy();
    // 委托代理对象执行HelloService
            HelloService proxy = (HelloService) helloServiceProxy.bind(new HelloServiceImpl());
            //本质调用的代理对象的involve方法
            proxy.sayHello("张三");
        }
    }

步骤  
1、代理对象和真实对象进行绑定，绑定过程中代理对象获取到真实对象，即代理类中target  
2、代理对象调用方法实际执行的是invoke方法，在invoke利用反射机制调用到HelloServiceImpl类的方法

## CGLIB动态代理： ##

JDK动态代理有一个缺陷就是必须有接口，如果没有接口的方法又该如何实现动态代理？即也就是CGLIB方式的动态代理所提供的方式。  
     CGLIB采用底层的字节码技术，CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，并在子类中采用方法拦截技术拦截所有调用父类方法的调用，比使用Java反射效率要高。唯一需要注意的是，CGLib不能对声明为final的方法进行代理，因为CGLib原理是动态生成被代理类的子类。

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

实现方式

//添加依赖
            <dependency>
                <groupId>cglib</groupId>
                <artifactId>cglib</artifactId>
                <version>3.2.4</version>
            </dependency>
     import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    
    import java.lang.reflect.Method;
    
    /** * @author 贾文静 * @DESCRIPTION:$ * @Date: **/
    public class HelloServiceCgLib implements MethodInterceptor {
        private Class target;
    
        public Object getInstance(Class target) {
            this.target = target;
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(this.target);
            enhancer.setCallback(this);
            return enhancer.create();
        }
    
        @Override
        public Object intercept(Object object, Method method, Object[] objects, MethodProxy proxy) throws Throwable {
            System.out.println("我是CGLIB的动态代理");
            System.out.println("我准备说hello");
            Object returnObj = proxy.invokeSuper(object, objects);
            System.out.println("我说过hello了");
            return returnObj;
        }
    }
    
    public class Hello {
        public void sayHello(String name) {
            System.out.println("hello"+name);
        }
    }
    
    public class CGLib {
        public static void main(String[] args) {
            HelloServiceCgLib helloServiceCgLib = new HelloServiceCgLib();
            Hello proxy = (Hello) helloServiceCgLib.getInstance(Hello.class);
    
            proxy.sayHello("贾文静");
    
        }
    }

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

## JDK动态代理VSCGLIB动态代理 ##

CGLIb创建动态代理对象相比JDK创建的动态代理对象性能高很多，但是CGLIb在创建对象的时所花费的时间比JDK多，所以对于单例对象，不用频繁创建的使用CGLIb效率会更好一些，比如需要延迟加载的地方使用CGLIb，相反使用JDK动态代理更合适。因为CGLIb是动态创建子类，对于final方法，无法进行代理。在会更合适一些。  
     **如有错误之处还请各位大神指出，小编不胜感激！！！**

[Link 1]: http://blog.csdn.net/jiadajing267/article/details/78561872
[Link 2]: http://blog.csdn.net/jiadajing267/article/details/79374861