在我另一篇博客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、运行结果：