日常工作记录，java动态代理

为什么要用代理

案例： 我们有个接口Iservice，他有三个方法(分别为a()；接口有两个实现ServiceAImpl和ServiceBImpl，实现的方法都简单只有一个输出语句，例如：我是ServiceA中的A方法!

突然收到改变需求 调用IService接口中的任何方法的时候，需要记录方法的耗时 此时你可能觉得只有两个实现不多，就自己挨个的添加了；那要是改的地方多呢？还有要是这些接口都是别人提供的jar包呢？

比较好的方式：可以为IService接口创建一个代理类，通过这个代理类来间接访问IService接口的实现 类，在这个代理类中去做耗时及发送至监控的代码

// IService的代理类
public class ServiceProxy implements IService {
//目标对象，被代理的对象
private IService target;
public ServiceProxy(IService target) {
this.target = target;
}
@Override
public void a() {
long starTime = System.nanoTime();
this.target.a();
long endTime = System.nanoTime();
System.out.println(this.target.getClass() + ".a()方法耗时(纳秒):" +(endTime - starTime));
}

ServiceProxy是IService接口的代理类，target为被代理的对象，即实际需要访问的对象，也实现了 IService接口，上面的3个方法中加了统计耗时的代码，当我们需要访问IService的其他实现类的时候， 可以通过ServiceProxy来间接的进行访问

@Test
public void serviceProxy() {
IService serviceA = new ServiceProxy(new ServiceA());//@1
IService serviceB = new ServiceProxy(new ServiceB()); //@2
serviceA.a();
serviceB.a();
}

上面实现中我们没有去修改ServiceA和ServiceB中的方法，只是给IService接口创建了一个代理类，通过 代理类去访问目标对象，需要添加的一些共有的功能都放在代理中，当领导有其他需求的时候，我们只 需修改ServiceProxy的代码，方便系统的扩展和测试。

假如现在我们需要给系统中所有接口都加上统计耗时的功能，若按照上面的方式，我们需要给每个接口 创建一个代理类，此时代码量和测试的工作量也是巨大的，那么我们能不能写一个通用的代理类，来满 足上面的功能呢？

jdk动态代理详解

jdk中为实现代理提供了支持，主要用到2个类：

java.lang.reflect.Proxy
java.lang.reflect.InvocationHandler

jdk自带的代理使用上面有个限制，只能为接口创建代理类，如果需要给具体的类创建代理类，需要用到cglib

java.lang.reflect.Proxy

这是jdk动态代理中主要的一个类，里面有一些静态方法会经常用到，我们来熟悉一下：

getProxyClass方法

为指定的接口创建代理类，返回代理类的Class对象
public static Class<?> getProxyClass(ClassLoader loader,Class<?>... interfaces)
参数说明：
loader：定义代理类的类加载器
interfaces：指定需要实现的接口列表，创建的代理默认会按顺序实现interfaces指定的接口

newProxyInstance方法

创建代理类的实例对象

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
	
这个方法先为指定的接口创建代理类，然后会生成代理类的一个实例，最后一个参数比较特殊，是
InvocationHandler类型的，这个是个接口如下：

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

上面方法会返回一个代理对象，当调用代理对象的任何方法的时候，会就被 InvocationHandler 接口
的 invoke 方法处理，所以主要代码需要卸载 invoke 方法中，稍后会有案例细说。

isProxy方法

判断指定的类是否是一个代理类

public static boolean isProxyClass(Class<?> cl) 

getInvocationHandler方法

获取代理对象的 InvocationHandler 对象

public static InvocationHandler getInvocationHandler(Object proxy)
throws IllegalArgumentException

代理的两种创建方式

第一种：

• 1.调用Proxy.getProxyClass方法获取代理类的Class对象
• 2.使用InvocationHandler接口创建代理类的处理器
• 3.通过代理类和InvocationHandler创建代理对象
• 4.上面已经创建好代理对象了，接着我们就可以使用代理对象了

@Test
public void m1() throws NoSuchMethodException, IllegalAccessException,
InvocationTargetException, InstantiationException {
// 1. 获取接口对应的代理类
Class<IService> proxyClass = (Class<IService>)Proxy.getProxyClass(IService.class.getClassLoader(), IService.class);
// 2. 创建代理类的处理器
InvocationHandler invocationHandler = new InvocationHandler() {
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	System.out.println("我是InvocationHandler，被调用的方法是：" + method.getName());
	return null;
	}
};
// 3. 创建代理实例
IService proxyService =proxyClass.getConstructor(InvocationHandler.class).newInstance(invocationHandler);
// 4. 调用代理的方法
proxyService.m1();

第二种

• 1.使用InvocationHandler接口创建代理类的处理器
• 2.使用Proxy类的静态方法newProxyInstance直接创建代理对象
• 3.使用代理对象

@Test
public void m2() throws NoSuchMethodException, IllegalAccessException,InvocationTargetException, InstantiationException {
// 1. 创建代理类的处理器
InvocationHandler invocationHandler = new InvocationHandler() {
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	System.out.println("我是InvocationHandler，被调用的方法是：" +
	method.getName());
	return null;
	}
};
// 2. 创建代理实例
IService proxyService = (IService)Proxy.newProxyInstance(IService.class.getClassLoader(), new Class[]{IService.class}, invocationHandler);
// 3. 调用代理的方法
proxyService.m1();
}

案例：任意接口中的方法耗时统计

下面我们通过jdk动态代理实现一个通用的代理，解决统计所有接口方法耗时的问题。 主要的代码在代理处理器 InvocationHandler 实现上面； 上面主要是 createProxy 方法用来创建代理对象，2个参数： target：目标对象，需要实现targetInterface接口 targetInterface：需要创建代理的接口 invoke方法中通过 method.invoke(this.target, args) 调用目标方法，然后统计方法的耗时。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class CostTimeInvocationHandler implements InvocationHandler {
	private Object target;
public CostTimeInvocationHandler(Object target) {
	this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws
Throwable {
	long starTime = System.nanoTime();
	Object result = method.invoke(this.target, args);//@1
	long endTime = System.nanoTime();
	System.out.println(this.target.getClass() +"》》"+ method.getName() +"方法耗时(纳秒):" +(endTime - starTime));
	return result;
}
/**
* 用来创建targetInterface接口的代理对象
*
* @param target 需要被代理的对象
* @param targetInterface 被代理的接口
* @param <T>
* @return
*/
public static <T> T createProxy(Object target, Class<T> targetInterface) {
	if (!targetInterface.isInterface()) {
		throw new IllegalStateException("targetInterface必须是接口类型!");
	} else if (!targetInterface.isAssignableFrom(target.getClass())) {
		throw new IllegalStateException("target必须是targetInterface接口的实现类!");
	}
	return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(), new CostTimeInvocationHandler(target));
}
}

Proxy使用注意

1. jdk中的Proxy只能为接口生成代理类，如果你想给某个类创建代理类，那么Proxy是无能为力的，此时需要我们用到下面要说的cglib了。
2. Proxy类中提供的几个常用的静态方法大家需要掌握
3. 通过Proxy创建代理对象，当调用代理对象任意方法时候，会被InvocationHandler接口中的invoke方法进行处理，这个接口内容是关键