java反射（8） AOP

1. AOP，面向切片编程，可以实现在不用将两部分代码硬编码实现调用的情况下，实现代码之间的调用。
2. 具体讲解将分布进行

   //1、首先时创建一个简单的接口和其简单的实现类
   
   package Chapter_5;
   
   public interface Dog {
       void info();
       void run();
   }
   

   package Chapter_5;
   
   public class GunDog implements Dog {
       public  void info(){
           System.out.println("猎狗");
       }
   
       public void run(){
           System.out.println("迅速奔跑");
       }
   }
   

   //2、接下来这个类是实现AOP的关键。将dog对象作为动态代理对象进行处理，并且在执行这个动态代理对象的前后
   //都“插入”了一些操作
   
   package Chapter_5;
   
   
   import java.lang.reflect.InvocationHandler;
   import java.lang.reflect.Method;
   
   public class MyInvoikationHandle implements InvocationHandler {
       private Object target;
       public void setTarget(Object target){
           this.target = target;
       }
   
   //    前面的例子有说到，执行动态代理对象的所有方法都将被代替成执行invoke方法，invoke方法在执行动态代理对象之前
   //    和之后都增加了一些别的操作，即执行DigUtil的两个方法
       public Object invoke(Object proxy, Method method, Object[] args) throws  Exception{
           DogUtil du = new DogUtil();
           du.method1();
           Object result = method.invoke(target, args);
           du.method2();
           return result;
       }
   }
   

   //3、MyProxyFactory的功能是将某个对象进行处理，得到其动态代理对象
   
   package Chapter_5;
   
   import java.lang.reflect.Proxy;
   
   public class MyProxyFactory {
       public  static Object getProxy(Object target) throws  Exception{
           MyInvoikationHandle handle = new MyInvoikationHandle();
           handle.setTarget(target);
           return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                   target.getClass().getInterfaces(),handle);
       }
   }
   

   //测试类
   package Chapter_5;
   
   public class Test {
       public static void main(String args[]) throws Exception{
           Dog target = new GunDog();
           Dog dog = (Dog)MyProxyFactory.getProxy(target);
           dog.info();
           dog.run();
       }
   }
   

    

3. 运行test.class，可以看到

   模拟第一个通用方法
   猎狗
   模拟第二个通用方法
   模拟第一个通用方法
   迅速奔跑
   模拟第二个通用方法

   这是因为在执行GunDog的两个方法的时候，都是通过动态代理的方式在invoke方法中实现的，并且在invoke方法中在执行动态代理对象的相应方法的前后还执行了别的操作。

这是我看李刚编著的《疯狂Java讲义》后总结出来的。