java動态代理（JDK和cglib實作對比）

ava的動态代理 

代理模式 

代理模式是常用的java設計模式，他的特征是代理類與委托類有同樣的接口，代理類主要負責為委托類預處理消息、過濾消息、把消息轉發給委托類，以及事後處理消息等。代理類與委托類之間通常會存在關聯關系，一個代理類的對象與一個委托類的對象關聯，代理類的對象本身并不真正實作服務，而是通過調用委托類的對象的相關方法，來提供特定的服務。 

按照代理的建立時期，代理類可以分為兩種。 

靜态代理：由程式員建立或特定工具自動生成源代碼，再對其編譯。在程式運作前，代理類的.class檔案就已經存在了。 

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

首先看一下靜态代理： 

1、count.java 

java代碼  

package net.battier.dao;  

/** 

 * 定義一個賬戶接口 

 *  

 * @author administrator 

 */  

public interface count {  

    // 檢視賬戶方法  

    public void querycount();  

    // 修改賬戶方法  

    public void updatecount();  

}  

2、countimpl.java 

package net.battier.dao.impl;  

import net.battier.dao.count;  

 * 委托類(包含業務邏輯) 

public class countimpl implements count {  

    @override  

    public void querycount() {  

        system.out.println("檢視賬戶方法...");  

    }  

    public void updatecount() {  

        system.out.println("修改賬戶方法...");  

、countproxy.java  

 * 這是一個代理類（增強countimpl實作類） 

public class countproxy implements count {  

    private countimpl countimpl;  

    /** 

     * 覆寫預設構造器 

     *  

     * @param countimpl 

     */  

    public countproxy(countimpl countimpl) {  

        this.countimpl = countimpl;  

        system.out.println("事務處理之前");  

        // 調用委托類的方法;  

        countimpl.querycount();  

        system.out.println("事務處理之後");  

        countimpl.updatecount();  

3、testcount.java 

package net.battier.test;  

import net.battier.dao.impl.countimpl;  

import net.battier.dao.impl.countproxy;  

 *測試count類 

public class testcount {  

    public static void main(string[] args) {  

        countimpl countimpl = new countimpl();  

        countproxy countproxy = new countproxy(countimpl);  

        countproxy.updatecount();  

        countproxy.querycount();  

觀察代碼可以發現每一個代理類隻能為一個接口服務，這樣一來程式開發中必然會産生過多的代理，而且，所有的代理操作除了調用的方法不一樣之外，其他的操作都一樣，則此時肯定是重複代碼。解決這一問題最好的做法是可以通過一個代理類完成全部的代理功能，那麼此時就必須使用動态代理完成。 

再來看一下動态代理： 

jdk動态代理中包含一個類和一個接口： 

invocationhandler接口： 

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 接口提供了生成動态代理類的能力。 

動态代理示例: 

1、bookfacade.java 

public interface bookfacade {  

    public void addbook();  

2、bookfacadeimpl.java 

import net.battier.dao.bookfacade;  

public class bookfacadeimpl implements bookfacade {  

    public void addbook() {  

        system.out.println("增加圖書方法。。。");  

、bookfacadeproxy.java  

package net.battier.proxy;  

import java.lang.reflect.invocationhandler;  

import java.lang.reflect.method;  

import java.lang.reflect.proxy;  

 * jdk動态代理代理類 

 * @author student 

public class bookfacadeproxy implements invocationhandler {  

    private object target;  

     * 綁定委托對象并傳回一個代理類 

     * @param target 

     * @return 

    public object bind(object target) {  

        this.target = target;  

        //取得代理對象  

        return proxy.newproxyinstance(target.getclass().getclassloader(),  

                target.getclass().getinterfaces(), this);   //要綁定接口(這是一個缺陷，cglib彌補了這一缺陷)  

     * 調用方法 

    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;  

3、testproxy.java 

import net.battier.dao.impl.bookfacadeimpl;  

import net.battier.proxy.bookfacadeproxy;  

public class testproxy {  

        bookfacadeproxy proxy = new bookfacadeproxy();  

        bookfacade bookproxy = (bookfacade) proxy.bind(new bookfacadeimpl());  

        bookproxy.addbook();  

但是，jdk的動态代理依靠接口實作，如果有些類并沒有實作接口，則不能使用jdk代理，這就要使用cglib動态代理了。 

cglib動态代理 

jdk的動态代理機制隻能代理實作了接口的類，而不能實作接口的類就不能實作jdk的動态代理，cglib是針對類來實作代理的，他的原理是對指定的目标類生成一個子類，并覆寫其中方法實作增強，但因為采用的是繼承，是以不能對final修飾的類進行代理。 

示例 

1、bookfacadecglib.java 

2、bookcadeimpl1.java 

 * 這個是沒有實作接口的實作類 

public class bookfacadeimpl1 {  

        system.out.println("增加圖書的普通方法...");  

3、bookfacadeproxy.java 

import net.sf.cglib.proxy.enhancer;  

import net.sf.cglib.proxy.methodinterceptor;  

import net.sf.cglib.proxy.methodproxy;  

 * 使用cglib動态代理 

public class bookfacadecglib implements methodinterceptor {  

     * 建立代理對象 

    public object getinstance(object target) {  

        enhancer enhancer = new enhancer();  

        enhancer.setsuperclass(this.target.getclass());  

        // 回調方法  

        enhancer.setcallback(this);  

        // 建立代理對象  

        return enhancer.create();  

    // 回調方法  

    public object intercept(object obj, method method, object[] args,  

            methodproxy proxy) throws throwable {  

        proxy.invokesuper(obj, args);  

        return null;  

4、testcglib.java 

import net.battier.dao.impl.bookfacadeimpl1;  

import net.battier.proxy.bookfacadecglib;  

public class testcglib {  

        bookfacadecglib cglib=new bookfacadecglib();  

        bookfacadeimpl1 bookcglib=(bookfacadeimpl1)cglib.getinstance(new bookfacadeimpl1());  

        bookcglib.addbook();  

}  

分類: hibernate

特别說明：尊重作者的勞動成果，轉載請注明出處哦~~~http://blog.yemou.net/article/query/info/tytfjhfascvhzxcyt214