动态代理

假如有一个Dog类，该类有eat()和sleep()方法；由该类创建了一个dog对象，现在有一个需求，想知道sleep执行了多长时间，该如何实现这个需求呢？
可以使用动态代理来实现这个需求。
关于动态代理的两个重要的类:
1.Proxy：构造动态代理对象的方法Proxy：构造动态代理对象的方法
public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
                               throws IllegalArgumentException
loader - 定义代理类的类加载器
interfaces - 代理类要实现的接口列表
h - 指派方法调用的调用处理程序

2.InvocationHandler:只有一个invoke方法：
Object invoke(Object proxy,
 Method method,
 Object[] args)
 throws Throwable
proxy - 在其上调用方法的代理实例
method - 对应于在代理实例上调用的接口方法的 Method 实例。
args - 包含传入代理实例上方法调用的参数值的对象数组.


为了实现计算dog的sleep时间，需要抽象出一个Animal接口，代码为：
Animal.java

代码为：

package com.oterman.proxy;

public interface Animal {
	public void eat();
	public void sleep();
}

Dog类实现Animal接口：
Dog.java
代码为：
package com.oterman.proxy;

public class Dog implements Animal {

	@Override
	public void eat() {
		System.out.println("狗狗正在吃东西。。");
	}

	@Override
	public void sleep() {
		System.out.println("狗狗正在睡觉觉。。");
	}

}

封装了自己需求的Advice接口:
Advice.java

Advice.java
package com.oterman.proxy;

import java.lang.reflect.Method;

public interface Advice {

	void beforeMethod(Method method);

	void afterMethod(Method method);

}

MyAdvice.java
package com.oterman.proxy;

import java.lang.reflect.Method;

public class MyAdvice implements Advice {
	long beginTime=0;
	long endTime=0;
	@Override
	public void afterMethod(Method method) {
		endTime=System.currentTimeMillis();
		System.out.println(method.getName()+"方法执行后。。共睡了："+(endTime-beginTime)/1000+"秒");
	}

	@Override
	public void beforeMethod(Method method) {
		beginTime=System.currentTimeMillis();	
		System.out.println(method.getName()+"方法执行前。。。");
	}

}

抽象一个返回某个实例target的代理对象的方法：

package com.oterman.proxy;

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

public class ProxyDemo {
	
	/**
	 * 获取某个target对象的代理对象，并加入自己想要操作的代码，我们称之为advice；
	 * 
	 * @param target  要去代理的对象；
	 * @param advice  封装了自己需求的对象；
	 * @return  target的代理对象；
	 */
	public static Object getProxy(final Object target,final Advice advice){
		return Proxy.newProxyInstance(target.getClass().getClassLoader(),//传入类加载器
				target.getClass().getInterfaces(),//获取target所实现的接口
				new InvocationHandler(){//匿名内部类
					@Override
					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {
						
						if(method.getName().equals("sleep")){//如果调用的方法是sleep方法；
							advice.beforeMethod(method);//调用真正的方法前，执行一些操作
							Object retValue=method.invoke(target, args);
							advice.afterMethod(method);//调用方法后，执行一些操作。
							return retValue;
						}else{//调用的是其他方法
							Object retValue=method.invoke(target, args);
							return retValue;
						}
						
					}
			
		});
		
	}
	//演示代码
	public static void main(String[] args) {
		Animal dog=new Dog();
		Advice advice=new MyAdvice();
		Animal proxyDog=(Animal)getProxy(dog, advice);
		
		proxyDog.eat();
		proxyDog.sleep();
		/*	每次调用proxyDog对象的方法，都会去执行invoke方法，因此可以在invoke方法里对方法的执行实现控制，如如果调用的是sleep方法，那么就加入自己的一些想法，是其他方法则放行，相当于起到了过滤器的左右，这比过滤器实现了更细微程度的控制。
		*/
	}

}