JDK动态代理

注意在使用JDK提供的动态代理要求我们的目标对象必须实现接口。我们可以通过调用java.lang.reflect.Proxy的静态方法

publicstaticObjectnewProxyInstance(ClassLoaderloader,Class<?>[]interfaces,InvocationHandlerh)

loader是类装载器
interfaces是目标对象实现的一系列接口
h是一个实现 InvocationHandler 接口的类 , 我们对代理对象的所有操作都经过它处理

它等价于

Proxy.getProxyClass(loader,interfaces).getConstructor(new Class[]{InvocationHandler.class}). newInstance(newObject[]{handler});

可以创建动态代理，它需要一个类加载器(你通常可以从已经被加载的对象中获取器类加载器，然后传递给它),一个你希望该代理实现的接口列表，以及一个实现了InvacationHandler接口的调用处理器。动态代理可以将所有调用都重定向到调用处理器，因此会向调用处理器的构造器传递一个实际对象的引用，从而使得调用处理器在执行其中介任务时，可以将请求转发。下面介绍一下调用处理器：

InvocationHandler:

Object invoke ( Object proxy,

Method method,

Object []args)

throws Throwable

在代理实例上处理方法调用并返回结果 .其中 proxy 表示在其上调用方法的代理实例。 method -对应于在代理实例上调用的接口方法的 Method 实例。 args -包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null 。从代理实例的方法调用返回的值。

下面我们举例来实现JDK的动态代理：

首先我们创建一个目标对象要实现的接口：

publicinterfaceInterface{
voiddoSomething();
voidsomethingElse(Stringarg);
}

public interface Interface {
	void doSomething();
	void somethingElse(String arg);
}

其次我们在创建目标类：

packagecom.demo;

 publicclassRealObjectimplementsInterface{

@Override
publicvoiddoSomething(){
System.out.println("doSomething");
}

@Override
publicvoidsomethingElse(Stringarg){
System.out.println("somethingElse:"+arg);

}

}

package com.demo;

public class RealObject implements Interface{

	@Override
	public void doSomething() {
		System.out.println("doSomething");
	}

	@Override
	public void somethingElse(String arg) {
		System.out.println("somethingElse: "+arg);
		
	}
	
}

接着我们就可以实现简单的动态代理了：

packagecom.demo;

 importjava.lang.reflect.InvocationHandler;
 importjava.lang.reflect.Method;
 importjava.lang.reflect.Proxy;
 importjava.text.SimpleDateFormat;
 importjava.util.Date;

 publicclassSimpleDynamicProxy{
publicstaticvoidconsumer(Interfaceiterface){
iterface.doSomething();
iterface.somethingElse("imaingecup");
}
publicstaticvoidmain(String[]args)throwsException{
RealObjectreal=newRealObject();
consumer(real);
//通过调用静态方法Proxy.newProxyInstance()可以创建动态代理，它需要一个类加载器(你通常可以从已经被加载的对象中获取器类加载器，然后传递给它)
//,一个你希望该代理实现的接口列表，以及InvacationHandler接口的实现。
Interfaceproxy=(Interface)Proxy.newProxyInstance(Interface.class.getClassLoader(),newClass[]{Interface.class},newDynamicProxyHandler(real));
//Interfaceproxy=(Interface)Proxy.getProxyClass(Interface.class.getClassLoader(),newClass[]{Interface.class}).getConstructor(newClass[]{InvocationHandler.class}).newInstance(newDynamicProxyHandler(real));
consumer(proxy);
}
}
 classDynamicProxyHandlerimplementsInvocationHandler{
privateObjectproxied;
publicDynamicProxyHandler(Objectproxied){
this.proxied=proxied;
}

publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)
throwsThrowable{
System.out.println("********proxy:"+proxy.getClass()+",method:"+method+",args:"+args);
if(method.getName().equals("doSomething")){
SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-ddHH:mm:ss");
System.out.println(sdf.format(newDate()));
returnmethod.invoke(proxied,args);
}else{
System.out.println("Todayisnothing");
}
if(args!=null){
for(Objectarg:args){
System.out.println(""+arg);
}
}
returnmethod.invoke(proxied,args);
}

}

package com.demo;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDynamicProxy{
	public static void consumer(Interface iterface){
		iterface.doSomething();
		iterface.somethingElse("imaingecup");
	}
	public static void main(String[] args) throws Exception{
		RealObject real=new RealObject();
		consumer(real);
		//通过调用静态方法Proxy.newProxyInstance()可以创建动态代理，它需要一个类加载器(你通常可以从已经被加载的对象中获取器类加载器，然后传递给它)
		//,一个你希望该代理实现的接口列表，以及InvacationHandler接口的实现。
		Interface proxy=(Interface)Proxy.newProxyInstance(Interface.class.getClassLoader(), new Class[]{Interface.class}, new DynamicProxyHandler(real));
		//Interface proxy=(Interface)Proxy.getProxyClass(Interface.class.getClassLoader(), new Class[]{Interface.class}).getConstructor(new Class[]{InvocationHandler.class}).newInstance(new DynamicProxyHandler(real));
		consumer(proxy);
	}
}
class DynamicProxyHandler implements InvocationHandler{
	private Object proxied;
	public DynamicProxyHandler(Object proxied) {
		this.proxied=proxied;
	}
	
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("******** proxy: "+proxy.getClass()+" , method: "+method+" ,args: "+args);
		if(method.getName().equals("doSomething")){
			SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			System.out.println(sdf.format(new Date()));
			return method.invoke(proxied, args);
		}else{
			System.out.println("Today is nothing");
		}
		if(args!=null){
			for(Object arg:args){
				System.out.println("   "+arg);
			}
		}
		return method.invoke(proxied, args);
	}
	
}