1 public interface ICalFab {
 2     int calFaByLoop(int n);
 3     int calFabByRecursion(int n); 
 4 }
 5 
 6 class CalFabImp implements ICalFab{
 7     @Override
 8     public int calFaByLoop(int n) {
 9         int n1=1,n2= 1,n3=0;
10         for (int i = 3; i < n; i++) {
11             n3=n1+n2;
12             n1=n2;
13             n2=n3;
14         }
15         return n3;
16     }
17     @Override
18     public int calFabByRecursion(int n) {
19         if(n==1||n==2) return 1;
20         return calFabByRecursion(n-1)+calFabByRecursion(n-2);
21         
22     }
23     
24 }
25 /**
26  * 代理类往往依赖于被代理类
27  * @author 
28  */
29 class CalFabImplProxy implements ICalFab{
30     private ICalFab calFab;
31     public CalFabImplProxy() {}
32     public CalFabImplProxy(ICalFab calFab) {
33         this.calFab =calFab;
34     }
35     @Override
36     public int calFaByLoop(int n) {
37         long start = System.currentTimeMillis();
38         int result = calFab.calFaByLoop(n);
39         long end = System.currentTimeMillis();
40         System.out.println(end-start+"ms");
41         return result;
42     }
43 
44     @Override
45     public int calFabByRecursion(int n) {
46         long start = System.currentTimeMillis();
47         int result = calFab.calFabByRecursion(n); 
48         long end = System.currentTimeMillis();
49         System.out.println(end-start+"ms");
50         return result;
51     }
52     
53 }

 1 public class Invoker {
 2     public static void main(String[] args) {
 3 //        ICalFab imp = new CalFabImp();
 4 //        System.out.println(imp.calFabByRecursion(10));;
 5 //        imp.calFaByLoop(10); 
 6         //-- 构造被代理对象
 7         ICalFab imp = new CalFabImp();
 8         //-- 构造代理对象
 9         CalFabImplProxy proxy = new CalFabImplProxy(imp);
10         //-- 调用代理对象的业务方法：
11         proxy.calFabByRecursion(50);
12         proxy.calFaByLoop(50);
13     }
14 }

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

/**
 * 动态代理模式：实现框架底层的核心
 * (1) 构建InvocationHandler对象
 * (2) 构建动态代理对象（利用被代理对象和InvocationHandler对象）
 * @author 张泽
 */
public class DynamicProxyDemo01 {
    public static void main(String[] args) {
        //-- 1. 构建被代理对象
        ICalFab calFab = new CalFabImp();
        //-- 2. 构造InvocationHandler对象
        CalFabInvocationHandler invocationHandler = 
                new CalFabInvocationHandler(calFab); 
        //-- 3.构建动态代理对象
        //-- arg0 : 传被代理对象的类加载器对象
        //-- arg1 : 传入被代理对象的所实现的接口
        //-- arg3 : 传入InvocationHandler对象
        ICalFab dynamicProxy = (ICalFab)Proxy.newProxyInstance(
                calFab.getClass().getClassLoader(),
                calFab.getClass().getInterfaces(),
                invocationHandler);
        //-- 4. 利用代理对象调用业务方法
        dynamicProxy.calFaByLoop(40);
        dynamicProxy.calFabByRecursion(40);
    }
}


//-- 编写InvocationHandler类要实现InvocationHandler接口
class CalFabInvocationHandler implements InvocationHandler{
    private Object target;    //-- 被代理对象
    
    public CalFabInvocationHandler() {}
    public CalFabInvocationHandler(Object target) {
        this.target = target;
    }
    /**
     * @param proxy 代理对象，这个对象是在程序运行的过程中动态创建出来的
     * @param method 调用的方法
     * @param args 方法的参数
     * @return
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) 
        throws Throwable {
        //-- 1. 业务代码前切入代码
        long start = System.currentTimeMillis();
        //-- 2. 业务代码
        Object result = method.invoke(target, args);//-- 调用被代理类的业务方法
        //-- 3. 业务代码后切入代码
        long end = System.currentTimeMillis();
        System.out.println((end - start)+"ms");
        return result;
    }
    
}