动态代理模式和AOP探究

java强大的反射机制给动态代理带来了可能、能够自由穿梭在类与方法之间、简直神通广大、

动态代理的一个小例子，顺便看看神奇的AOP是如何实现的、代码如下： 

首先声明的是一个接口Dog类

1 package com.chenjun.test;

2 

3 public interface Dog

4 {

5     public void info();

6     public void run();

7 }

然后一个“猎狗类”实现了该接口

 1 package com.chenjun.test;

 2 

 3 public class GunDog implements Dog

 4 {

 5 

 6     @Override

 7     public void info()

 8     {

 9         // TODO 自动生成的方法存根

10         System.out.println("猎狗");

11     }

12 

13     @Override

14     public void run()

15     {

16         // TODO 自动生成的方法存根

17         System.out.println("迅速奔跑");

18     }

19     

20 }

然后是一个用于切面编程的AOP类，比如在鬣狗类的方法执行前后分别调用method1和method2

代码如下：

 1 package com.chenjun.test;

 2 

 3 public class DogAop

 4 {

 5 

 6     public void method1()

 7     {

 8         System.out.println(" AOP method1");

 9     }

10     public void method2()

11     {

12         System.out.println(" AOP method2");

13     }

14 

15 }

然后本例的最重要的一个类登场：

AOP将实际target调用的方法无情夹杀、  形成所谓的AOP

 1 /**

 2  * 

 3  */

 4 package com.chenjun.test;

 5 

 6 import java.lang.reflect.InvocationHandler;

 7 import java.lang.reflect.Method;

 8 

 9 /**

10  * @author Administrator

11  *

12  */

13 public class MyInvocationHandle implements InvocationHandler

14 {

15     //需要被代理的对象

16     /* （非 Javadoc）

17      * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])

18      */

19     private Object target;   //需要被代理的目标对象

20     public void setTarget(Object target)

21     {

22         this.target = target;  //设置需要被代理的目标对象

23     }

24     public Object invoke(Object proxy, Method method, Object[] args)  //开始代理了。挂羊头卖狗肉开始

25             throws Throwable

26     {

27         // TODO 自动生成的方法存根

28         DogAop dogAop = new DogAop();  //用于AOP的类实例化

29         dogAop.method1();  //AOP方法1

30         Object result = method.invoke(target, args);  //真实的方法调用。利用反射

31         dogAop.method2();  //aop方法2

32         

33         return result;

34     }

35 

36 }

最后来个主函数：

 1 package com.chenjun.test;

 2 

 3 import java.lang.reflect.Proxy;

 4 

 5 public class Main

 6 {

 7     public static void main(String []args)

 8     {

 9         Dog target = new GunDog();  //new一个需要被动态代理的对象

10         MyInvocationHandle handler = new MyInvocationHandle();  

11         handler.setTarget(target);  //挂羊头卖狗肉开始

12         

13         Dog dog  = (Dog)Proxy.newProxyInstance(target.getClass().getClassLoader(),

14                 target.getClass().getInterfaces(),

15                 handler);

16         dog.info();  //明修栈道，暗度陈仓 ，内部已经调用了代理类的方法。原对象的方法被添油加醋了、

17         dog.run();   //同上

18     }

19 }