何为代理
代理,即代替主角完成一些额外的事情。例如,明星都有经纪人,明星参演电影之前,经纪人作为明星的代理人和出资方洽谈片酬、排期等,而真正参与拍戏的还是明星本人,明星拍完戏后,由经纪人代理明星去清算片酬等。Java中的代理机制就是在目标方法执行前后执行一些额外的操作,如安全检查、记录日志等,Java中的代理分为静态代理和动态代理。
静态代理
首先看一下静态代理,直接上代码,代码模拟了登录操作。
public interface LoginService {
void login();
}
public class LoginServiceImpl implements LoginService {
@Override
public void login() {
System.out.println("login");
}
}
public class LoginServiceProxy implements LoginService {
private LoginService loginService;
public LoginServiceProxy() {
loginService = new LoginServiceImpl();
}
@Override
public void login() {
beforeLogin();
loginService.login();
afterLogin();
}
private void beforeLogin() {
System.out.println("before login");
}
private void afterLogin() {
System.out.println("after login");
}
}
public class Client {
@Test
public void test() {
LoginService loginService = new LoginServiceImpl();
LoginService loginServiceProxy = new LoginServiceProxy(loginService);
loginServiceProxy.login();
}
}
输出结果如下:
before login
login
after login
上面代码实现的静态代理很容易理解,使用聚合方式,在登录操作前后执行额外的操作。静态代理方式可以看得到具体代理类的代码,且代码由程序员编写,在编译之后会生成相应的class文件。使用静态代理方式的缺点,如果需要对LoginService接口中有N个方法都代理,则需要在代理类中创建N个代理方法,并且需要编写重复的代理操作代码。
概念解释
目标接口,即对目标操作的抽象,如LoginService。
目标类,即目标接口的实现类,如LoginServiceImpl。
目标对象,即目标类的实例。
代理类,即目标类的代理,如LoginServiceProxy。
代理对象,即代理类的实例。
动态代理
动态代理,即在运行时根据目标接口动态生成的代理类。动态代理方式生成的代理类在编译后不会生成实际的class文件,而是在运行时动态生成类字节码,并加载到JVM中使用。下面使用JDK的动态代理机制模拟登录操作,具体代码如下。
public interface LoginService {
void login();
}
public class LoginServiceImpl implements LoginService {
@Override
public void login() {
System.out.println("login");
}
}
public class ProxyInvocationHandler implements InvocationHandler {
private LoginService loginService;
public ProxyInvocationHandler(LoginService loginService) {
this.loginService = loginService;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
beforeLogin();
Object invokeResult = method.invoke(loginService, args);
afterLogin();
return invokeResult;
}
private void beforeLogin() {
System.out.println("before login");
}
private void afterLogin() {
System.out.println("after login");
}
}
public class Client {
@Test
public void test() {
LoginService loginService = new LoginServiceImpl();
ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler(loginService);
LoginService loginServiceProxy = (LoginService) Proxy.newProxyInstance(loginService.getClass().getClassLoader(), loginService.getClass().getInterfaces(), proxyInvocationHandler);
loginServiceProxy.login();
createProxyClassFile();
}
public static void createProxyClassFile() {
String name = "LoginServiceProxy";
byte[] data = ProxyGenerator.generateProxyClass(name, new Class[]{LoginService.class});
try {
FileOutputStream out = new FileOutputStream("/Users/" + name + ".class");
out.write(data);
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出结果如下:
before login
login
after login
JDK动态代理方式实现代理的步骤如下:
1.编写目标接口;
2.编写目标类实现目标接口,实现目标方法的具体逻辑;
3.编写一个代理处理器类实现InvocationHandler接口,重写invoke方法,用于指定运行时将生成的代理类需要完成的具体操作,包括beforeLogin和afterLogin。代理对象调用任何代理方法时都会调用这个invoke方法;
4.创建代理对象,使用代理对象调用代理方法。
上面的步骤中主要涉及以下两个类:
java.lang.reflect.InvocationHandler和java.lang.reflect.Proxy
InvocationHandler是一个接口,代理类的调用处理器,每个代理对象都具有一个关联的调用处理器,用于指定动态生成的代理类需要完成的具体操作。该接口中有一个invoke方法,代理对象调用任何目标接口的方法时都会调用这个invoke方法,在这个方法中进行目标类的目标方法的调用。
Proxy提供静态方法用于创建动态代理类和代理类实例,同时,使用它提供的方法创建的代理类都是它的子类。这个类中主要关注newProxyInstance方法,该方法用于创建代理类对象,方法声明如下:
public static Object newProxyInstance(ClassLoader loader,Class
代理类解密
对于JDK动态代理,生成的代理类是什么样的?为什么调用代理类的任何方法时都一定会调用invoke方法?下面来进行深入解密。
因为动态代理是在运行时动态生成字节码,编译期看不到相应的class文件,所以不能直观的看到代理类内容。那就从newProxyInstance方法开始(代码分析基于JDK7),这个方法用于创建代理类对象,这里只关注重要的代码段,
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
// create proxy instance with doPrivilege as the proxy class may
// implement non-public interfaces that requires a special permission
return AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
return newInstance(cons, ih);
}
});
} else {
return newInstance(cons, ih);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString());
}
代码段中
final Constructor<?> cons = cl.getConstructor(constructorParams);
用于获取代理类的构造函数,constructorParams参数其实就是一个InvocationHandler,所以从这里猜测代理类中有一个InvocationHandler类型的属性,并且作为构造函数的参数。那这个代理类是在哪里创建的?注意看上面的代码段中有
Class<?> cl = getProxyClass0(loader, intfs);
这里就是动态创建代理类的地方,继续深入到getProxyClass0方法中,方法如下,
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// If the proxy class defined by the given loader implementing
// the given interfaces exists, this will simply return the cached copy;
// otherwise, it will create the proxy class via the ProxyClassFactory
return proxyClassCache.get(loader, interfaces);
}
继续跟踪代码,进入proxyClassCache.get(loader, interfaces),这个方法中重点关注如下代码
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
继续跟踪代码,进入subKeyFactory.apply(key, parameter),进入apply方法,这个方法中有很多重要的信息,如生成的代理类所在的包名,发现重要代码,
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
上面代码用于生成代理类名称,nextUniqueNumber是AtomicLong类型,是一个全局变量,所以nextUniqueNumber.getAndIncrement()会使用当前的值加一得到新值;proxyClassNamePrefix声明如下,
private static final String proxyClassNamePrefix = "$Proxy";
所以,这里生成的代理类类名格式为:包名+
Proxy+num,如jdkproxy.
P
r
o
x
y
+
n
u
m
,
如
j
d
k
p
r
o
x
y
.
Proxy12。
代理类的类名已经构造完成了,那可以开始创建代理类了,继续看代码,
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
这里就是真正创建代理类的地方,继续分析代码,进入generateProxyClass方法,
public static byte[] generateProxyClass(final String var0, Class[] var1) {
ProxyGenerator var2 = new ProxyGenerator(var0, var1);
final byte[] var3 = var2.generateClassFile();
if(saveGeneratedFiles) {
AccessController.doPrivileged(new PrivilegedAction() {
public Void run() {
try {
FileOutputStream var1 = new FileOutputStream(ProxyGenerator.dotToSlash(var0) + ".class");
var1.write(var3);
var1.close();
return null;
} catch (IOException var2) {
throw new InternalError("I/O exception saving generated file: " + var2);
}
}
});
}
return var3;
}
从这里可以很直白的看到,生成的代理类字节码文件被输出到某个目录下了,这里可能很难找到这个字节码文件,没关系,仔细查看这个方法,generateProxyClass方法可以重用,可以在外面调用generateProxyClass方法,把生成的字节码文件输出到指定位置。写到这里,终于可以解释上面实例代码中的createProxyClassFile方法了,这个方法把代理类的字节码文件输出到了/Users路径下,直接到路径下查看这个文件,使用反编译工具查看,得到的代码如下,
public final class LoginServiceProxy extends Proxy
implements LoginService
{
private static Method m1;
private static Method m3;
private static Method m0;
private static Method m2;
public LoginServiceProxy(InvocationHandler paramInvocationHandler)
throws
{
super(paramInvocationHandler);
}
public final boolean equals(Object paramObject)
throws
{
try
{
return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final void login()
throws
{
try
{
this.h.invoke(this, m3, null);
return;
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final int hashCode()
throws
{
try
{
return ((Integer)this.h.invoke(this, m0, null)).intValue();
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final String toString()
throws
{
try
{
return (String)this.h.invoke(this, m2, null);
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
static
{
try
{
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
m3 = Class.forName("jdkproxy.LoginService").getMethod("login", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
return;
}
catch (NoSuchMethodException localNoSuchMethodException)
{
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
}
catch (ClassNotFoundException localClassNotFoundException)
{
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}
}
从上面的代码可以看到,当代理类调用目标方法时,会调用InvocationHandler接口实现类的invoke方法,很明了的解释了为什么调用目标方法时一定会调用invoke方法。
总结
1.静态代理方式虽然简单,但是会出现重复代码的情况;
2.动态代理使用上相对复杂些,但是可以动态创建代理类,避免手动编写重复代码;
3.因为Java的单继承性,JDK动态代理只能对接口创建代理类,不能对实现类创建。