分享知識-快樂自己：三種代理（靜態、JDK、CGlib 代理）
1）：代理模式（靜態代理）點我下載三種模式原始碼
代理模式是常用設計模式的一種，我們在軟體設計時常用的代理一般是指靜態代理，也就是在程式碼中顯式指定的代理。
靜態代理由 業務實現類、業務代理類 兩部分組成。
業務實現類 負責實現主要的業務方法，業務代理類負責對呼叫的業務方法作攔截、過濾、預處理，主要是在方法中首先進行預處理動作，然後呼叫業務實現類的方法，還可以規定呼叫後的操作。
我們在需要呼叫業務時，不是直接通過業務實現類來呼叫的，而是通過業務代理類的同名方法來呼叫被代理類處理過的業務方法。
靜態代理的實現：
1）：首先定義一個介面，說明業務邏輯。
package
2）：然後，定義業務實現類，實現業務邏輯介面
package com.gdbd.staticproxy.mapper.impl;
import com.gdbd.staticproxy.mapper.Count;
3）：定義業務代理類：通過組合，在代理類中建立一個業務實現類物件來呼叫具體的業務方法；通過實現業務邏輯介面，來統一業務方法；
在代理類中實現業務邏輯介面中的方法時，進行預處理操作、通過業務實現類物件呼叫真正的業務方法、進行呼叫後操作的定義。
package com.gdbd.staticproxy.proxy;
import com.gdbd.staticproxy.mapper.Count;
import com.gdbd.staticproxy.mapper.impl.CountImpl;
/**
* @author asus
*/
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("修改賬戶之後——————————");
}
}
4）：在使用時，首先建立業務實現類物件，然後把業務實現類物件作構造引數建立一個代理類物件，最後通過代理類物件進行業務方法的呼叫。
package com.gdbd.staticproxy;
import com.gdbd.staticproxy.mapper.impl.CountImpl;
import com.gdbd.staticproxy.proxy.CountProxy;
/**
*
* @author asus
*/
public class TextProxy {
public static void main(String[] args) {
CountImpl countImpl = new CountImpl();
CountProxy countProxy = new CountProxy(countImpl);
countProxy.updateCount();
countProxy.queryCount();
}
}
靜態代理的缺點很明顯：一個代理類只能對一個業務介面的實現類進行包裝，如果有多個業務介面的話就要定義很多實現類和代理類才行。
而且，如果代理類對業務方法的預處理、呼叫後操作都是一樣的（比如：呼叫前輸出提示、呼叫後自動關閉連線），則多個代理類就會有很多重複程式碼。
這時我們可以定義這樣一個代理類，它能代理所有實現類的方法呼叫：根據傳進來的業務實現類和方法名進行具體呼叫。——那就是動態代理。
2）：動態代理的第一種實現——JDK動態代理
JDK動態代理所用到的代理類在程式呼叫到代理類物件時才由JVM真正建立，JVM根據傳進來的 業務實現類物件 以及 方法名 ，動態地建立了一個代理類的class檔案並被位元組碼引擎執行，然後通過該代理類物件進行方法呼叫。
我們需要做的，只需指定代理類的預處理、呼叫後操作即可。
1）：首先，定義業務邏輯介面
package com.gdbd.jdkproxy.mapper;
/**
* @author asus
*/
public interface BookFacade {
/***
* 新增圖書
*/
public void addBook();
}
2）：然後，實現業務邏輯介面建立業務實現類
package com.gdbd.jdkproxy.mapper.impl;
import com.gdbd.jdkproxy.mapper.BookFacade;
/**
* @author asus
*/
public class BookFacadeImpl implements BookFacade {
@Override
public void addBook() {
System.out.println("增加圖書方法。。。");
}
}
3）：最後，實現 呼叫管理介面InvocationHandler 建立動態代理類
package com.gdbd.jdkproxy.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @author asus
*/
public class BookFacadeProxy implements InvocationHandler {
/***
* 這其實業務實現類物件，用來呼叫具體的業務方法
*/
private Object target;
/**
* 繫結業務物件並返回一個代理類
*/
public Object bind(Object target) {
//接收業務實現類物件引數
this.target = target;
//通過反射機制，建立一個代理類物件例項並返回。使用者進行方法呼叫時使用
//建立代理物件時，需要傳遞該業務類的類載入器（用來獲取業務實現類的元資料，在包裝方法是呼叫真正的業務方法）、介面、handler實現類
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), this);
}
/**
* 包裝呼叫方法：進行預處理、呼叫後處理
*/
@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;
}
}
4）：在使用時，首先建立一個業務實現類物件和一個代理類物件，然後定義介面引用（這裡使用向上轉型）並用代理物件.bind(業務實現類物件)的返回值進行賦值。
最後通過介面引用呼叫業務方法即可。（介面引用真正指向的是一個綁定了業務類的代理類物件，所以通過介面方法名呼叫的是被代理的方法們）
package com.gdbd.jdkproxy;
import com.gdbd.jdkproxy.mapper.BookFacade;
import com.gdbd.jdkproxy.mapper.impl.BookFacadeImpl;
import com.gdbd.jdkproxy.proxy.BookFacadeProxy;
/**
* @author asus
*/
public class TextProxy {
public static void main(String[] args) {
BookFacadeImpl bookFacadeImpl = new BookFacadeImpl();
BookFacadeProxy proxy = new BookFacadeProxy();
BookFacade bookfacade = (BookFacade)
proxy.bind(bookFacadeImpl);
bookfacade.addBook();
}
}
JDK動態代理的代理物件在建立時，需要使用業務實現類所實現的介面作為引數（因為在後面代理方法時需要根據介面內的方法名進行呼叫）。
如果業務實現類是沒有實現介面而是直接定義業務方法的話，就無法使用JDK動態代理了。
並且，如果業務實現類中新增了介面中沒有的方法，這些方法是無法被代理的（因為無法被呼叫）。
3）：動態代理的第二種實現——CGlib
cglib是針對類來實現代理的，原理是對指定的業務類生成一個子類，並覆蓋其中業務方法實現代理。因為採用的是繼承，所以不能對final修飾的類進行代理。
1）：首先定義業務類，無需實現介面（當然，實現介面也可以，不影響的）
package com.gdbd.cglibproxy.impl;
/**
* @author asus
*/
public class BookFacadeImpl1 {
public void addBook() {
System.out.println("新增圖書...");
}
}
2）：實現 MethodInterceptor方法代理介面，建立代理類
package com.gdbd.cglibproxy.proxy;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* @author asus
*/
public class BookFacadeCglib implements MethodInterceptor {
/***
* 業務類物件，供代理方法中進行真正的業務方法呼叫
*/
private Object target;
/***
* 相當於JDK動態代理中的繫結
* @param target
* @return
*/
public Object getInstance(Object target) {
//給業務物件賦值
this.target = target;
//建立加強器，用來建立動態代理類
Enhancer enhancer = new Enhancer();
//為加強器指定要代理的業務類（即：為下面生成的代理類指定父類）
enhancer.setSuperclass(this.target.getClass());
//設定回撥：對於代理類上所有方法的呼叫，都會呼叫CallBack，而Callback則需要實現intercept()方法進行攔
enhancer.setCallback(this);
// 建立動態代理類物件並返回
return enhancer.create();
}
/***
* 實現回撥方法
* @param obj
* @param method
* @param args
* @param proxy
* @return
* @throws Throwable
*/
@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;
}
}
3）：建立業務類和代理類物件，然後通過 代理類物件.getInstance(業務類物件) 返回一個動態代理類物件（它是業務類的子類，可以用業務類引用指向它）。
最後通過動態代理類物件進行方法呼叫。
package com.gdbd.cglibproxy;
import com.gdbd.cglibproxy.impl.BookFacadeImpl1;
import com.gdbd.cglibproxy.proxy.BookFacadeCglib;
/**
* @author asus
*/
public class TextProxy {
public static void main(String[] args) {
BookFacadeImpl1 bookFacade = new BookFacadeImpl1();
BookFacadeCglib cglib = new BookFacadeCglib();
BookFacadeImpl1 bookCglib = (BookFacadeImpl1) cglib.getInstance(bookFacade);
bookCglib.addBook();
}
}
比較：
靜態代理是通過在程式碼中顯式定義一個業務實現類一個代理，在代理類中對同名的業務方法進行包裝，使用者通過代理類呼叫被包裝過的業務方法；
JDK動態代理是通過介面中的方法名，在動態生成的代理類中呼叫業務實現類的同名方法；
CGlib動態代理是通過繼承業務類，生成的動態代理類是業務類的子類，通過重寫業務方法進行代理；