java动态代理实现

jdk代理

参考博文:jdk动态代理实现原理 以前虽然会用jdk代理，但一直不知道是怎么回事，好比说：InvocationHandler的invoke方法是由谁来调用的，代理对象是怎么生成的。 先来看看jdk的动态代理是怎么用的吧

实现本身的InvocationHandler code

package com.geccocrawler.gecco.spider.render.html;

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

/**
 * 实现本身的InvocationHandler
 *
 * @author zyb
 * @since 2012-8-9
 */
public class MyInvocationHandler implements InvocationHandler {

    // 目标对象   
    private Object target;

    /**
     * 构造方法
     *
     * @param target 目标对象
     */
    public MyInvocationHandler(Object target) {
        super();
        this.target = target;
    }


    /**
     * 执行目标对象的方法
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        // 在目标对象的方法执行以前简单的打印一下  
        System.out.println("------------------before------------------");

        // 执行目标对象的方法  
        Object result = method.invoke(target, args);

        // 在目标对象的方法执行以后简单的打印一下  
        System.out.println("-------------------after------------------");

        return result;
    }

    /**
     * 获取目标对象的代理对象
     *
     * @return 代理对象
     */
    public Object getProxy() {
        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                target.getClass().getInterfaces(), this);
    }
}

目标对象实现的接口UserService code

package com.geccocrawler.gecco.spider.render.html;

import java.io.IOException;

/**
 * 目标对象实现的接口，用JDK来生成代理对象必定要实现一个接口
 *
 * @author zyb
 * @since 2012-8-9
 */
public interface UserService {

    /**
     * 目标方法
     */
    public abstract void add();

}

目标对象UserServiceImpl code

package com.geccocrawler.gecco.spider.render.html;

import java.io.IOException;

/**
 * 目标对象
 *
 * @author zyb
 * @since 2012-8-9
 */
public class UserServiceImpl implements UserService {
  
    /* (non-Javadoc) 
     * @see dynamic.proxy.UserService#add() 
     */

    public void add() {
        System.out.println("--------------------add---------------");
    }
}

动态代理测试类ProxyTest code

package com.geccocrawler.gecco.spider.render.html;

/**
 * 动态代理测试类
 *
 * @author zyb
 * @since 2012-8-9
 */
public class ProxyTest {

    public static void main(String[] args) throws Throwable {
        // 实例化目标对象  
        UserService userService = new UserServiceImpl();

        // 实例化InvocationHandler
        MyInvocationHandler invocationHandler = new MyInvocationHandler(userService);

        // 根据目标对象生成代理对象  
        UserService proxy = (UserService) invocationHandler.getProxy();

        // 调用代理对象的方法  
        proxy.add();

    }
}

执行结果以下： ------------------before------------------ --------------------add--------------- -------------------after------------------

用起来是很简单吧，其实这里基本上就是AOP的一个简单实现了，在目标对象的方法执行以前和执行以后进行了加强。Spring的AOP实现其实也是用了Proxy和InvocationHandler这两个东西的。

用起来是比较简单，可是若是能知道它背后作了些什么手脚，那就更好不过了。首先来看一下JDK是怎样生成代理对象的。既然生成代理对象是用的Proxy类的静态方newProxyInstance，那么咱们就去它的源码里看一下它到底都作了些什么？ 在内存中生成一个字节码文件，而后使用classload加载，反射实例化，调用MyInvocationHandler中的invoke方法实现代理

cglib代理

参考博文：cglib动态代理实现 JDK实现动态代理须要实现类经过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就须要CGLib了。CGLib采用了很是底层的字节码技术，其原理是经过字节码技术为一个类建立子类，并在子类中采用方法拦截的技术拦截全部父类方法的调用，顺势织入横切逻辑。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础 简单的实现举例： 这是一个须要被代理的类，也就是父类，经过字节码技术建立这个类的子类，实现动态代理。

public class SayHello {
    public void say() {
        System.out.println("hello everyone");
    }
}

该类实现了建立子类的方法与代理的方法。getProxy(SuperClass.class)方法经过入参即父类的字节码，经过扩展父类的class来建立代理对象。intercept()方法拦截全部目标类方法的调用，obj表示目标类的实例，method为目标类方法的反射对象，args为方法的动态入参，proxy为代理类实例。proxy.invokeSuper(obj, args)经过代理类调用父类中的方法。

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 {
        System.out.println("前置代理");
        //经过代理类调用父类中的方法
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("后置代理");
        return result;
    }
}

具体实现类：

public class DoCGLib {
    public static void main(String[] args) {
        CglibProxy proxy = new CglibProxy();
        //经过生成子类的方式建立代理类
        SayHello proxyImp = (SayHello) proxy.getProxy(SayHello.class);
        proxyImp.say();
    }
}

输出结果： 前置代理 hello everyone 后置代理

CGLib建立的动态代理对象性能比JDK建立的动态代理对象的性能高很多，可是CGLib在建立代理对象时所花费的时间却比JDK多得多，因此对于单例的对象，由于无需频繁建立对象，用CGLib合适，反之，使用JDK方式要更为合适一些。同时，因为CGLib因为是采用动态建立子类的方法，对于final方法，没法进行代理

补充—————————————————— 代理是为一个类设置代理，不是针对方法

jdk的代理须要接口是由于内存中动态生成的字节码须要实现那个接口，以便于强转类型不出现报错，即超类一致

cglib不须要是由于他是在须要代理的类的基础上生成的子类，也作到了超类一致，强转不会报错