之前星球的球友面試，問了我一些問題，說讓我寫一下這個代理，和代理到底是根據什麼來進行區分，又該在什麼地方使用。這篇文章我細緻的講解一下關於代理的一些問題。
代理分類
-
靜態代理
-
動態搭理
靜態代理
我們先說靜態代理的實現方式，爲什麼不推薦使用靜態代理？
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的jar和asm的jar不要忘記找
運行結果
CGLIB debugging enabled, writing to 'D:\code'
TestService的構造
======插入前置通知======
TestService:sayHello
======插入後者通知======
實現CGLIB動態代理必須實現MethodInterceptor(方法攔截器)接口，
這個接口只有一個intercept()方法，這個方法有4個參數：
-
obj表示增強的對象，即實現這個接口類的一個對象；
-
method表示要被攔截的方法；
-
args表示要被攔截方法的參數；
-
proxy表示要觸發父類的方法對象；
代理的使用
那麼什麼時候使用靜態態代理，什麼時候使用動態代理和cgLib代理呢？
一般情況靜態代理是很少是用的，因爲他對代碼的複用性或者說是耦合度都非常不友好，不推薦使用。
如果目標對象至少實現了一個接口，那麼就用JDK動態代理，所有由目標對象實現的接口將全部都被代理。
如果目標對象沒有實現任何接口，就是個類，那麼就用CGLIB代理。
我是懿，一個正在被打擊還在努力前進的碼農。歡迎大家關注我們的公衆號，加入我們的知識星球，我們在知識星球中等着你的加入。