java动态代理详解(一)

（一）.什么是动态代理？

定义：动态代理为其他对象提供一种代理以控制对这个对象的访问。

（二）.为什么要用动态代理？

动态代理的优势就是实现无侵入式的代码扩展，比如 Spring的AOP的拦截功能是由java中的动态代理来实现的。

动态代理可以用在记录方法的日志，AOP，权限等等，而不侵入原来类的代码。

（三）.java中动态代理的实现

在java中如果要为一个类创建动态代理，这个类必须实现接口，然后还有两个重要的东西：Proxy和InvocationHandler。Proxy类是创建动态代理的主要类。它的newProxyInstance()静态方法返回一个代理对象的实例,而InvocationHandler是该被代理类的事物处理器。具体看代码。

1.创建一个的接口，并创建该接口的实现类，

package com.my.proxyTest;

//创建一个接口
public interface UserService {
public void addUser(String userName);

}

package com.my.proxyTest;

public class UserServiceImpl implements UserService {
@Override
public void addUser(String userName) {
System.out.println("增加的用户名为："+userName);
}

}

2.通过实现InvocationHandler接口创建自己的调用处理器

package com.my.proxyTest;

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

public class UserServiceHandler implements InvocationHandler{

public Object target;//用Object接收，可以传进来任意类型的对象。

public UserServiceHandler(Object obj){
target=obj;
}

/**
* proxy:代理类
* method：被代理类的方法
* args：该方法的参数数组
*/
@Override
//这里的invoke方法不是显示调用，而是java创建的代理对象$Proxy0.class调用
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

System.out.println("开始添加用户。。。");//在原来的对象方法执行前面，执行这段代码

Object obj=method.invoke(target,args);//传入被代理对象，也就是目标对象
return obj;
}

}

3.写测试类，并为对象创建代理对象

package com.my.proxyTest;

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

public class Client {

public static void main(String[] args) {

UserService userService=new UserServiceImpl();
UserServiceHandler h=new UserServiceHandler(userService);

//把$Proxy0强制转换成UserService
UserService userServiceProxy=(UserService)Proxy.newProxyInstance(
userService.getClass().getClassLoader(),
userService.getClass().getInterfaces(),
h);

System.out.println(userServiceProxy instanceof Proxy); //输出为true

//输出：userServiceProxy的Class类是：class $Proxy0
//这里可以看出userServiceProxy的Class类是$Proxy0。
//这个$Proxy0类继承了Proxy，实现了UserServiceImpl接口
System.out.println("userServiceProxy的Class类是："+userServiceProxy.getClass().toString());

System.out.print("<span style="font-size: 14px;">userServiceProxy</span>中的属性有：");

Field[] field=userServiceProxy.getClass().getDeclaredFields();
for(Field f:field){
System.out.print(f.getName()+", ");
}

System.out.print("\n"+"<span style="font-family: Arial, Helvetica, sans-serif;">userServiceProxy</span>中的方法有：");

Method[] method=userServiceProxy.getClass().getDeclaredMethods();

for(Method m:method){
System.out.print(m.getName()+", ");
}

System.out.println("\n"+"<span style="font-family: Arial, Helvetica, sans-serif;">userServiceProxy</span><span style="font-family: Arial, Helvetica, sans-serif;">的父类是："+userServiceProxy.getClass().getSuperclass());  </span>

System.out.print("\n"+"<span style="font-family: Arial, Helvetica, sans-serif;">userServiceProxy</span>实现的接口是：");

Class<?>[] interfaces=userServiceProxy.getClass().getInterfaces();

for(Class<?> i:interfaces){
System.out.print(i.getName()+", ");
}

System.out.println("\n\n"+"运行结果为：");

userServiceProxy.addUser("张三");
}

}

输出结果：

true

userServiceProxy的Class类是：class $Proxy0
userServiceProxy中的属性有：m3, m1, m0, m2, 
userServiceProxy中的方法有：addUser, hashCode, equals, toString, 
userServiceProxy的父类是：class java.lang.reflect.Proxy

userServiceProxy实现的接口是：com.my.proxyTest.UserService, 

运行结果为：

开始添加用户。。。

