最近整理一些算法的东西，想着得要给每个算法写至少一个测试，要有方法计算运行时间，然后写着写着发现好多功能虽然封装了一边，但是还是有很多代码免不了要重用。比如说算时间的方法，总要在算法方法执行前加行代码，在算法执行后加一行代码。
  忽然就想到了我特么可以用代理类处理啊，这特么不是和打log一样么，所以这里就简单记录一下JDK的动态代理和cglib的动态代理的使用形式。并且这里有个不错的博客：代理模式原理及实例讲解 (小声比比，IBM的博客感觉质量都很高，但是他家的文档就有点emmmmmmmm)

1：JDK动态代理。

首先JDK提供的动态代理需要提供接口以及实现该接口的实现类。

public interface GeneralSort {
    void sort(Integer[] a);
}
public class QuickSort implements GeneralSort{
    //测试
    public static void main(String[] args) {
        GeneralSort generalSortProxy = (GeneralSort)new DynamicProxyTimeCaculateHandler(new QuickSort()).bind();
        generalSortProxy.sort(new int[]{5,4,3,2,1});
    }
    //数组实现
    public  void sort(Integer[] a) {
        quickSort(a, 0, a.length - 1);
    }
    private  void quickSort(Integer[] a,Integer low,Integer high) {
        if (high<=low) {
            return;
        }
        Integer partition = partition(a, low, high);
        quickSort(a, low, partition-1);
        quickSort(a, partition+1, high);
    }
    //第二个循环的判断可删除，因为j==lowd的时候必定等于跳出循环。
    private  Integer partition(Integer[] a,Integer low,Integer high) {
        Integer i=low,j=high+1;
        Integer value  = a[low];
        while(true) {
            while(a[++i]<value) {
                if (i==high) {
                    break;
                }
            }
            while(a[--j]>value) {
                if (j==low) {
                    break;
                }
            }
            if (i>=j) {
                break;
            }
            Integer temp = a[i];
            a[i] = a[j];
            a[j] =temp;
        }
        Integer temp = a[low];
        a[low] = a[j];
        a[j] = temp;
        return j;
    }
}

然后创建一个实现InvocationHandler的代理类。

public class DynamicProxyTimeCaculateHandler implements InvocationHandler {
    //这个就是需要被代理的类了
    private Object object;
    
    public DynamicProxyTimeCaculateHandler(final Object object) {
        this.object = object;   
    }
     //这里的method是接口定义的方法，args是方法传入的参数
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Integer[] arg = (Integer[])args[0];
        for(Integer i:arg) {
            System.out.print(i+" ");
        }System.out.println();
        Long begainTime = System.nanoTime();
        Object result = method.invoke(object, args);
        Long endTime = System.nanoTime();
        for(Integer i:arg) {
            System.out.print(i+" ");
        }System.out.println();
        System.out.println("运行时间 :"+(endTime-begainTime)+"ns");
        return result;
    }
    //将需要被代理的类进行绑定并且返回代理类
    public Object bind() {
        return (GeneralSort) Proxy.newProxyInstance(object.getClass().getClassLoader(),
                object.getClass().getInterfaces(),
                this);
    }
}

最后执行只需要运行QuickSort中main方法即可。

2.cglib动态代理

cglib的动态代理不需要被代理的类实现某些接口，原理是对指定的类生成一个子类，并覆盖其中方法实现代理，所以final修饰的类是无法被代理的。拦截器定义如下

public class TimeCaculateInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object arg0, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        printArgs(args);
        Long begainTime = System.nanoTime();
        Object proxyObject = methodProxy.invokeSuper(arg0, args);
        Long endTime = System.nanoTime();
        System.out.println("运行时间 :"+(endTime-begainTime)+"ns");
        return proxyObject;
    }

    private void printArgs(Object[] args) {
        Class pa = args[0].getClass();

        if (pa.isArray()) {
            printrArray((Integer[]) args[0]);
        }
        if (args[0] instanceof ListNode) {
            printListNode((ListNode) args[0]);
        }
    }
}

拦截器的使用如下，这里吐槽一下java，用反射获得的永远是Object类型的实例，意味着每次都需要向下强制转换，就不能一步到位太特么蠢了。老子可终于知道为什么之前用这用那儿的框架的方法一个个要强制装换...

public class ProxyUtil {
    public static Object excuteListSort(String className) throws Exception {
        Class<?> class1 = Class.forName(className);
        TimeCaculateInterceptor timeCaculateInterceptor = new TimeCaculateInterceptor();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(class1);
        enhancer.setCallback(timeCaculateInterceptor);
        return enhancer.create();
    }
}
public class QuickSort implements GeneralSort{
    private static String className = QuickSort.class.getName();
    
    public static void main(String[] args) {
    
        try {
        QuickSort quickSort = (QuickSort)ProxyUtil.excuteListSort(className);
        printListNode(quickSort.sortList(generateRandomListNode(10)));
        } catch (Exception e) {
        }
        
    }
}

 单纯的只看两个的使用形式，感觉JDK的动态代理就不够灵活，cglib明显好得多。然后就是cglib局限在于不能用于final类，并且效率低于JDK的动态代理。
 最后这里有个疑问，这些代理类都是需要强制转换的，那么像Spring的aspectj这样，如果我不想将类型信息作为hardcode写死，就如上述的ProxyUtil.excuteListSort中我想直接返回一个QuickSort，那么我要如何动态的生成一个能执行的代理类呢...