spring源码学习之【准备】jdk动态代理例子

一：被代理的对象所要实现的接口

 package com.yeepay.testpoxy;

 import java.util.Map;

 /**
  * 被动态代理的接口
  * @author shangxiaofei
  *
  */
 public interface MyCheckPay {
     /**
      * 付钱的接口
      * @param name
      * @param money
      * @return
      */
     public Map<String, String> payMoney(String name,Integer money);
 }

二：被动态代理的实现类

 package com.yeepay.testpoxy;

 import java.util.HashMap;
 import java.util.Map;

 /**
  * 被动态代理的实现类
  * @author shangxiaofei
  *
  */
 public class ShangxiaofeiMyCheckPay implements MyCheckPay{

     @Override
     public Map<String, String> payMoney(String name, Integer money) {
         System.out.println("ShangxiaofeiMyCheckPay.payMoney()========>name=["+name+"],payMoney=["+money+"]");
         Map<String, String> map=new HashMap<String, String>();
         map.put("result",name+"付钱"+money+"元，已经结束");
         return map;
     }

 }

三：动态代理的增强类（代理类）

 package com.yeepay.testpoxy;

 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;

 /**
  * 增加功能的类
  * @author shangxiaofei
  *
  */
 public class HandlerForMyCheckPay implements InvocationHandler{
     /**
      * 被委托的类的引用
      */
     private Object object;

     /**
      * 空构造
      */
     public HandlerForMyCheckPay() {

     }

     /**
      * 有参构造
      * @param object
      */
     public HandlerForMyCheckPay(Object object) {
         this.object = object;
     }

     /**
      * Object proxy:指代我们所代理的那个真实对象,这个对象不能使用，否则会引起栈溢出
      * Method method:　指代的是我们所要调用真实对象的某个方法的Method对象
      * Object[] args:　指代的是调用真实对象某个方法时接受的参数
      */
     @Override
     public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {

         /**
          * 被代理对象调用方法之前调用（aop的前置增强）
          */
         System.out.println("HandlerForMyCheckPay.invoke()=======>【付钱前】向统计系统发送付钱消息");
         if(args!=null&&args.length>0){
             for(int i=0;i<args.length;i++){
                 System.out.println("HandlerForMyCheckPay.invoke()发送消息为===>"+args[i]);
             }
         }

         /**
          * 调用被代理对象的实际的方法
          */
         Object d=method.invoke(this.object, args);

         /**
          * 调用被代理对象的实际的方法之后执行：后置增强
          */
         System.out.println("HandlerForMyCheckPay.invoke()=======>【付钱后】进行计算执行时长");

         return d;
     }

 }

四：代理类的生产工厂

 package com.yeepay.testpoxy;

 import java.lang.reflect.Proxy;

 /**
  * 生产代理者的工厂类
  * @author shangxiaofei
  *
  */
 public class ProxyFactory {

     public static MyCheckPay getMyCheckPay(){

         /**
          * ClassLoader loader:一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
          * Class<?>[] interfaces:　一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
          * InvocationHandler h:一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
          */
         Object object=Proxy.newProxyInstance(ProxyFactory.class.getClassLoader(), new Class[]{MyCheckPay.class},new HandlerForMyCheckPay(new ShangxiaofeiMyCheckPay()));
         return (MyCheckPay) object;
     }

     public static MyCheckPay getMyCheckPay2(){

         /**
          * ClassLoader loader:一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
          * Class<?>[] interfaces:　一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
          * InvocationHandler h:一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
          */
         Object object=Proxy.newProxyInstance(ProxyFactory.class.getClassLoader(),MyCheckPay.class.getInterfaces(),new HandlerForMyCheckPay(new ShangxiaofeiMyCheckPay()));
         return (MyCheckPay) object;
     }
 }

五：测试类

 package com.yeepay.testpoxy;

 import java.util.Map;

 /**
  * 测试动态代理
  * @author shangxiaofei
  *
  */
 public class TestController {

     private MyCheckPay myCheckPay=ProxyFactory.getMyCheckPay();

     public void payMoney(String name,Integer money){
         System.out.println("TestController.payMoney(开始)");
         Map<String, String> map=myCheckPay.payMoney(name, money);
         System.out.println("TestController.payMoney(结束)"+map.get("result"));
     }

     /**
      * TestController.payMoney(开始)
      *HandlerForMyCheckPay.invoke()=======>【付钱前】向统计系统发送付钱消息
      *HandlerForMyCheckPay.invoke()发送消息为===>怪物雷克
      *HandlerForMyCheckPay.invoke()发送消息为===>100
      *ShangxiaofeiMyCheckPay.payMoney()========>name=[怪物雷克],payMoney=[100]
      *HandlerForMyCheckPay.invoke()=======>【付钱后】进行计算执行时长
      *TestController.payMoney(结束)怪物雷克付钱100元，已经结束
      * @param args
      */
     public static void main(String[] args) {
         TestController testController=new TestController();
         testController.payMoney("怪物雷克", 100);
     }

 }