增加的用户名为：张三。可以发现在没有改动原来类的基础上，增加了原来类的业务逻辑。这就是java动态代理运用。

（四）分析源码

先看看Proxy类的主要代码

Proxy构造方法

private final static Class[] constructorParams ={ InvocationHandler.class }; //定义参数是<span style="font-family: Arial, Helvetica, sans-serif;">InvocationHandler的数组</span>

protected InvocationHandler h;

// 由于 Proxy 内部从不直接调用构造函数，所以 private 类型意味着禁止任何调用
private Proxy() {
}

// 由于 Proxy 内部从不直接调用构造函数，所以 protected 意味着只有子类可以调用
protected Proxy(InvocationHandler h) {
this.h = h;
}

Proxy静态方法newProxyInstance

public static Object newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h) throws IllegalArgumentException {
// 检查 h 不为空，否则抛异常
if (h == null) {
throw new NullPointerException();
}

// 获得与指定类装载器和一组接口相关的代理类类型对象
Class cl = getProxyClass(loader, interfaces);

// 通过反射获取构造函数对象并生成代理类实例
try {
Constructor cons = cl.getConstructor(constructorParams);
//cons即是形参为InvocationHandler类型的构造方法，通过构造方法创建代理类实例，
//此时需将调用处理器对象作为参数被传入
return (Object) cons.newInstance(new Object[] { h });
} catch (NoSuchMethodException e) { throw new InternalError(e.toString());     }
catch (IllegalAccessException e) { throw new InternalError(e.toString());     }
catch (InstantiationException e) { throw new InternalError(e.toString());     }
catch (InvocationTargetException e) { throw new InternalError(e.toString());     }
}

类Proxy的getProxyClass方法调用ProxyGenerator的 generateProxyClass方法产生ProxySubject.class的二进制数据：

public static byte[] generateProxyClass(final String name, Class[] interfaces)

我们可以import sun.misc.ProxyGenerator，调用 generateProxyClass方法产生binary data，然后写入文件，最后通过反编译工具来查看内部实现原理。 反编译后的userServiceProxy.java Proxy静态方法newProxyInstance

public final class $Proxy0 extends Proxy implements Subject {
private static Method m1;
private static Method m0;
private static Method m3;
private static Method m2;

static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals",
new Class[] { Class.forName("java.lang.Object") });

m0 = Class.forName("java.lang.Object").getMethod("hashCode",
new Class[0]);

m3 = Class.forName("***.RealSubject").getMethod("request",
new Class[0]);

m2 = Class.forName("java.lang.Object").getMethod("toString",
new Class[0]);

} catch (NoSuchMethodException nosuchmethodexception) {
throw new NoSuchMethodError(nosuchmethodexception.getMessage());
} catch (ClassNotFoundException classnotfoundexception) {
throw new NoClassDefFoundError(classnotfoundexception.getMessage());
}
} //static

public $Proxy0(InvocationHandler invocationhandler) {
super(invocationhandler);
}

@Override
public final boolean equals(Object obj) {
try {
return ((Boolean) super.h.invoke(this, m1, new Object[] { obj })) .booleanValue();
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}

@Override
public final int hashCode() {
try {
return ((Integer) super.h.invoke(this, m0, null)).intValue();
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}

public final void request() {
try {
super.h.invoke(this, m3, null);
return;
} catch (Error e) {
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}

@Override
public final String toString() {
try {
return (String) super.h.invoke(this, m2, null);
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
}

总结

一个典型的动态代理创建对象过程可分为以下四个步骤：

1、通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl(...);

2、通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类

Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});

3、通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型

Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});

4、通过构造函数创建代理类实例，此时需将调用处理器对象作为参数被传入

Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));

为了简化对象创建过程，Proxy类中的newInstance方法封装了2~4，只需两步即可完成代理对象的创建。
生成的ProxySubject继承Proxy类实现UserServiceImpl接口，实现的UserServiceImpl的方法实际调用处理器的invoke方法，而invoke方法利用反射调用的是被代理对象的的方法（Object result=method.invoke(proxied,args)）

java的用jdk实现动态代理有个美中不足，它只能实现继承接口的类。对于那些没有实现任何接口类无法使用动态代理，这时候就需要用到第三方的cglib来实现。