動態代理：在程式執行時，運用反射機制動態建立而成。 

靜態代理：

BookInterface.java

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

public class BookImpl implements BookInterface
{

    @Override
    public void addBook()
    {
        System.out.println("[email protected]#addBook");
    }

}

/**
 * 靜態代理類   需要和委託類實現同樣的介面 
 * @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");
    }

}
 

/**
 * 測試類
 * @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 介面提供了生成動態代理類的能力。 

BookInterface.java

public interface BookInterface
{
    /**
     * 業務方法
     * Description: <br> 
     * @see
     */
    void addBook();
    
    /**
     * 攔截方法
     * Description: <br> 
     * @see
     */
    void intercept();
}

public class BookImpl implements BookInterface
{


    @Override
    public void addBook()
    {
        System.out.println("[email protected]#addBook");
    }
    
    @Override
    public void intercept()
    {
        System.out.println("[email protected]#intercept is intercepted...");
    }


}

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;
    }

}

/**
 * 測試類 
 * @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();
    }
}

Cglib動態代理 
JDK的動態代理機制只能代理實現了介面的類，而不能實現介面的類就不能實現JDK的動態代理，cglib是針對類來實現代理的，他的原理是對指定的目標類生成一個子類，並覆蓋其中方法實現增強，但因為採用的是繼承，所以不能對final修飾的類進行代理。 

BookClass.java

public class BookClass
{
    /**
     * 業務方法 使用cglib則不需要額外定義介面
     * Description: <br> 
     * @see
     */
    public void addBook()
    {
        System.out.println("[email protected]#addBook");
    }
}

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;
    }

}

/**
 * 測試類
 * @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();
    }

}