靜態代理
1、定義抽象主題接口。
package com.zhangguo.Spring041.aop02;
/**
* 接口
* 抽象主題
*/
public interface IMath {
//加
int add(int n1, int n2);
//減
int sub(int n1, int n2);
//乘
int mut(int n1, int n2);
//除
int div(int n1, int n2);
}
2、主題類，算術類，實現抽象接口。
package com.zhangguo.Spring041.aop02;
/**
* 被代理的目標對象
*真實主題
*/
public class Math implements IMath {
//加
public int add(int n1,int n2){
int result=n1+n2;
System.out.println(n1+"+"+n2+"="+result);
return result;
}
//減
public int sub(int n1,int n2){
int result=n1-n2;
System.out.println(n1+"-"+n2+"="+result);
return result;
}
//乘
public int mut(int n1,int n2){
int result=n1*n2;
System.out.println(n1+"X"+n2+"="+result);
return result;
}
//除
public int div(int n1,int n2){
int result=n1/n2;
System.out.println(n1+"/"+n2+"="+result);
return result;
}
}
3、代理類
1 package com.zhangguo.Spring041.aop02;
2
3 import java.util.Random;
4
5 /**
6 * 靜態代理類
7 */
8 public class MathProxy implements IMath {
9
10 //被代理的對象
11 IMath math=new Math();
12
13 //加
14 public int add(int n1, int n2) {
15 //開始時間
16 long start=System.currentTimeMillis();
17 lazy();
18 int result=math.add(n1, n2);
19 Long span= System.currentTimeMillis()-start;
20 System.out.println("共用時："+span);
21 return result;
22 }
23
24 //減法
25 public int sub(int n1, int n2) {
26 //開始時間
27 long start=System.currentTimeMillis();
28 lazy();
29 int result=math.sub(n1, n2);
30 Long span= System.currentTimeMillis()-start;
31 System.out.println("共用時："+span);
32 return result;
33 }
34
35 //乘
36 public int mut(int n1, int n2) {
37 //開始時間
38 long start=System.currentTimeMillis();
39 lazy();
40 int result=math.mut(n1, n2);
41 Long span= System.currentTimeMillis()-start;
42 System.out.println("共用時："+span);
43 return result;
44 }
45
46 //除
47 public int div(int n1, int n2) {
48 //開始時間
49 long start=System.currentTimeMillis();
50 lazy();
51 int result=math.div(n1, n2);
52 Long span= System.currentTimeMillis()-start;
53 System.out.println("共用時："+span);
54 return result;
55 }
56
57 //模擬延時
58 public void lazy()
59 {
60 try {
61 int n=(int)new Random().nextInt(500);
62 Thread.sleep(n);
63 } catch (InterruptedException e) {
64 e.printStackTrace();
65 }
66 }
67 }
4、測試運行
1 package com.zhangguo.Spring041.aop02;
2
3 public class Test {
4
5 IMath math=new MathProxy();
6 @org.junit.Test
7 public void test01()
8 {
9 int n1=100,n2=5;
10 math.add(n1, n2);
11 math.sub(n1, n2);
12 math.mut(n1, n2);
13 math.div(n1, n2);
14 }
15 }
5、小結
通過靜態代理，是否完全解決了上述的4個問題：
已解決：
5.1、解決了“開閉原則（OCP）”的問題，因為並沒有修改Math類，而擴展出了MathProxy類。
5.2、解決了“依賴倒轉（DIP）”的問題，通過引入接口。
5.3、解決了“單一職責（SRP）”的問題，Math類不再需要去計算耗時與延時操作，但從某些方面講MathProxy還是存在該問題。
未解決：
5.4、如果項目中有多個類，則需要編寫多個代理類，工作量大，不好修改，不好維護，不能應對變化。
如果要解決上面的問題，可以使用動態代理。
動態代理，使用JDK內置的Proxy實現
只需要一個代理類，而不是針對每個類編寫代理類。
在上一個示例中修改代理類MathProxy如下：
1 package com.zhangguo.Spring041.aop03;
2
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.Method;
5 import java.lang.reflect.Proxy;
6 import java.util.Random;
7
8 /**
9 * 動態代理類
10 */
11 public class DynamicProxy implements InvocationHandler {
12
13 //被代理的對象
14 Object targetObject;
15
16 /**
17 * 獲得被代理后的對象
18 * @param object 被代理的對象
19 * @return 代理后的對象
20 */
21 public Object getProxyObject(Object object){
22 this.targetObject=object;
23 return Proxy.newProxyInstance(
24 targetObject.getClass().getClassLoader(), //類加載器
25 targetObject.getClass().getInterfaces(), //獲得被代理對象的所有接口
26 this); //InvocationHandler對象
27 //loader:一個ClassLoader對象，定義了由哪個ClassLoader對象來生成代理對象進行加載
28 //interfaces:一個Interface對象的數組，表示的是我將要給我需要代理的對象提供一組什么接口，如果我提供了一組接口給它，那么這個代理對象就宣稱實現了該接口(多態)，這樣我就能調用這組接口中的方法了
29 //h:一個InvocationHandler對象，表示的是當我這個動態代理對象在調用方法的時候，會關聯到哪一個InvocationHandler對象上，間接通過invoke來執行
30 }
31
32
33 /**
34 * 當用戶調用對象中的每個方法時都通過下面的方法執行，方法必須在接口
35 * proxy 被代理后的對象
36 * method 將要被執行的方法信息（反射）
37 * args 執行方法時需要的參數
38 */
39 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
40 //被織入的內容，開始時間
41 long start=System.currentTimeMillis();
42 lazy();
43
44 //使用反射在目標對象上調用方法並傳入參數
45 Object result=method.invoke(targetObject, args);
46
47 //被織入的內容，結束時間
48 Long span= System.currentTimeMillis()-start;
49 System.out.println("共用時："+span);
50
51 return result;
52 }
53
54 //模擬延時
55 public void lazy()
56 {
57 try {
58 int n=(int)new Random().nextInt(500);
59 Thread.sleep(n);
60 } catch (InterruptedException e) {
61 e.printStackTrace();
62 }
63 }
64
65 }
測試運行：
1 package com.zhangguo.Spring041.aop03;
2
3 public class Test {
4
5 //實例化一個MathProxy代理對象
6 //通過getProxyObject方法獲得被代理后的對象
7 IMath math=(IMath)new DynamicProxy().getProxyObject(new Math());
8 @org.junit.Test
9 public void test01()
10 {
11 int n1=100,n2=5;
12 math.add(n1, n2);
13 math.sub(n1, n2);
14 math.mut(n1, n2);
15 math.div(n1, n2);
16 }
17
18 IMessage message=(IMessage) new DynamicProxy().getProxyObject(new Message());
19 @org.junit.Test
20 public void test02()
21 {
22 message.message();
23 }
24 }
小結：
JDK內置的Proxy動態代理可以在運行時動態生成字節碼，而沒必要針對每個類編寫代理類。中間主要使用到了一個接口InvocationHandler與Proxy.newProxyInstance靜態方法，參數說明如下：
使用內置的Proxy實現動態代理有一個問題：被代理的類必須實現接口，未實現接口則沒辦法完成動態代理。
動態代理，使用cglib實現
CGLIB(Code Generation Library)是一個開源項目,是一個強大的，高性能，高質量的Code生成類庫，它可以在運行期擴展Java類與實現Java接口，通俗說cglib可以在運行時動態生成字節碼。
4.1、引用cglib，通過maven
修改pom.xml文件，添加依賴
保存pom.xml配置文件，將自動從共享資源庫下載cglib所依賴的jar包，主要有如下幾個：
4.2、使用cglib完成動態代理，大概的原理是：cglib繼承被代理的類，重寫方法，織入通知，動態生成字節碼並運行，因為是繼承所以final類是沒有辦法動態代理的。具體實現如下：
1 package com.zhangguo.Spring041.aop04;
2
3 import java.lang.reflect.Method;
4 import java.util.Random;
5
6 import net.sf.cglib.proxy.Enhancer;
7 import net.sf.cglib.proxy.MethodInterceptor;
8 import net.sf.cglib.proxy.MethodProxy;
9
10 /*
11 * 動態代理類
12 * 實現了一個方法攔截器接口
13 */
14 public class DynamicProxy implements MethodInterceptor {
15
16 // 被代理對象
17 Object targetObject;
18
19 //Generate a new class if necessary and uses the specified callbacks (if any) to create a new object instance.
20 //Uses the no-arg constructor of the superclass.
21 //動態生成一個新的類，使用父類的無參構造方法創建一個指定了特定回調的代理實例
22 public Object getProxyObject(Object object) {
23 this.targetObject = object;
24 //增強器，動態代碼生成器
25 Enhancer enhancer=new Enhancer();
26 //回調方法
27 enhancer.setCallback(this);
28 //設置生成類的父類類型
29 enhancer.setSuperclass(targetObject.getClass());
30 //動態生成字節碼並返回代理對象
31 return enhancer.create();
32 }
33
34 // 攔截方法
35 public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
36 // 被織入的橫切內容，開始時間 before
37 long start = System.currentTimeMillis();
38 lazy();
39
40 // 調用方法
41 Object result = methodProxy.invoke(targetObject, args);
42
43 // 被織入的橫切內容，結束時間
44 Long span = System.currentTimeMillis() - start;
45 System.out.println("共用時：" + span);
46
47 return result;
48 }
49
50 // 模擬延時
51 public void lazy() {
52 try {
53 int n = (int) new Random().nextInt(500);
54 Thread.sleep(n);
55 } catch (InterruptedException e) {
56 e.printStackTrace();
57 }
58 }
59
60 }
測試運行：
package com.zhangguo.Spring041.aop04;
public class Test {
//實例化一個DynamicProxy代理對象
//通過getProxyObject方法獲得被代理后的對象
Math math=(Math)new DynamicProxy().getProxyObject(new Math());
@org.junit.Test
public void test01()
{
int n1=100,n2=5;
math.add(n1, n2);
math.sub(n1, n2);
math.mut(n1, n2);
math.div(n1, n2);
}
//另一個被代理的對象,不再需要重新編輯代理代碼
Message message=(Message) new DynamicProxy().getProxyObject(new Message());
@org.junit.Test
public void test02()
{
message.message();
}
}
運行結果：
4.3、小結
使用cglib可以實現動態代理，即使被代理的類沒有實現接口，但被代理的類必須不是final類。
如果項目中有些類沒有實現接口，則不應該為了實現動態代理而刻意去抽出一些沒有實例意義的接口，通過cglib可以解決該問題。