在我另一篇部落格SSM之Spring 02 —— 動态代理、AOP、Spring-MyBatis、聲明式事務中有簡單描述代理模式和AOP原理，當時自己也還是有些沒明白，後面在面試過程中被問到，這裡詳細說明一下。

AOP是什麼就不再說明了，主要解釋下AOP的原理——動态代理。

動态代理

和靜态代理不同，動态代理是動态生成代理對象，克服了靜态代理的問題——不同目标對象都需要寫一個代理類。

動态代理主要有兩種方式：JDK的動态代理和cglib代理。

JDK的動态代理

它是對對象進行代理，底層利用反射機制實作，同時需要我們自定義一個實作了InvocationHandler接口的類，這個接口中的invoke方法就是AOP的本質。

下面我們通過代碼來進行了解。

1、定義好UserDao以及實作類，這是我們常見的方式。

//為了友善就不寫參數了
public interface UserDao {
    boolean addUser();
    boolean deleteUser();
}

public class UserDaoImpl implements UserDao {
    @Override
    public boolean addUser() {
        System.out.println("addUser();");
        return false;
    }

    @Override
    public boolean deleteUser() {
        System.out.println("deleteUser();");
        return true;
    }
}

2、寫一個測試，具體解釋看注解。可以看到Proxy和InvocationHandler都是reflect包下的，說明底層肯定是反射。

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

public class Test {
    public static void main(String[] args) {
      	//建立好目标對象
        UserDao ud = new UserDaoImpl();
      
      	//這個就是我們自定義的一個實作類，裡面invoke方法就是AOP的原理。
      	InvocationHandler ih = new MyInvocationHandler(ud);//将ud作為目标對象傳進去
      
        /*
        		這個方法傳回一個代理對象，我們會在代理對象中做一些其他操作
            newProxyInstance(ClassLoader, interfaces, InvocationHandler)
            1、ClassLoader：目标對象的類加載器，代碼是固定的。
            2、interfaces：目标對象的接口數組，代碼也是固定的，都是通過反射獲得。
            3、InvocationHandler：這是關鍵點，AOP能實作方法的增強就在這個接口裡。需要自己定義。
         */
        Object newProxyInstance = Proxy.newProxyInstance(ud.getClass().getClassLoader(),
                ud.getClass().getInterfaces(), ih);
      
        //執行代理對象被增強後的方法（增強的意思是在原有方法的基礎上添加了其他效果，同時不影響原有業務，同Spring AOP的事務）
        UserDao proxyUserDao = (UserDao)newProxyInstance;
        proxyUserDao.addUser();
        System.out.println("--------------");
        proxyUserDao.deleteUser();
    }
}

3、自定義的實作類，這是實作AOP增強方法的關鍵。

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

public class MyInvocationHandler implements InvocationHandler {
    private Object object;

    public MyInvocationHandler(Object object) {
        this.object = object;
    }

    /**
     *
     * @param proxy 代理對象，就是我們從外部傳進來的，但一般不用這個，會用我們自定義的object成員。
     * @param method 目标對象的方法對象，是JDK傳過來的。
     * @param args 目标對象方法的參數對象。
     * @return 對應于我們目标對象的方法的傳回值
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        String before = "";
        String after = "";
        //這裡通過反射來判斷UserDao的兩個方法，如果不判斷，那麼就會針對目标對象的所有方法進行增強。
        if(method.getName().equals("addUser")){
            before = "前置通知：addUser()方法執行 之前";
            after = "後置通知：addUser()方法執行 之後";
        }
        if(method.getName().equals("deleteUser")){
            before = "前置通知：deleteUser()方法執行 之前";
            after = "後置通知：deleteUser()方法執行 之後";
        }
        //下面這樣就實作了和Spring AOP 一樣的效果：方法的增強，即在方法執行前做一些其他事，且不影響到原有業務。
        System.out.println(before);
        Object result = method.invoke(object, args);//通過反射調用目标對象的方法
        System.out.println(after);
        return result;
    }
}

4、運作結果：