spring 的AOP 實現 可以使用jdk的動態代理，也可以使用cglib的動態代理 先說下兩者區別：
靜態代理：代理之前就已經知道了代理者和被代理者
動態代理：代理之前並不清楚，在執行時使用反射機制動態生成代理類的位元組碼 無需我們手動編寫它的原始碼
jdk動態代理：java.lang.reflect 包中的Proxy類，InvocationHandler 介面提供了生成動態代理類的能力。它必須有被代理物件的介面和實現類，ciglib不需要介面，簡單的說 jkd動態代理針對介面，而cglib動態代理針對的是類 比JDK快，但載入cglib的時間比jdk反射的時間長，開發的過程中，如果是反覆動態生成新的代理類推薦用 JDK 自身的反射，反之用 cglib。

spring AOP的實現 既可以編寫介面使用jdk動態代理實現，也可以使用cglib來進行實現

對於hibernate使用cglib延遲載入，在load（)的時候，cglib會生成一個數據庫實體類的代理類，此代理類開始的時候裡面的屬性值是null，只有當真正請求資料,如user.getName(）的時候，這個代理類就會去資料庫裡查詢出具體的值(通過cglib的回撥機制)，然後載入到代理類對應的屬性中，最後返回給給呼叫者。

以下為一個轉載的例項：

/**
*使用類
*/
public class MyClass { 
public void method() { 
        System.out.println("MyClass.method()"
 
); 
    } 
public void method2() { 
        System.out.println("MyClass.method2()"); 
    } 
}
/**
*使用代理
*/
import java.lang.reflect.Method; 
import net.sf.cglib.proxy.Enhancer; 
import net.sf.cglib.proxy.MethodProxy; 
import net.sf.cglib.proxy.MethodInterceptor; 
public class Main { 
public static void
 
 main(String[] args) { 
        Enhancer enhancer = new Enhancer(); 
//在這代理了 
        enhancer.setSuperclass(MyClass.class); 
        enhancer.setCallback( new MethodInterceptorImpl() ); 
// 創造 代理 （動態擴充套件了MyClass類） 
        MyClass my = (MyClass)enhancer.create(); 
        my.method(); 
    } 
private static class MethodInterceptorImpl implements MethodInterceptor { 
public Object intercept(Object obj,  
                                Method method,  
                                Object[] args,  
                                MethodProxy proxy) throws Throwable { 
            System.out.println(method); 
            proxy.invokeSuper(obj, args); 
return null; 
        } 
    } 
}
/**
*新增方法過濾
*/
import java.lang.reflect.Method; 
import net.sf.cglib.proxy.Enhancer; 
import net.sf.cglib.proxy.MethodProxy; 
import net.sf.cglib.proxy.MethodInterceptor; 
import net.sf.cglib.proxy.NoOp; 
import net.sf.cglib.proxy.Callback; 
import net.sf.cglib.proxy.CallbackFilter; 
public class Main2 { 
public static void main(String[] args) { 
        Callback[] callbacks = 
new Callback[] { new MethodInterceptorImpl(),  NoOp.INSTANCE }; 
        Enhancer enhancer = new Enhancer(); 
        enhancer.setSuperclass(MyClass.class); 
        enhancer.setCallbacks( callbacks ); 
//新增 方法過濾器  返回1為不執行 2 為執行 
        enhancer.setCallbackFilter( new CallbackFilterImpl() ); 
        MyClass my = (MyClass)enhancer.create(); 
        my.method(); 
        my.method2(); 
    } 
private static class CallbackFilterImpl implements CallbackFilter { 
public int accept(Method method) { 
if ( method.getName().equals("method2") ) { 
return 1; 
            } else { 
return 0; 
            } 
        } 
    } 
private static class MethodInterceptorImpl implements MethodInterceptor { 
public Object intercept(Object obj,  
                                Method method,  
                                Object[] args,  
                                MethodProxy proxy) throws Throwable { 
            System.out.println(method); 
return proxy.invokeSuper(obj, args); 
        } 
    } 
}

下面貼下在imooc上自己寫的幾個小例子：
具體可點選：

jdk動態代理的簡單實現：

package proxy.dynamicProxy.jdk;

import java.util.Random;

/**
 * 需要代理的具體類繼承介面
 */
public class Car implements Moveable {

    @Override
    public void move() {
        //實現開車
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽車行駛中....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
########################################
package proxy.dynamicProxy.jdk;

/**
 *jdk實現動態代理模式，必須使用介面
 */
public interface Moveable {
    void move();
}
########################################
package proxy.dynamicProxy.jdk;


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

/**
 * 代理者，必須整合InvocationHandler 實現invoke方法
 */
public class TimeHandler implements InvocationHandler {

    public TimeHandler(Object target) {
        super();
        this.target = target;
    }

    //代理物件
    private Object target;

    /*
     * 只能代理實現了介面的類，沒有實現介面的類不能實現JDK動態代理
     * 引數：
     * proxy  被代理物件
     * method  被代理物件的方法
     * args 方法的引數
     * 
     * 返回值：
     * Object  方法的返回值
     * */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        long starttime = System.currentTimeMillis();
        System.out.println("汽車開始行駛....");
        method.invoke(target);
        long endtime = System.currentTimeMillis();
        System.out.println("汽車結束行駛....  汽車行駛時間：" 
                + (endtime - starttime) + "毫秒！");
        return null;
    }

}
#####################################
package proxy.dynamicProxy.jdk;

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


public class Test {

    /**
     * JDK動態代理測試類
     */
    public static void main(String[] args) {
        Car car = new Car();
        InvocationHandler h = new TimeHandler(car);
        Class<?> cls = car.getClass();
        /**
         * loader  類載入器
         * interfaces  實現介面
         * h InvocationHandler 呼叫處理者
         */
        Moveable m = (Moveable)Proxy.newProxyInstance(cls.getClassLoader(),
                                                cls.getInterfaces(), h);
        m.move();
    }

}

cglib動態代理簡單實現：

package proxy.dynamicProxy.cglib;

public class Train {

    public void move(){
        System.out.println("火車行駛中...");
    }
}
##########################################
package proxy.dynamicProxy.cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibProxy implements MethodInterceptor {

    private Enhancer enhancer = new Enhancer();//例項化強化劑物件

    public Object getProxy(Class clazz){
        //設定建立子類的類
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);

        return enhancer.create();
    }

    /**
     * 針對類來實現代理，先為目標類生產一個子類，通過方法攔截技術攔截所有父類方法的呼叫
     * 攔截所有目標類（父類）方法的呼叫
     * obj  目標類的例項
     * m   目標方法的反射物件
     * args  方法的引數
     * proxy代理類的例項
     */
    @Override
    public Object intercept(Object obj, Method m, Object[] args,
            MethodProxy proxy) throws Throwable {
        System.out.println("日誌開始...");
        //代理類呼叫父類的方法
        proxy.invokeSuper(obj, args);
        System.out.println("日誌結束...");
        return null;
    }

}
##################################
package proxy.dynamicProxy.cglib;

import proxy.dynamicProxy.cglib.CglibProxy;

public class Client {

    /**
     * @param args
     */
    public static void main(String[] args) {

        CglibProxy proxy = new CglibProxy();
        Train t = (Train)proxy.getProxy(Train.class);
        t.move();
    }

}