Java动态代理（JDK接口代理和Cglib类代理）

代理模式 
代理模式是常用的java设计模式，它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。 
按照代理的创建时期，代理类可以分为两种。 
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。 
动态代理：在程序运行时，运用反射机制动态创建而成。 

静态代理：

BookInterface.java

public interface BookInterface
{
/**
* 业务方法
* Description: <br>
* @see
*/
void addBook();
}

BookImpl.java

public class BookImpl implements BookInterface
{

@Override
public void addBook()
{
System.out.println("stati@BookImpll#addBook");
}

}

BookProxy.java

/**
* 静态代理类   需要和委托类实现同样的接口
* @author lyh
* @version 2013-4-16
* @see BookProxy
* @since
*/
public class BookProxy implements BookInterface
{

private BookImpl bookImpl;

/**
* 这里使用构造函数注入委托类
* @param bookImpl
*/
public BookProxy(BookImpl bookImpl)
{
this.bookImpl = bookImpl;
}

@Override
public void addBook()
{
System.out.println("Before Advice");

bookImpl.addBook();

System.out.println("After Advice");
}

}

Will.java

/**
* 测试类
* @author lyh
* @version 2013-4-16
* @see Will
* @since
*/
public class Will
{

/**
* Description: <br>
* @param args
* @see
*/
public static void main(String[] args)
{
BookImpl impl=  new BookImpl();

BookProxy proxy = new BookProxy(impl);

//展示给客户端调用的是代理类的方法
proxy.addBook();
}

}

观察代码可以发现每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理，而且，所有的代理操作除了调用的方法不一样之外，其他的操作都一样，则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。 

再来看一下动态代理： 

JDK动态代理中包含一个类和一个接口（具体参见API手册）： 

InvocationHandler接口（这里推荐一篇文章 对于这个接口解释的很清楚 http://www.cnblogs.com/yixiwenwen/archive/2012/11/14/2770068.html）： 
public interface InvocationHandler { 

public Object invoke(Object proxy,Method method,Object[] args) throws Throwable; 

} 

参数说明： 

Object proxy：指被代理的对象。 

Method method：要调用的方法 

Object[] args：方法调用时所需要的参数 

可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。 

Proxy类： 

Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法： 

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, 

InvocationHandler h) 

                               throws IllegalArgumentException 

参数说明： 

ClassLoader loader：类加载器 

Class<?>[] interfaces：得到全部的接口 

InvocationHandler h：得到InvocationHandler接口的子类实例 

Ps:类加载器 

在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器; 

Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的； 

Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类; 

AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。 

动态代理 

与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 
JDK动态接口代理: 
BookInterface.java

public interface BookInterface
{
    /**
     * 业务方法
     * Description: <br> 
     * @see
     */
    void addBook();
    
    /**
     * 拦截方法
     * Description: <br> 
     * @see
     */
    void intercept();
}

BookImpl.java

public class BookImpl implements BookInterface
{

    @Override
    public void addBook()
    {
        System.out.println("dynamic@BookImpl#addBook");
    }
    
    @Override
    public void intercept()
    {
        System.out.println("dynamic@BookImpl#intercept is intercepted...");
    }

}

BookProxy.java

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

/**
* JDK 动态代理类  接口代理
* @author lyh
* @version 2013-4-16
* @see BookProxy
* @since
*/
public class BookProxy implements InvocationHandler
{
/**
* 委托类
*/
private Object target;

public Object getInstance(Object target)
{
this.target = target;

return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), this);
}

@Override
    public Object invoke(Object obj, Method method, Object[] args)
        throws Throwable
    {
        System.out.println("Before Advice");
        
        if("intercept".equals(method.getName()))
        {
            System.out.println("intercept method is intercepted");
            
            return null;
        }
        
        //注意此处的参数是注入的target 而不是obj
        Object  result = method.invoke(target, args);
        
        System.out.println("After Advice");
        
        return result;
    }

}

Will.java

/**
* 测试类
* @author lyh
* @version 2013-4-16
* @see Will
* @since
*/
public class Will
{

/**
* Description: <br>
* @param args
* @see
*/
public static void main(String[] args)
{
BookProxy proxy = new BookProxy();
BookInterface impl = (BookInterface)proxy.getInstance(new BookImpl());

//impl.addBook();
        impl.intercept();
}
}

但是，JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。 

Cglib动态代理 

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

public class BookClass
{
/**
* 业务方法 使用cglib则不需要额外定义接口
* Description: <br>
* @see
*/
public void addBook()
{
System.out.println("cglib@BookClass#addBook");
}
}

BookProxy.java

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

/**
* Cglib 动态代理类 类代理
* @author lyh
* @version 2013-4-16
* @see BookProxy
* @since
*/
public class BookProxy implements MethodInterceptor
{
/**
* 委托类
*/
private Object target;

public Object getInstance(Object target)
{
this.target = target;

Enhancer en = new Enhancer();

en.setSuperclass(target.getClass());

en.setCallback(this);

return en.create();
}

@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
throws Throwable
{
System.out.println("Before Advice");

//注意此处的参数是注入的target 而不是obj
Object result = proxy.invoke(target, args);

System.out.println("After Advice");

return result;
}

}

Will.java

/**
* 测试类
* @author lyh
* @version 2013-4-16
* @see Will
* @since
*/
public class Will
{

/**
* Description: <br>
* @param args
* @see
*/
public static void main(String[] args)
{
BookProxy proxy = new BookProxy();

BookClass bc = (BookClass)proxy.getInstance(new BookClass());

bc.addBook();
}

}