java动态代理

一、学习一个方法

public static Object newProxyInstance(ClassLoader loader,
                                      类<?>[] interfaces,
                                      InvocationHandler h)
                               throws IllegalArgumentException

（1）方法作用：

        在运行时，动态创建一组指定的接口的实现类对象！（在运行时，创 建实现了指定的一组接口的对象）

Object proxyObject = Proxy.newProxyInstance(ClassLoader classLoader, 
                                            Class[] interfaces, 
                                            InvocationHandler h)

 ( 2 )方法的三大参数；

    3. InvocationHandler：代理对象的所有方法(个别不执行，getClass())都会调用InvocationHandler的invoke()方法。

 （3）InvocationHandler

public Object invoke(Object proxy, Method method, Object[] args)

* Object[] args：实参（指方法的参数）！

二、认识两个对象

（1）认识目标对象，目标方法，代理对象

    目标对象：被增强的对象
    代理对象：需要目标对象，然后在目标对象上添加了增强后的对象！
    目标方法：增强的内容

    代理对象 = 目标对象 + 增强

三、实现目的

    完成对服务员对象在不修改源代码的情况下对服务员的服务方法进行前置增强和后置增强！

四、代码

（1）前置增强

package com.winter.proxy;
//前置增强接口
public interface BeforeAdvance {
	public void before();
}

（2）后置增强

package com.winter.proxy;
//后置增强接口
public interface AfterAdvance {
	public void after();
}

（3）服务员接口

package com.winter.proxy;
public interface waiter {
    //服务员服务
    public void service();
}

（4）服务员实现类

package com.winter.proxy;

import cn.winter.proxy.Waiter;

public class WomanWaiter implements Waiter {

	@Override
	public void server() {
		System.out.println("欢迎光临！");
	}

}

（5）动态代理工厂

package com.winter.proxy;

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

public class FactoryBean {
	private BeforeAdvance beforeAdvance;
	private AfterAdvance afterAdvance;
	private Object target;
	//创建代理
	public Object createProxy(){
		//获取当前的类加载器
		ClassLoader loader = this.getClass().getClassLoader();
		//得到目标对象的一组接口
		Class<?>[] interfaces = target.getClass().getInterfaces();
		//创建InvocationHandler的实现类
		InvocationHandler h = new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				//执行前置增强
				if(beforeAdvance != null){
					beforeAdvance.before();
				}
				//通过反射回调被代理对象的目标方法
				Object result = method.invoke(target, args);
				//执行后置增强
				if(afterAdvance != null) {
					afterAdvance.after();
				}
				return result;
			}
		};
		//创建并返回一个动态代理
		Object newProxyInstance = Proxy.newProxyInstance(loader, interfaces, h);
		return newProxyInstance;
	}

	public AfterAdvance getAfterAdvance() {
		return afterAdvance;
	}

	public void setAfterAdvance(AfterAdvance afterAdvance) {
		this.afterAdvance = afterAdvance;
	}

	public BeforeAdvance getBeforeAdvance() {
		return beforeAdvance;
	}
	public void setBeforeAdvance(BeforeAdvance beforeAdvance) {
		this.beforeAdvance = beforeAdvance;
	}
	public Object getTarget() {
		return target;
	}
	public void setTarget(Object target) {
		this.target = target;
	}
	
	
}

（6）测试类

package com.winter.proxy;

import org.junit.Test;

import cn.winter.proxy.Waiter;

public class ProxTest {
	@Test
	public void waiterTest(){
		//创建实例工厂
		FactoryBean factoryBean = new FactoryBean();
		//传递目标对象
		factoryBean.setTarget(new WomanWaiter());
		//传递前置增强的实例
		factoryBean.setBeforeAdvance(new BeforeAdvance() {
			
			@Override
			public void before() {
				System.out.println("您好：");
			}
		});
		//传递后置增强的实例
		factoryBean.setAfterAdvance(new AfterAdvance() {
			
			@Override
			public void after() {
				System.out.println("慢走！");
			}
		});
		Waiter waiter = (Waiter)factoryBean.createProxy();
		waiter.server();
	}
}

（7）测试结果

您好：
欢迎光临！
慢走！

五、总结

动态代理作为Aop（Aspect Orient Program，面向切面编程）的底层原理，使用动态代理可以非常灵活的实现解耦，通过实现动态代理，程序可以在不修改源代码的情况下对目标方法的前后实现增强。