Java动态代理机制

(1)什么是代理？

大道理上讲代理是一种软件设计模式，目的地但愿能作到代码重用。具体上讲，代理这种设计模式是经过不直接访问被代理对象的方式，而访问被代理对象的方法。这个就比如 商户---->明星经纪人(代理)---->明星这种模式。咱们能够不经过直接与明星对话的状况下，而经过明星经纪人(代理)与其产生间接对话。

 

(2)什么状况下使用代理？

(1)设计模式中有一个设计原则是开闭原则，是说对修改关闭对扩展开放，咱们在工做中有时会接手不少前人的代码，里面代码逻辑让人摸不着头脑(sometimes the code is really like shit)，这时就很难去下手修改代码，那么这时咱们就能够经过代理对类进行加强。

(2)咱们在使用RPC框架的时候，框架自己并不能提早知道各个业务方要调用哪些接口的哪些方法 。那么这个时候，就可用经过动态代理的方式来创建一个中间人给客户端使用，也方便框架进行搭建逻辑，某种程度上也是客户端代码和框架松耦合的一种表现。

(3)Spring的AOP机制就是采用动态代理的机制来实现切面编程。

 

(3)静态代理和动态代理

咱们根据加载被代理类的时机不一样，将代理分为静态代理和动态代理。若是咱们在代码编译时就肯定了被代理的类是哪个，那么就能够直接使用静态代理；若是不能肯定，那么可使用类的动态加载机制，在代码运行期间加载被代理的类这就是动态代理，好比RPC框架和Spring AOP机制。

 

(4)动态代理类型

• JDK动态代理
• CGLIB动态代理

JDK动态代理示例

public interface Manager {
    public void modify(String msg);
}

public class ManagerImpl implements Manager {
    @Override
    public void modify(String msg) {
        System.out.println("*******modify()方法被调用" + msg);
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class BusinessHandler implements InvocationHandler {
    public Object delagate = null;
    
    public Object bind(Object obj){
        this.delagate = obj;
        return Proxy.newProxyInstance(this.delagate.getClass().getClassLoader(), this.delagate.getClass().getInterfaces(), this);
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("do something before method");
        Object ret = method.invoke(this.delagate, args);
        System.out.println("do something after method");
        return ret;
    }
}


public class TestJDKProxy {
    public static void main(String[] args) {
        // 元对象(被代理对象)
        ManagerImpl managerImpl = new ManagerImpl();

        // 业务代理类
        BusinessHandler securityHandler = new BusinessHandler();
        Manager managerProxy = (Manager) securityHandler.bind(managerImpl);
        managerProxy.modify("hello steve!");
    }
}

　　

CGLIB动态代理示例

public interface BookFacade {
    public void addBook(); 
}

public class BookFacadeImpl implements BookFacade {
    @Override
    public void addBook() {
        System.out.println("增长图书的普通方法...");  
    }
}

import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class BookFacadeCglib implements MethodInterceptor {
    private Object target;

    /**
     * 建立代理对象
     * 
     * @param target
     * @return
     */
    public Object getInstance(Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        // 回调方法  
        enhancer.setCallback(this);
        // 建立代理对象  
        return enhancer.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("事物开始");
        proxy.invokeSuper(obj, args);
        System.out.println("事物结束");
        return null;
    }
}

public class TestCglib {
    public static void main(String[] args) {
        BookFacadeCglib cglib = new BookFacadeCglib();
        BookFacade bookCglib = (BookFacade) cglib.getInstance(new BookFacadeImpl());
        bookCglib.addBook();
    }
}

　　

二者区别

1、简单来讲：

1. JDK动态代理只能对实现了接口的类生成代理，而不能针对类
2. CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法（继承）

2、Spring在选择用JDK仍是CGLiB的依据：

1. 当Bean实现接口时，Spring就会用JDK的动态代理
2. 当Bean没有实现接口时，Spring使用CGlib是实现
3. 能够强制使用CGlib（在spring配置中加入<aop:aspectj-autoproxy proxy-target-class="true"/>）

3、CGlib比JDK快？

1. 使用CGLib实现动态代理，CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，比使用Java反射效率要高。惟一须要注意的是，CGLib不能对声明为final的方法进行代理，由于CGLib原理是动态生成被代理类的子类。
2. 在对JDK动态代理与CGlib动态代理的代码实验中看，1W次执行下，JDK7及8的动态代理性能比CGlib要好20%左右。