springmvc 动态代理 JDK实现与模拟JDK纯手写实现。

首先明白 动态代理和静态代理的区别；

　　　　 静态代理：①持有被代理类的引用  ② 代理类一开始就被加载到内存中了（非常重要）

            动态代理：JDK中的动态代理中的代理类是动态生成的。并且生成的动态代理类为$Proxy0

 静态代理实例1、创建一个接口：

package proxy;

public interface People {
	public void zhaoduixiang()throws Throwable;
	
}

 2、创建一个实现类，张三，张三能够吃饭，张三可以找对象

package proxy;

public class ZhangSan implements People {

	public void zhaoduixiang() throws Throwable{
		System.out.println(" 我只要漂亮的");
		
	}
	
}

 3、创建一个实现父类，父类持有张三的引用

package proxy;

public class HisDady implements People {
        ZhangSan zs;
        public HisDady(ZhangSan zs){
            this.zs=zs
        }
	public void zhaoduixiang() throws Throwable{
                before()
		zs.zhaoduixiang();
		afger() 
	}
          
	public void afger() throws Throwable{
		System.out.println(" 家境要好");
		
	}
          
	public void before() throws Throwable{
		System.out.println(" 要有学历");
		
	}
          
	
}                        

 动态代理:

1、创建一个申明类ProxyHandler

package proxy;

import java.awt.event.InvocationEvent;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;


public class ProxyHandler  implements InvocationHandler{
	People peaple=null;
	public ProxyHandler(People people){
		this.peaple=people;
	}

	public void before()throws Throwable{
		System.out.println("吃饭之前要洗手");
	}
	public void after()throws Throwable{
		System.out.println("吃饭以后要洗碗");
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		before();
		method.invoke(peaple,null);
		after();
		return null;
	}

}

 

2、创建一个test类 。

package proxy;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Proxy;

import sun.misc.ProxyGenerator;

public class Test {
	public static void main(String[] args) throws Throwable{
		System.out.println("JDK写的动态代理");
		
		People people=(People) Proxy.newProxyInstance(People.class.getClassLoader(),
				new Class[]{People.class}, new ProxyHandler(new ZhangSan()));
		people.eat();
	}
	public void sleep() throws Throwable{
		System.out.println("睡觉");
	}
	public void sport()throws Throwable{
		System.out.println("睡觉");
	}
}

 执行结果：

打印如图所示，那么People一定执行了ProxyHandler 中的invoke方法，并且首先执行before()  再执行method.invoke(peaple,null);最后执行 after();

那么问题来了，为什么会这么执行了？我们明明调用的People.eat()方法啊。

解析步骤：我们打印此时的People对象的名字，看看接口对应中到底是个什么东西：

        在test中的      people.eat();后面加入：
        
        System.out.println(people.getClass().getName());

打印结果为：Proxy.$Proxy0 ,这是个什么鬼东西，原来，people对象中保存的是一个类名为 $Proxy0的对象，我们调用的是$Proxy0的eat()方法，

所以我们最好看看$Proxy0的源码:

   如何读取$Proxy0的代码（由于$Proxy0JDK会自动删除，所以我们要把它写入到一个对应的文件中 ，代码如下）：

package proxy;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Proxy;

import sun.misc.ProxyGenerator;

public class Test {
	public static void main(String[] args) throws Throwable{
		System.out.println("JDK写的动态代理");
		
		People people=(People) Proxy.newProxyInstance(People.class.getClassLoader(),
				new Class[]{People.class}, new ProxyHandler(new ZhangSan()));
		people.eat();
		
		System.out.println(people.getClass().getName());
		creatProxyClassFile();
	}
	public static void creatProxyClassFile(){
		byte[] data=ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{People.class});
		try {
			FileOutputStream out= new FileOutputStream("$Proxy0.class");
			out.write(data);
			out.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}
	public void sleep() throws Throwable{
		System.out.println("睡觉");
	}
	public void sport()throws Throwable{
		System.out.println("睡觉");
	}
}

 打开对应的项目工作空间，你会发现一个对应$Proxy0文件；

那么其中有什么玄妙，导致我们调用$Proxy0.eat()方法的时候，会调用invoke()方法了

我们看看Proxy0类的源码，请用反编译软件打开Proxy0.class：

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

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

  public $Proxy0(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 eat()
    throws Throwable
  {
    this.h.invoke(this, m3, null);
  }

  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("proxy.People").getMethod("eat", 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());
    }
  }
}

 请注意其中的一些方法和属性，比如public final void eat() throws Throwable { this.h.invoke(this, m3, null); }   ，其中 该对象的eat()方法是调用的invoke 方法，那h是什么意思， 

