java動態代理的定義：為其他目標類的方法增加切面的邏輯，即在執行目標類方法的時候，先去執行一段如校驗檢測的邏輯代碼。java通俗一點就是生成一個繼承目標類的子類，并在每個調用方法都添加一段邏輯。
應用場景：當我們從別的項目遷移過來的代碼進行修改的時候，如果有一個需求是當要執行某個業務類的所有方法前，需要校驗其權限或其他的時候，如果這個類是源代碼，我們還可以在類的基礎上對每個方法區更改，但若是打包成jar包的類，若該類有接口還可以實現一個代理模式創建一個代理類，沒有接口就比較麻煩，但接口一旦多起來，那編寫的話也比較麻煩。這時我們就需要用到動態代理，由jdk動態創建一個proxy類，我們通過proxy類來調用目標類的方法。
動態代理的實現有三種方法：1、使用代理模式。1）創建一個Star（明星）類，其實現了Speak，Eat接口

1. package cglib;
3. public class Star implements Speak,Eat{
5. @Override
6. public void say() {
7. // TODO Auto-generated method stub
8. System.out.println("i am a star");
9. }
11. @Override
12. public void eat() {
13. // TODO Auto-generated method stub
14. System.out.println("star eats some fruit");
15. }
17. }

2）創建一個Broker（經紀人）類，其實現了Speak接口，如下代碼：

1. package cglib;
4. //裝飾器模式
5. public class Broker implements Speak{
6. private Speak speak;
7. public Broker(Speak speak){
8. this.speak=speak;
9. }
10. @Override
11. public void say() {
12. // TODO Auto-generated method stub
13. speak.say();
14. }
16. }
17. 


3）測試代碼：
? ? ? ?輸出I am Star！ 一個經紀人可以代理不同的明星表述，這在現實中是符合的。2、使用JDK動態代理（原理是通過映射，動態生成java字節碼Proxy類）1）同樣以Star類為目標類，實現JDK動態代理需要實現InvocationHandler接口，如下：

1. package cglib;
3. import java.lang.reflect.InvocationHandler;
4. import java.lang.reflect.Method;
5. import java.lang.reflect.Proxy;
7. public class JDKDynamicProxy implements InvocationHandler{
8. private Object speak;
9. private JDKDynamicProxy(Object speak){
10. //傳入star對象
11. this.speak=speak;
12. }
15. //創建一個靜態方法，生成代理類，
16. public static Object newProxyInstance(Object speak){
17. System.out.println(JDKDynamicProxy.class.getClassLoader().toString());
18. return Proxy.newProxyInstance(JDKDynamicProxy.class.getClassLoader(),new Class[]{Speak.class,Eat.class}, new JDKDynamicProxy(speak));
19. }
22. //覆蓋InvocationHandler的invoke方法，從參數可以看出，這個方法明顯使用了jdk的方法映射來調用Star的方法，在調用Star的方法前后，我們都可以增加自己的邏輯代碼
23. @Override
24. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
25. // TODO Auto-generated method stub
26. System.out.println("call the JDKDynamicProxy");
28. return method.invoke(speak, args);
29. }
31. }

2)測試類

1. package cglib;
3. import java.lang.reflect.Constructor;
5. public class ProxyTest {
6. public static void main(String[] args) {
7. //裝飾者模式
8. Star star=new Star();
9. Speak b=new Broker(star);
10. b.say();
11. //jdk動態代理模式
12. Speak s=(Speak) JDKDynamicProxy.newProxyInstance(star);
13. s.say();
14. Eat e=(Eat) JDKDynamicProxy.newProxyInstance(star);
15. e.eat();
16. //CGlib動態代理
17. Speak sp=CGProxy.newCGproxyInstance(Star.class);
18. sp.say();
19. }
20. }

可以看出在調用Star的say（）方法之前，調用了JDKDynamicProxy 的invoke方法。3、使用CGLib動態代理（原理使用了asm）
? ? ? ? 1）CGProxy類，因為是方法攔截，故實現的是MethodInterceptor 接口，下面是一個簡單的實現方法。

1. package cglib;
3. import java.lang.reflect.Method;
5. import net.sf.cglib.proxy.Enhancer;
6. import net.sf.cglib.proxy.MethodInterceptor;
7. import net.sf.cglib.proxy.MethodProxy;
9. public class CGProxy implements MethodInterceptor {
11. public static <T extends Speak> Speak newCGproxyInstance(Class<T> superClass){
12. Enhancer en=new Enhancer();
13. en.setSuperclass(superClass);
14. en.setCallback(new CGProxy());
15. return (Speak)en.create();
16. }
19. @Override
20. public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
21. // TODO Auto-generated method stub
22. System.out.println("call the CGProxy");
23. return arg3.invokeSuper(arg0, arg2);
24. }
26. }

看代碼和JDK動態代理的寫法差不多，但其內部實現的原理卻不同。明顯的區別從代碼可以看出，JDK動態代理要傳入目標類的接口作為參數，所以目標類必須要有一個統一的接口，即如上的Speak，Eat接口，這就使得JDK動態代理有一定的局限性。而CGlib從代碼看出，傳入的是Class，不是接口，使用范圍更廣一些。


下一章探討一下JDK動態代理內部的實現原理。



null

轉載于:https://www.cnblogs.com/zhenyimo/p/6837321.html

總結

以上是生活随笔為你收集整理的java动态代理【一】的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。