1、动态代理的概念
动态代理是在程序运行时，动态的创建一个实现了目标对象所实现的所有接口的增强对象。通过Proxy类实现。
（增强对象=被增强对象+增强）

图片.png

2、Proxy动态生成代理对象的简单实现

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Demo {

public void fun1() {
    //通过本类可以获取加载本类的类加载器，使用这个类加载器来加载我们要创建的动态对象
    ClassLoader loader = this.getClass().getClassLoader();
    InvocationHandler h = new InvocationHandler() {

        @Override
        public Object invoke(Object proxy, Method method, Object[] objects)
                throws Throwable {
            return null;
        }
    };
    //获得我们想要的动态对象
    Object object = Proxy.newProxyInstance(loader, new Class[] { A.class, B.class }, h);
}

}
//定义两个接口
interface A {
public void a();
}

interface B {
public void b();
}

3、创建动态对象时的三大参数
a.ClassLoader：类加载器，所有的class文件要加载到JVM的内存中成为Class对象都需要类加载器将其加载到内存中。
b.interfaces：产生的代理对象需要实现的所有的接口数组，即2代码中的new Class[] { A.class, B.class }
c.InvocationHandler：调用处理器

4、InvocationHandler（调用处理器的invoke方法）
invoke的三个参数：
a.proxy：调用接口方法的对象，生成的代理对象
b.method：代理对象调用的方法
c.objects：代理对象调用方法时传递过来的参数
在代理对象每次调用接口中的方法时都会执行invoke方法。

5、代理工程的实现
a.前置增强接口

/**
 * 前置增强
 * @author John
 *
 */
public interface BeforeAdvice {
    //前置增强方法
    public void before();
}

b.后置增强接口

/**
 * 后置增强
 * @author John
 *
 */
public interface AfterAdvice {
    //后置增强方法
    public void after();
}

c.目标对象接口

/**
 * 目标对象
 * @author John
 *
 */
public interface Target {
    //目标方法
    public void targetMethod();
}

d.代理工程类

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

/**
 * 代理工厂
 * @author John
 *
 */
public class ProxyFactory {

private Object targetObject;// 目标对象
private BeforeAdvice beforeAdvice;// 前置增强
private AfterAdvice afterAdvice;// 后置增强

/**
 * 生成代理对象
 * 
 * @return 代理对象
 */
public Object createProxy() {
    // 给出三大参数
    ClassLoader loader = this.getClass().getClassLoader();
    Class[] interfaces = targetObject.getClass().getInterfaces();
    InvocationHandler h = new InvocationHandler() {

        @Override
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            // 如果前置增强不为空，执行前置增强
            if (beforeAdvice != null) {
                beforeAdvice.before();
            }
            // 执行目标方法
            Object result = method.invoke(targetObject, args);
            // 如果后置增强不为空，执行后置增强
            if (afterAdvice != null) {
                afterAdvice.after();
            }
            // 返回目标方法执行结果
            return result;
        }
    };
    Object object = Proxy.newProxyInstance(loader, interfaces, h);
    return object;
}

/**
 * 无参构造方法
 */
public ProxyFactory() {
    super();
}

/**
 * 有参构造方法
 * 
 * @param targetObject
 *            目标对象
 * @param beforeAdvice
 *            前置增强
 * @param afterAdvice
 *            后置增强
 */
public ProxyFactory(Object targetObject, BeforeAdvice beforeAdvice,
        AfterAdvice afterAdvice) {
    super();
    this.targetObject = targetObject;
    this.beforeAdvice = beforeAdvice;
    this.afterAdvice = afterAdvice;
}

public Object getTargetObject() {
    return targetObject;
}

public void setTargetObject(Object targetObject) {
    this.targetObject = targetObject;
}

public BeforeAdvice getBeforeAdvice() {
    return beforeAdvice;
}

public void setBeforeAdvice(BeforeAdvice beforeAdvice) {
    this.beforeAdvice = beforeAdvice;
}

public AfterAdvice getAfterAdvice() {
    return afterAdvice;
}

public void setAfterAdvice(AfterAdvice afterAdvice) {
    this.afterAdvice = afterAdvice;
}

}

e.测试代码

import org.junit.Test;

public class Test2 {

@Test
public void fun1() {

    ProxyFactory factory = new ProxyFactory(new Target() {

        @Override
        public void targetMethod() {
            System.out.println("我是目标对象的实现类");
        }
    }, new BeforeAdvice() {

        @Override
        public void before() {
            System.out.println("我是前置增强");
        }
    }, new AfterAdvice() {

        @Override
        public void after() {
            System.out.println("我是后置增强");
        }
    });
    Target targetProxy = (Target) factory.createProxy();
    targetProxy.targetMethod();
}

}

f.运行结果

图片.png

（如有错误，欢迎指正）