因为Proxy0 ：public final class $Proxy0 extends Proxy，在Proxy中查看  发现：   protected InvocationHandler h;,所以h就是一个我们传入的InvocationHandler 对象，也就是调用的是InvocationHandler 的invoke方法。  这样我们就明白了为什么会出现console中打印的结果了吧。

 

纯手写动态代理，不使用任何JDK：

1、 创建一个MyInvocationHandler 接口，模拟InvocationHandler

package proxy;

import java.lang.reflect.Method;

public interface MyInvocationHandler {
	public Object invoke(Object proxy,Method method,Object args)
		throws Throwable;
}

 2、实现该接口MyProxyHandler，模拟ProxyHandler，和原来动态代理完全一个样，只是改了下代码形式

package proxy;

import java.lang.reflect.Method;

public class MyProxyHandler implements MyInvocationHandler {
	People peaple=null;
	public MyProxyHandler(People people){
		this.peaple=people;
	}
	public Object invoke(Object proxy, Method method, Object args)
			throws Throwable {		
		before();
		method.invoke(peaple,null);
		after();
		return null;
	}
	public void before(){
		System.out.println("吃饭之前要洗手");
	}
	public void after(){
		System.out.println("吃饭以后要洗碗");
	}

}

 3、新建一个Proxy类，MyProxy，用来模拟Proxy

package proxy;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import javax.tools.JavaCompiler;
import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;

import org.omg.CORBA.INTF_REPOS;

public class MyProxy {
	static String rt="\r\t";
	public static Object createProxyInstance(ClassLoader loader,Class intf,MyInvocationHandler handler){
		try {
			Method[] methods=intf.getMethods();
			//1用流的方式创建一个Java文件，
				String proxyClass="package proxy;"+rt
						+"import java.lang.reflect.Method;"+rt
						+"public class $Proxy0 implements "+intf.getName()+"{"+rt
						+"MyInvocationHandler h;"+rt
						+"public $Proxy0(MyInvocationHandler h)"+"{"+rt
						+"this.h= h;"+rt+"}"
						+getMethodString(methods,intf)+rt+"}";
			//2 把类生成文件，
			String filename="D:/WorkSpace/proxy/src/proxy/$Proxy0.java";
			File f=new File(filename);
	
			FileWriter fw=new FileWriter(f);
			fw.write(proxyClass);
			fw.flush();
			fw.close();
			
			//3编译Java文件
			JavaCompiler compiler=ToolProvider.getSystemJavaCompiler();
			StandardJavaFileManager fileMgr	=compiler.getStandardFileManager(null, null, null);
			Iterable units=fileMgr.getJavaFileObjects(filename);
			CompilationTask t=compiler.getTask(null, fileMgr, null, null, null, units);
			t.call();
			fileMgr.close();
			
			//把class加载到内存中去
			MyClassLoader loader1=new MyClassLoader("D:/WorkSpace/proxy/src/proxy/");
			Class proxy0Class=loader1.findClass("$Proxy0");
			Constructor m=proxy0Class.getConstructor(MyInvocationHandler.class);
			Object o=m.newInstance(handler);
			return o;
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
		
	}	
	public static String getMethodString(Method[] methods,Class intf){
		String proxyMe="";
		for(Method method: methods){
			proxyMe+="public void "+method.getName()+"() throws Throwable {"+rt
					+"Method md= "+intf.getName()+".class.getMethod(\""+method.getName()
					+"\",new Class[]{});"+rt
					+"this.h.invoke(this,md,null);"+rt+"}"+rt;
					
		}
		return proxyMe;
	}
}

 4、创建一个测试：

package proxy;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Proxy;

import sun.misc.ProxyGenerator;

public class Test {
	public static void main(String[] args) throws Throwable{
		System.out.println("JDK写的动态代理");
		
		People people=(People) Proxy.newProxyInstance(People.class.getClassLoader(),
				new Class[]{People.class}, new ProxyHandler(new ZhangSan()));
		people.eat();
		
		
/*		People people1=(People) MyProxy.createProxyInstance(People.class
				.getClassLoader(),People.class, new MyProxyHandler(
						new ZhangSan()));
		System.out.println(people1.getClass().getName());
		System.out.println("自己写的动态代理");
		people1.eat();	*/	
		
		
		System.out.println(people.getClass().getName());
		creatProxyClassFile();
	}
	public static void creatProxyClassFile(){
		byte[] data=ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{People.class});
		try {
			FileOutputStream out= new FileOutputStream("$Proxy0.class");
			out.write(data);
			out.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}
}

 结果：

此次是我观看动脑学院免费教学课后的练习，非常感谢Jack老师，老师讲的很好，我学了很多。