jdk动态代理与cglib动态代理

最近学习springaop的知识，看到了其中的aop的代理的实现，现在总结一下,aop的代理其实就是用jdk的动态代理或者cglib动态代理来实现的，所谓的代理就是来给某个方法，在执行这个方法之前多一些事，在执行这个方法之后做一些事，下面就分析一下jdk动态代理与cglib动态代理：
jdk动态代理
jdk动态代理需要4样东西，1.目标对象，2.织入类（用于增强）,3.代理类，4、接口，下面写一个服务员问好的例子

//目标类需要的接口
public interface IWaiter {
    public void sayHello(String name);
}

//目标类实现接口
public class Waiter implements IWaiter{
    public void sayHello(String name) {
        // TODO Auto-generated method stub
        System.out.println("早上好，" + name);
    }
}

//代理类，用来增强的，需要实现InvocationHandler接口，并重写其方法
public class WaveInvocationHander implements InvocationHandler {

    //定义一个要传入的对象，不知道类型用Object
    private Object target;
    //利用构造函数初始化这个对象
    public WaveInvocationHander(){

    }
    public WaveInvocationHander(Object target){
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] params)
            throws Throwable {
        //执行这个方法开始前做的事，比如说：服务员下楼了
        System.out.println("黑猫下楼了！");
        //执行我们原本要执行的方法
        Object obj = method.invoke(target, params);
        //执行方法后在做一件事，比如现在服务员要说一句话
        System.out.println("黑猫说：请问您需要什么帮助吗？");

        //返回增强后的对象
        return obj;
    }
}

//测试下是否可用
public class Test {

    public static void main(String[] args) {
        //定义目标类的对象
        IWaiter iwaiter = new Waiter();
        //传入到我们的增强类中即织入进去
        WaveInvocationHander hander = new WaveInvocationHander(iwaiter);
        //调用代理类Proxy中的newProxyInstance进行增强一下
        /*
         * Proxy.newProxyInstance(loader, interfaces, h)方法
         * loader代表反射得到的getClassLoader
         * interface代表反射得到目标类的接口（所以我们要定义一个接口涩,h代表我们的织入类即上面的hander）
         * */
        IWaiter waiter = (IWaiter)Proxy.newProxyInstance(Waiter.class.getClassLoader(),
                Waiter.class.getInterfaces(), hander);
        //现在来调用目标类的方法，看下对不对
        waiter.sayHello("来访者");
    }
}

欧了，这就是jdk动态代理实现的方式，

CGLIB动态代理
CGLIB动态代理需要两个东西：1、目标对象，2、代理类，也写一个例子来说明

//目标类
public class Waiter {
    public void sayHello(String name){
        System.out.println("黑猫说：早上好，" + name);
    }
}

//代理类，要继承MethodInterceptor接口
public class CglibProxy implements MethodInterceptor {
    //要用到Enhancer，这个单词表面意思就是增强的意思，其实就是增强我们传入的对象
    private Enhancer enhancer = new Enhancer();
    //代理类方法，吧你需要代理的对象字节码传进去,这个是固定的写法
    public Object getProxy(Class clz){
        enhancer.setSuperclass(clz);
        enhancer.setCallback(this);
        return enhancer.create();//返回制作的代理对象
    }
    //重写的方法，在上面盗用Enhancer时，会自动用这个方法来增强
    @Override
    public Object intercept(Object obj, Method method, Object[] params,
            MethodProxy proxy) throws Throwable {
        //执行方法前做一些事
        System.out.println("黑猫下楼了");
        //执行代理类调用的方法
        Object result = proxy.invokeSuper(obj, params);
        //执行方法后做一些事
        System.out.println("黑猫说：请问您需要什么帮助吗？");
        return null;
    }   
}

//写个测试类测试下，输出正确
public class Test {

    public static void main(String[] args) {
        //先弄个我们代理类的对象出来
        CglibProxy proxy = new CglibProxy();
        //调用我们写好的getProxy方法来进行增强,传入我们目标类的class字节码
        Waiter waiter = (Waiter)proxy.getProxy(Waiter.class);
        //调用目标类的方法
        waiter.sayHello("小明");
    }
}

可以看出jdk动态代理和cglib动态代理都是用一个类来代理的，但是cglib在编译时就要增强，但是在运行时不需要，所以在运行时速度较快，而jdk动态代理正好相反。后面在总结下简易的aop代理方式