JDK动态代理

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

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

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

它等价于

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

 

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

InvocationHandler:

Object   invoke ( Object  proxy,

               Method  method,

               Object [] args)

              throws  Throwable

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

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

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

public interface Interface {
	void doSomething();
	void somethingElse(String 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);
		
	}
	
}

 

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

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);
	}
	
}