java动态代理实现原理

java动态代理与反射

 

引言：

java的代理分为静态代理与动态代理，静态代理有其固有缺点，即代码量大，缺乏灵活性。故我们主要关注的还是动态代理。而动态代理是基于java反射机制实现的一种代理模式。

动态代理的用处：动态代理的用处很广。比如，我们常用的spring的AOP，即是通过动态代理技术来实现的。

 

 

要理解动态代理，首先需要了解java反射的基本概念及API方法。在这里假设你已经知道java反射的基础知识，在这个前提下，我们通过一个例子程序，即可说明动态代理的实现原理：

 

interface Manager {
	public void modify1();
	public void modify2();
}

class ManagerImpl implements Manager {
	public void modify1() {
		System.out.println("*******ManagerImpl 的 modify()1方法被调用*******");
	}
	public void modify2() {
		System.out.println("*******ManagerImpl 的 modify()2方法被调用*******");
	}
}

class ManagerImpl2 implements Manager {
	public void modify1() {
		System.out.println("*******ManagerImpl2 的 modify()1方法被调用*******");
	}
	public void modify2() {
		System.out.println("*******ManagerImpl2 的 modify()2方法被调用*******");
	}
}

class BusinessHandler implements InvocationHandler {
	private Object object = null;

	public BusinessHandler(Object object) {
		this.object = object;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("do something before method");
		Object ret = method.invoke(this.object, args);
		System.out.println("do something after method");
		return ret;
	}
}

public class Client {
	public static void main(String[] args) {
		// 元对象(被代理对象)
		ManagerImpl managerImpl = new ManagerImpl();
		ManagerImpl2 managerImpl2 = new ManagerImpl2();
		// 业务代理类
		BusinessHandler securityHandler = new BusinessHandler(managerImpl);
		// 获得代理类($Proxy0 extends Proxy implements Manager)的实例.
		Manager managerProxy = (Manager) Proxy.newProxyInstance(managerImpl
				.getClass().getClassLoader(), managerImpl.getClass()
				.getInterfaces(), securityHandler);
		
		System.out.println("——————");
                //通过反射，可以知晓，在内存中实际生成了一个$Proxy0的类，亦可通过反射看出这个类的代码组成
		//这里可以通过运行结果证明managerProxy是Proxy的一个实例，这个实例实现了Manager接口  
        System.out.println(managerProxy instanceof Proxy);  
          
        //这里可以看出managerProxy的Class类是$Proxy0,这个$Proxy0类继承了Proxy，实现了Manager接口  
        System.out.println("managerProxy的Class类是："+managerProxy.getClass().toString());  
          
        System.out.print("managerProxy中的属性有：");  
          
        Field[] field=managerProxy.getClass().getDeclaredFields();  
        for(Field f:field){  
            System.out.print(f.getName()+", ");  
        }  
          
        System.out.print("\n"+"managerProxy中的方法有：");  
        
        Method[] method=managerProxy.getClass().getDeclaredMethods();  
          
        for(Method m:method){  
            System.out.print(m.getName()+", ");  
        }  
          
        System.out.println("\n"+"managerProxy的父类是："+managerProxy.getClass().getSuperclass());  
          
        System.out.print("\n"+"managerProxy实现的接口是：");  
          
        Class<?>[] interfaces=managerProxy.getClass().getInterfaces();  
          
        for(Class<?> i:interfaces){  
            System.out.print(i.getName()+", ");  
        }  
        
        System.out.println();
        System.out.println("——————");
		
		managerProxy.modify1();
		managerProxy.modify2();
		System.out.println("——————");
		// 业务代理类，用以演示动态代理的优势：不用增加格外代码，只需增加另一个代理处理类，然后绑定到一个新的InvocationHandler实例上，即可实现扩充
		securityHandler = new BusinessHandler(managerImpl2);
		// 获得代理类($Proxy0 extends Proxy implements Manager)的实例.
		managerProxy = (Manager) Proxy.newProxyInstance(managerImpl2
						.getClass().getClassLoader(), managerImpl2.getClass()
						.getInterfaces(), securityHandler);
		managerProxy.modify1();
		managerProxy.modify2();
	}
}

 执行结果：

 

 

——————
true
managerProxy的Class类是：class testReflect_10.$Proxy0
managerProxy中的属性有：m4, m1, m0, m3, m2, 
managerProxy中的方法有：equals, toString, hashCode, modify1, modify2, 
managerProxy的父类是：class java.lang.reflect.Proxy

managerProxy实现的接口是：testReflect_10.Manager, 
——————
do something before method
*******ManagerImpl 的 modify()1方法被调用*******
do something after method
do something before method
*******ManagerImpl 的 modify()2方法被调用*******
do something after method
——————
do something before method
*******ManagerImpl2 的 modify()1方法被调用*******
do something after method
do something before method
*******ManagerImpl2 的 modify()2方法被调用*******
do something after method

 说明：

 

1、InvocationHandler是个代理处理类的父类（接口），只定义了一个invoke方法。BusinessHandler继承了该接口，并实现了invoke方法；

2、securityHandler = new BusinessHandler(managerImpl)：实例化一个代理处理类，并传入一个要代理的真实“对象”：managerImpl。

3、(Manager) Proxy.newProxyInstance(managerImpl 

                .getClass().getClassLoader(), managerImpl.getClass() 

 

                .getInterfaces(), securityHandler) 方法：创建了一个$Proxy0类的实例（不要问我是怎么知道的，代码里已经很清楚的看到，是可以通过反射打印出来的），这个实例继承了Proxy类，也实现了要代理的那个Manager接口，同时，还传入一个BusinessHandler的实例。

 

4、重点来了，managerProxy.modify1()，这句代码执行的时候，为什么会调用BusinessHandler的 invoke()方法？答案：也是通过反射，让我看到了那个$Proxy0类的代码（你可以通过反射的各种方法去将这个类的所有信息都可以打印出来）。其实网上也有很多同学已经帮我们去辛辛苦苦扣下来了$Proxy0类的代码，如是：

 

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

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

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

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

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

    m3 =Class.forName("com.ml.test.Manager").getMethod("modify1",
     new Class[0]);

    m2 =Class.forName("com.ml.test.Manager").getMethod("modify2",
     new Class[0]);

   } catch (NoSuchMethodExceptionnosuchmethodexception) {
    throw newNoSuchMethodError(nosuchmethodexception.getMessage());
   } catch(ClassNotFoundException classnotfoundexception) {
    throw newNoClassDefFoundError(classnotfoundexception.getMessage());
   }
} //static

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

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

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

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

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

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

 看到关键代码没？这个：

 

 

public final void modify1() {
   try {
          super.h.invoke(this, m3, null);
          return;

 明白了吧？代理类每次执行方法时，实际就是通过BusinessHandler这个真正的代理处理类的invoke方法来执行的。invoke方法的：method.invoke(this.object, args)这个方法，是java的反射技术，通过这个方法其实真正执行了managerImpl的modify1()这些方法。

 

 

——————这下明白了吧，动态代理的实现步骤：

1、继承并实现InvocationHandler接口及其invoke方法，这个方法体的实现其实也比较固定，就如例子程序那样；

2、通过Proxy的newProxyInstance方法创建一个代理实例，这个创建方法也会把真正处理方法执行的InvocationHandler绑定在一块。

3、再用第二步的proxy实例执行方法时，实际是调用了InvocationHandler的invoke方法，最终执行了真实的managerImpl的modify1()方法。

 

 

最后，我再画一个图吧：

 

希望对大家理解动态代理有所帮助！谢谢。