java代理（静态代理和jdk动态代理以及cglib代理）

版权声明：本文为Fighter168原创文章，未经允许不得转载。

 

目录(?)[+]

 

说到代理，脑袋中浮现一大堆代理相关的名词，代理模式，静态代理，jdk代理，cglib代理等等。

记忆特别深刻的是，一次面试中，一位面试官问我，spring的AOP核心采用的设计模式是什么什么模式，阅读过24种设计模式，以及阅读过spring源代码的我竟然答错了，回想起来，真是日了狗了，学过那么多遍的东西都忘记了，结果是装逼失败，自己要狠下心来，把代理都搞懂!

代理模式简述

代理模式是常用的Java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。 

静态代理

由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。下面通过例子展示。

定义接口

/**
 * 定义一个账户接口
 *
 * @author Fighter
 * @date 2016-04-20
 *
 */
public interface Count {
    // 查看账户方法
    public void queryCount();

    // 修改账户方法
    public void updateCount();

}

实现接口

/**
 * 委托类(包含业务逻辑)
 *
 * @author Fighter
 * @date 2016-04-20
 *
 */
public class CountImpl implements Count {

    @Override
    public void queryCount() {
        System.out.println("查看账户方法...");

    }

    @Override
    public void updateCount() {
        System.out.println("修改账户方法...");

    }

}

添加代理

/**
 * 这是一个代理类（增强CountImpl实现类）
 *
 * @author Fighter
 * @date 2016-04-20
 *
 */
public class CountProxy implements Count {
    private CountImpl countImpl;

    /**
     * 覆盖默认构造器
     *
     * @param countImpl
     */
    public CountProxy(CountImpl countImpl) {
        this.countImpl = countImpl;
    }

    @Override
    public void queryCount() {
        System.out.println("事务处理之前");
        // 调用委托类的方法;
        countImpl.queryCount();
        System.out.println("事务处理之后");
    }

    @Override
    public void updateCount() {
        System.out.println("事务处理之前");
        // 调用委托类的方法;
        countImpl.updateCount();
        System.out.println("事务处理之后");

    }

}

测试

/**
 *测试Count类
 *
 * @author Fighter
 * @date 2016-04-20
 *
 */
public class TestCount {
    public static void main(String[] args) {
        CountImpl countImpl = new CountImpl();
        CountProxy countProxy = new CountProxy(countImpl);
        countProxy.updateCount();
        countProxy.queryCount();

    }
}

JDK动态代理

特点：只能对实现了接口的类生产代理，不能针对类

定义接口

/**
 * 创建业务接口，包含业务可以提供对外的接口
 *
 * @author Fighter
 * @date 2016-04-19
 *
 */
public interface UserService{

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

定义实现类

/**
 * 创建业务接口实现类
 *
 * @author Fighter
 * @date 2016-04-19
 *
 */
public class UserServiceImpl implements UserService{
    @Override
    public void add() {
     System.out.println("----------add----------");

    }
}

定义代理

/**
 * 自定义简单的Invocation，对接口提供的方法进行增强
 *
 * @author Fighter
 * @date 2016-04-19
 */
public class MyInvocationHandler implements InvocationHandler {


    //目标对象
    private Object target;

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

    <span style="white-space:pre">    </span>/**
     * 执行目标对象的方法
     */
    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(),
                this.target.getClass().getInterfaces(),this);
    }


}

jdk动态代理测试

public class ProxyTest{

    @Test
    public void testProxy() throws Throwable{
        //实例化目标对象
        UserService userService=new UserServiceImpl();

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

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

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

CGLIB动态代理示例

JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。 

CGLIB是一个强大的高性能的代码生成包。被广泛的许多AOP框架使用，如Spring的AOP和dynaop，为他们提供方法的interceptor(拦截)，最流行的是OR Mapping工具hibernate也是使用CGLIB来代理单端的single-ended（多对一和一对一）关联（对集合的延迟抓取是采用其他机制实现）。EsayMock和jMock是通过模仿（moke）对象来测试java代码的包。他们都是通过使用CGLIB来为那些没有接口的类创建模仿（moke）对象。

我们先通过demo来快速了解CGLIB的使用示例。

定义实现类

/**
 * 这个是没有实现接口的实现类
 *
 * @author student
 *
 */
public class BookFacadeImpl {
    public void addBook() {
        System.out.println("增加图书的普通方法...");
    }
}

定义代理

/**
 * 使用cglib动态代理
 *
 * @author student
 *
 */
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;


    }

}

编写Cglib测试

public class TestCglib {

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

总结

当阅读到spring的AOP章节的时候发现其中使用了代理的一些方法，在此复习一下代理的一些实现以及操作。代理-Spring AOP的核心设计模式。