三分鐘吃透代理技術！
最近有網友問了我一些問題，什么是代理，又該在什么地方使用。結合之前的討論，這篇文章我們一起細致的講解一下關于代理的一些問題。
在 Java 中，代理通常分為兩類：
- 靜態代理
- 動態代理
兩者技術實現是不一樣的，具體有什么區別呢？下面我們一起來看看。
一、靜態代理
我們先說靜態代理的實現方式，為什么不推薦使用靜態代理？
1.繼承方式實現代理（靜態代理中的繼承代理）
//目標對象
public class UserImpl {
public void system(){
System.out.println("輸出測試");
}
}
//代理對象
public class Proxy extends UserImpl {
@Override
public void system() {
super.system();
System.out.println("增強之后的輸出");
}
}
//測試類
public class TestMain {
public static void main(String[] args) {
UserImpl user = new Proxy();
user.system();
}
}靜態代理可以看出來一點問題吧？
每次代理都要實現一個類，導致項目中代碼很多；你每次想要代理，都要去實現一個類，代碼就會成堆的增加，然后你就會發現項目的類就會越來越多，就會導致你們的項目顯得很臃腫。而且代碼的復用性太低了，并且耦合度非常高，這個我們所說的高內聚低耦合是相悖的。
二、動態代理
我們在看一下這個動態代理：
//接口類
public interface Italk {
public void talk(String msg);
}
//實現類
public class People implements Italk {
public String username;
public String age;
public String getName() {
return username;
}
public void setName(String name) {
this.username= name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public People(String name1, String age1) {
this.username= name1;
this.age = age1;
}
public void talk(String msg) {
System.out.println(msg+"!你好,我是"+username+"，我年齡是"+age);
}
}
//代理類
public class TalkProxy implements Italk {
Italk talker;
public TalkProxy (Italk talker) {
//super();
this.talker=talker;
}
public void talk(String msg) {
talker.talk(msg);
}
public void talk(String msg,String singname) {
talker.talk(msg);
sing(singname);
}
private void sing(String singname){
System.out.println("唱歌："+singname);
}
}
//測試
public class MyProxyTest {
//代理模式
public static void main(String[] args) {
//不需要執行額外方法的
Italk people1=new People("湖海散人","18");
people1.talk("No ProXY Test");
System.out.println("-----------------------------");
//需要執行額外方法的
TalkProxy talker=new TalkProxy(people1);
talker.talk("ProXY Test","七里香");
}
}代碼解析如下：
一個 Italk 接口，有空的方法 talk（）（說話），所有的 people 對象都實現（implements）這個接口，實現 talk() 方法，前端有很多地方都將 people 實例化，執行 talk 方法，后來發現這些前端里有一些除了要說話以外還要唱歌（sing），那么我們既不能在 Italk 接口里增加 sing() 方法，又不能在每個前端都增加 sing 方法，我們只有增加一個代理類 talkProxy ，這個代理類里實現 talk 和 sing 方法，然后在需要 sing 方法的客戶端調用代理類即可，
這也是實現動態代理的方式，是通過實現（implements）的方式來實現的，這種方法的優點，在編碼時，代理邏輯與業務邏輯互相獨立，各不影響，沒有侵入，沒有耦合。
三、cgLib代理
還有一種是cgLib的代理，這種代理則是適合那些沒有接口抽象的類代理，而Java 動態代理適合于那些有接口抽象的類代理。
我們來通過代碼了解一下他到底是怎么玩的。
/**
* 業務類，
*/
public class TestService {
public TestService() {
System.out.println("TestService的構造");
}
/**
* 該方法不能被子類覆蓋,Cglib是無法代理final修飾的方法的
*/
final public String sayOthers(String name) {
System.out.println("TestService:sayOthers>>"+name);
return null;
}
public void sayHello() {
System.out.println("TestService:sayHello");
}
}
/**
* 自定義MethodInterceptor
*/
public class MethodInterceptorTest implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("======插入前置通知======");
Object object = methodProxy.invokeSuper(o, objects);
System.out.println("======插入后者通知======");
return object;
}
}
/**
* 測試
*/
public class Client {
public static void main(String[] args) {
// 代理類class文件存入本地磁盤方便我們反編譯查看源碼
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\code");
// 通過CGLIB動態代理獲取代理對象的過程
Enhancer enhancer = new Enhancer();
// 設置enhancer對象的父類
enhancer.setSuperclass(TestService.class);
// 設置enhancer的回調對象
MethodInterceptorTest t = new MethodInterceptorTest();
enhancer.setCallback(t);
// 創建代理對象
TestService proxy= (TestService)enhancer.create();
// 通過代理對象調用目標方法
proxy.sayHello();
}
}運行結果：
CGLIB debugging enabled, writing to 'D:\code'
TestService的構造
======插入前置通知======
TestService:sayHello
======插入后者通知======實現CGLIB動態代理必須實現MethodInterceptor(方法攔截器)接口，
這個接口只有一個intercept()方法，這個方法有4個參數：
- obj表示增強的對象，即實現這個接口類的一個對象；
- method表示要被攔截的方法；
- args表示要被攔截方法的參數；
- proxy表示要觸發父類的方法對象；
四、代理的使用
那么什么時候使用靜態態代理，什么時候使用動態代理和cgLib代理呢？
一般情況靜態代理是很少是用的，因為他對代碼的復用性或者說是耦合度都非常不友好，不推薦使用。
如果目標對象至少實現了一個接口，那么就用JDK動態代理，所有由目標對象實現的接口將全部都被代理。
如果目標對象沒有實現任何接口，就是個類，那么就用CGLIB代理。
