动态代理(简单实例）

动态代理与静态代理的区别。
（1）Proxy类的代码被固定下来，不会因为业务的逐渐庞大而庞大；
（2）可以实现AOP编程，这是静态代理无法实现的；
（3）解耦，如果用在web业务下，可以实现数据层和业务层的分离。
（4）动态代理的优势就是实现无侵入式的代码扩展。
静态代理这个模式本身有个大问题，如果类方法数量越来越多的时候，代理类的代码量是十分庞大的。所以引入动态代理来解决此类问题

Java提供的动态代理位于java.lang.reflect包下面，一般来说，涉及到了这两个东东：

1、Interface InvocationHandler：这个是一个接口，仅仅定义了一个方法。

在创建代理对象的时候，你必须要提供一个 InvocationHandler，由这个Handler处理器调用invoke（）方法来接替代理对象做实际工作。
接下来了解下invoke方法：

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

共有三个参数，分别介绍下：

1 proxy，该参数是代理对象，即Proxy.newProxyInstance()
2 method，该参数是代理的方法
3 代理方法中接受的参数

2.java.lang.reflect.Proxy：
该类用于动态生成代理类，只需传入目标接口、目标接口的类加载器以及InvocationHandler便可为目标接口生成代理类及代理对象。

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

动态代理类是这样的一个class，它是在程序运行的时候去创建一个class，这个class有一个特点，
就是你必须要提供一组interface给它，这样做的目的在于创建的代理类就会去实现你提供的这些interface，
那么这个代理类就宣告它实现了这些interface接口。这个动态代理其实就是一个Proxy，但是它不会替你做实际性的工作，
在创建实例对象的时候，你必须要提供一个Handler，由这个Handler处理器来接替你做实际工作。

编写动态代理类的步骤

• 创建需要被代理的类及接口。

 public interface Person {
	void eat();
}

public class RealPerson implements Person{

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("RealPerson.eat()...");
	}

}

• 创建一个handler

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
//Handler，由这个Handler处理器来接替proxy做实际工作。
public class PersonHandler implements InvocationHandler{
	public Object realObject=null;
	
	public PersonHandler(Object realObject) {
		
		this.realObject = realObject;
	}

	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("吃饭前要洗手。。。。");
		method.invoke(realObject, args);
		System.out.println("吃饭后要洗碗。。。。");
		return null;
	}

}

• 通过Proxy类的静态方法newInstance()方法创建一个代理类。
  （在创建动态代理类的时候，必须要实现InvocationHandler接口）
  在通过代理对象去调用方法。

import java.lang.reflect.Proxy;

public class Test {
	public static void main(String[] args) {
		Person realPerson=new RealPerson();
		//创建处理器，用户代替proxy完成实际工作。
		PersonHandler handler=new PersonHandler(new RealPerson());
		//		Person proxyPerson=(Person) Proxy.newProxyInstance(realPerson.getClass().getClassLoader(),
//				realPerson.getClass().getInterfaces(), handler);
		//创建动态代理类
		Person proxyPerson=(Person) Proxy.newProxyInstance(realPerson.getClass().getClassLoader(),
				new Class[] {Person.class}, handler);
				//通过代理对象去调用方法
		proxyPerson.eat();
	}
}