java动态代理（JDK和cglib）

JAVA的动态代理
代理模式
代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。
按照代理的创建时期，代理类可以分为两种。
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
动态代理：在程序运行时，运用反射机制动态创建而成。
静态代理可以发现每一个代理类只能为一个接口服务，这样一来程序开发必然产生过多的代理，而所有的代理操作除了调用的方法不一样，其他的操作都一样，则测试肯定是重复代码，而动态代理可以解决此问题。
1、JDK动态代理
JDK动态代理包含一个类和一个接口：
InvocationHandler接口：
public interface InvocationHandler{
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable;
}
Object proxy:被代理的对象
Method method:要调用的方法
Object[] args:方法调用时所需要的参数
Proxy类
Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态的生成实现类，方法如下：
public static Object newProxyInstance(ClassLoader loader,Class

package com.jader.reflect.jdk;
public interface User {
    void addUser();
}

package com.jader.reflect.jdk;
public class UserImpl implements User {
    @Override
    public void addUser() {
        System.out.println("添加用户信息……");
    }
}

package com.jader.reflect.jdk;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class UserProxy implements InvocationHandler {

    private Object target;
    /**
     * proxy：被代理的对象
     * method:用调用的方法
     * args:调用方法需要的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object result = null;
        System.out.println("增强操作开始");
        result = method.invoke(target, args);
        System.out.println("增强操作结束");
        return result;
    }

/**
     * Description: 绑定委托对象并返回一个代理类
     * @param  
     * @return 
     * @throws 
     * @Author fuyuwei
     * Create Date: 2015年11月23日 下午9:55:39
     */
    public Object bind(Object target){
        this.target = target;
        // 取得代理对象,通过类加载器得到全部接口
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
}

package com.jader.reflect.jdk;
import com.jader.reflect.jdk.User;
public class TestProxy {
    public static void main(String[] args) {
        UserProxy proxy = new UserProxy();
        User user = (User) proxy.bind(new UserImpl());
        user.addUser();
    }
}

Cglib动态代理

package com.jader.reflect.cglib;
/**
 * Description: JDK的动态代理只能代理实现了接口的类，而不能实现接口的类就不能实现JDK动态代理，cglib是针对类来实现代理的他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现
 * 增强，但因为采用的是继承，所以不能对final修饰的类进行代理
 * @author fuyuwei
 * @date2015年11月23日 下午10:12:35
 */
public interface UserCglib {
    void addUser();
}

package com.jader.reflect.cglib;
public class UserCglibImpl {
    public void addUser(){
        System.out.println("添加用户信息");
    }
}

package com.jader.reflect.cglib;
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 UserCglibProxy implements MethodInterceptor {

    private Object target;

    /**
     * Description: 创建代理对象
     * @param  
     * @return 
     * @throws 
     * @Author fuyuwei
     * Create Date: 2015年11月23日 下午10:19:23
     */
    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;
    }
}

package com.jader.reflect.cglib;
public class TestCglib {
    public static void main(String[] args) {
        UserCglibProxy userCglib = new UserCglibProxy();
        UserCglibImpl userCglibImpl = (UserCglibImpl) userCglib.getInstance(new UserCglibImpl());
        userCglibImpl.addUser();
    }
}

注意：需要使用cglib-2.2.jar，2.13会报错