JAVA动态代理模拟

所谓代理，就是有一个代理类和一个被代理类，代理类帮被代理类执行相关的动作，如房产中介帮房东代理出租房屋，当有客户租房子时，客户只要找房产中介就可以了，中介会帮房东去执行租出去这个动作。当然，中介可以在中间做一些事情，如带客户看房子，最主要的是万恶的中介会收中介费，扯远了。。。。。言归正传

代理分类

代理分为静态代理和动态代理两种，不管静态代理还是动态代理，代理类和被代理累一般都是实现同一个接口。

静态代理

所谓静态代理，就是如果被代理类的方法在执行之前或之后需要多种操作，那代理类就要写多种，如定义一个接口Flyable(飞行物)，有一个fly()方法。有一个被代理类Bird实现了这个接口，现在要计算这只鸟飞行了多久，那我们就要在这只鸟飞行之前记录下时间，飞行之后记录下时间。代码如下：

package com.sf.simba.dynamicproxy.fly;
/**
 * 
 * @author -Simba-
 *
 */
public interface Flyable {
   void fly();
}

package com.sf.simba.dynamicproxy.fly;

import java.util.Random;
/**
 * 被代理类
 * @author -Simba-
 *
 */
public class Bird implements Flyable {

@Override
public void fly() {
System.out.println("The bird is flying.......");
try {
Thread.sleep(new Random().nextInt(2000));
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

package com.sf.simba.dynamicproxy.fly;
/**
 *  时间代理类
 *  代理类和被代理类实现同一个接口
 * @author -Simba-
 *
 */
public class TimeBirdProxy implements Flyable {
private Flyable flyable;

public TimeBirdProxy(Flyable flyable){
this.flyable = flyable;
}
@Override
public void fly() {
long start = System.currentTimeMillis();
flyable.fly();
long end = System.currentTimeMillis();
System.out.println("The Flyable has flown "+(end-start)+" millisecond");


}


}

package com.sf.simba.dynamicproxy.fly;
/**
 * 测试类
 * @author -Simba-
 *
 */
public class ProxyMain {

public static void main(String[] args) {
Flyable bird = new Bird();
Flyable timeproxy = new TimeBirdProxy(bird);
timeproxy.fly();

}
}

测试结果如下：

The bird is flying.......
The Flyable has flown 1774 millisecond

结果测试可以记录时间了。

如果现在我要在被代理类Bird调用fly()方法后要记录下日志，那是不是要在写一个记录日志的代理类，那如果我要在调用之前做一下权限验证呢？那我是不是要在写一个权限验证的代理类，如果我还有更多的需求呢，那我这个代理类是不是要一直写下去？在比如，我现在要代理一个不是Flyable接口的接口但也是记录时间、记录日志、权限校验。。。。。。。。那这样就会导致类爆炸，对以后的维护带来非常的不便，那我们有没有办法让这个代理类动态生成呢？就是这个代理类不管代理什么我们都可以生成，那这样就好维护多了。

动态代理

从上面的例子中我们可以发现，静态代理会导致类爆炸，难以维护，那么如果这个代理类如果能够动态生成就好了，那么怎么样才能让我们这个代理类动态生成呢，那就是让这个代理类变成一个字符串，动态的改变这个字符串，然后动态编译成字节码，通过ClassLoad装载字节码生成二进制文件到内存，然后生成实例对象(代理对象)，然后执行这个代理对象。代码如下

package com.sf.simba.dynamicproxy.fly;

import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.net.URL;
import java.net.URLClassLoader;

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

/**
 * 动态代理生成类
 * @author -Simba-
 *
 */
public class Proxy {
public static Object newProxyInstance() throws Exception{
 String rn = "\r\n";
   String classStr = "package com.sf.simba.dynamicproxy.fly; " +rn+
            "import com.sf.simba.dynamicproxy.fly.Flyable;" +rn+
   " public class TimeBirdProxy implements Flyable { " + rn+
   "    private Flyable flyable; " + rn+
   "    public TimeBirdProxy(Flyable flyable){ " + rn+
   "      this.flyable = flyable; " + rn+
   "    } " + rn+
   "  @Override " + rn+
   "  public void fly() { " + rn+
   "    long startTime = System.currentTimeMillis(); " + rn+
   "    flyable.fly(); " + rn+
   "        long endTime = System.currentTimeMillis(); " + rn+
   "        System.out.println(\" TimeBirdProxy: The Flyable has flown \" + (endTime - startTime)+\" millisecond\"); " + rn+
   "  } " + rn+
   "\n" + rn+
   "}";

   //定义动态文件生成到哪里叫什么名字
   String fileName = System.getProperty("user.dir")+"/src/com/sf/simba/dynamicproxy/fly/TimeBirdProxy.java";
   File file = new File(fileName);
   FileWriter fw = new FileWriter(file);
   //把字符串写入文件
   fw.write(classStr);
   fw.flush();
   fw.close();

   //获得编译器
   JavaCompiler complier = ToolProvider.getSystemJavaCompiler();
   StandardJavaFileManager fileManager = complier.getStandardFileManager(null, null, null);
   Iterable<? extends JavaFileObject> units = fileManager.getJavaFileObjects(fileName);
   CompilationTask task = complier.getTask(null, fileManager, null, null, null, units);
   //编译，生成字节码
   task.call();
   fileManager.close();

   URL[] url = new URL[]{new URL("file:/"+System.getProperty("user.dir")+"/src/")};
   //加载字节码
   URLClassLoader classloder = new URLClassLoader(url);
   Class<?> loadClass = classloder.loadClass("com.sf.simba.dynamicproxy.fly.TimeBirdProxy");
   //获得代理对象构造方法
   Constructor<?> constructor = loadClass.getConstructor(Flyable.class);
   //生成代理对象实例

   Object newInstance = constructor.newInstance(new Bird());//new Bird()为被代理对象
   System.out.println(newInstance);
   return newInstance;


}

}

测试类如下：

package com.sf.simba.dynamicproxy.fly;
/**
 * 测试类
 * @author -Simba-
 *
 */
public class ProxyMain {

public static void main(String[] args) throws Exception {
//Flyable bird = new Bird();
Flyable timeproxy = (Flyable)Proxy.newProxyInstance();
timeproxy.fly();

}
}

测试结果：

com.sf.simba.dynamicproxy.fly.TimeBirdProxy@100a15d
The bird is flying.......
TimeBirdProxy: The Flyable has flown 767 millisecond

从上面这个例子可以看出，我不需要这个TimeBirdProxy类了，这个类被Proxy类自动生成了，但这样只能生成时间的代理类，如果要生成日志的代理类我们还是要改字符串，这明显不是我们想要的，所以我们要动态生成fly这个方法，然后在执行。我们需要这样一个接口，接口里的方法能够动态执行被代理类的方法，而代理类持有这个接口的引用，在调用fly()这个方法时调用这个接口里的方法，我们定义这个接口为InvocationHandler，方法为Invoke，这里有点绕，容易晕，先上一个类图。

JAVA动态代理模拟

代码如下：

 package com.sf.simba.dynamicproxy.fly;


import java.lang.reflect.Method;
/**
 * 动态代理类持有此接口的引用
 * @author -Simba-
 *
 */
public interface InvocationHandler {
 public void invoke(Object o,Method m);
}

时间处理类如下：

package com.sf.simba.dynamicproxy.fly;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
 * 时间记录处理类
 * @author -Simba-
 *
 */
public class TimeHandler implements InvocationHandler {
    /**
     * 这个target为被代理类
     */
private Object target;

private long starttime;
private long endtime;


public TimeHandler(Object target){
this.target = target;
}

public void pre(){
starttime = System.currentTimeMillis();
}
/**
 * 为简单起见，假设被代理对象的方法没有参数，在JDK中的动态代理中是有参数的
 */
@Override
public void invoke(Object o, Method m) {

         pre();//方法调用前的操作
         try {
m.invoke(target, null);
} 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();
}
         end();//方法调用后的操作
         System.out.println(" TimeBirdProxy: The Flyable has flown " + (endtime - starttime)+" millisecond");
}

public void end(){
endtime = System.currentTimeMillis();
}

}

Proxy类变为（注意持有的是InvocationHandler的引用了，而不是Flyable的引用，在生成构造方法的时候传入的是InvocationHandler类）：

package com.sf.simba.dynamicproxy.fly;

import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.net.URL;
import java.net.URLClassLoader;

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

/**
 * 动态代理生成类
 * @author -Simba-
 *
 */
public class Proxy {


public static Object newProxyInstance(InvocationHandler handler) throws Exception{
 String rn = "\r\n";
   String classStr = "package com.sf.simba.dynamicproxy.fly; " +rn+
            "import com.sf.simba.dynamicproxy.fly.Flyable;" +rn+
            "import com.sf.simba.dynamicproxy.fly.InvocationHandler;" +rn+
   " public class TimeBirdProxy implements Flyable { " + rn+
   "    private InvocationHandler handler; " + rn+
   "    public TimeBirdProxy(InvocationHandler handler){ " + rn+
    "    super(); " + rn+
   "      this.handler = handler; " + rn+
   "    } " + rn+
   "  @Override " + rn+
   "  public void fly() { " + rn+
   "try { "+rn+
  " java.lang.reflect.Method md = Flyable.class.getMethod(\"fly\");"+rn+
   " handler.invoke(this,md);"+rn+
  "}catch(Exception e){" +rn+
  " e.printStackTrace();" +rn+
  "}"+rn+
   "  } " + rn+
   "\n" + rn+
   "}";
   System.out.println("动态生成的代理类为：\n"+classStr);
   //定义动态文件生成到哪里叫什么名字
   String fileName = System.getProperty("user.dir")+"/src/com/sf/simba/dynamicproxy/fly/TimeBirdProxy.java";
   File file = new File(fileName);
   FileWriter fw = new FileWriter(file);
   //把字符串写入文件
   fw.write(classStr);
   fw.flush();
   fw.close();

   //获得编译器
   JavaCompiler complier = ToolProvider.getSystemJavaCompiler();
   StandardJavaFileManager fileManager = complier.getStandardFileManager(null, null, null);
   Iterable<? extends JavaFileObject> units = fileManager.getJavaFileObjects(fileName);
   CompilationTask task = complier.getTask(null, fileManager, null, null, null, units);
   //编译，生成字节码
   task.call();
   fileManager.close();

   URL[] url = new URL[]{new URL("file:/"+System.getProperty("user.dir")+"/src/")};
   //加载字节码
   URLClassLoader classloder = new URLClassLoader(url);
   Class<?> loadClass = classloder.loadClass("com.sf.simba.dynamicproxy.fly.TimeBirdProxy");
   //获得代理对象构造方法
   Constructor<?> constructor = loadClass.getConstructor(InvocationHandler.class);
   //生成代理对象实例

   Object newInstance = constructor.newInstance(handler);//new Bird()为被代理对象
  System.out.println("-------------------生成的对象类为:"+newInstance.getClass().getName());
   return newInstance;


}

}

测试类如下：

package com.sf.simba.dynamicproxy.fly;
/**
 * 测试类
 * @author -Simba-
 *
 */
public class ProxyMain {


public static void main(String[] args) throws Exception {
Flyable bird = new Bird();
InvocationHandler handler = new TimeHandler(bird);
Flyable timeproxy = (Flyable)Proxy.newProxyInstance(handler);
timeproxy.fly();


}
}

生成的结果如下：

动态生成的代理类为：
package com.sf.simba.dynamicproxy.fly;
import com.sf.simba.dynamicproxy.fly.Flyable;
import com.sf.simba.dynamicproxy.fly.InvocationHandler;
public class TimeBirdProxy implements Flyable {
private InvocationHandler handler;
public TimeBirdProxy(InvocationHandler handler){
super();
this.handler = handler;
}
@Override
public void fly() {
try {
java.lang.reflect.Method md = Flyable.class.getMethod("fly");
handler.invoke(this,md);
}catch(Exception e){
e.printStackTrace();
}
}

}
-------------------生成的对象类为:com.sf.simba.dynamicproxy.fly.TimeBirdProxy
The bird is flying.......
TimeBirdProxy: The Flyable has flown 1824 millisecond

通过动态生成的代理类我们可以看出，在代理类的fly()方法中，并没有去执行Bird的fly()方法（持有的引用有Flyable改为了InvocationHandler），而是通过反射机制获取Flyable的fly对应的Method，把Method作为参数传给InvocationHandler的invoke方法，然后执行InvocationHandler的invoke方法，而在这个invoke方法又去掉Flyable的fly对应的反射的invoke方法，在调用这个invoke方法前已经先把Bird这个对象传入，并在调用之前或之后加入时间的计算。如果要生成日志代理对象，只有实现InvocationHandler的invoke方法，并在方法前或者后加上需要的操作。

但是这个还是不够完美，还是没有达到我们可以代理任何接口的动态代理，如果我们要实现代理任何接口的代理，那我们就要把Flyable的接口换成动态的就好。代码如下：

package com.sf.simba.dynamicproxy.fly;

import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;

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

/**
 * 动态代理生成类
 * @author -Simba-
 *
 */
public class Proxy {


public static Object newProxyInstance(Class<?> infc,InvocationHandler handler) throws Exception{
 String rn = "\r\n";
 String methodStr = "";
 //获得此接口的所有方法，即所有方法都要加代理
 Method[] methods = infc.getMethods();
 for(Method m : methods){
 methodStr +="@Override"+rn+ 
 "public  "+m.getReturnType().getName()+"  "+m.getName()+"(){"+rn+
  "try { "+rn+
  " java.lang.reflect.Method md = "+infc.getName()+".class.getMethod(\""+m.getName()+"\");"+rn+
  " handler.invoke(this,md);"+rn+
  "}catch(Exception e){" +rn+
  " e.printStackTrace();" +rn+
  "}"+rn+
  "}"+rn;
 }

 String classStr = "package com.sf.simba.dynamicproxy.fly; " +rn+
            "import com.sf.simba.dynamicproxy.fly.Flyable;" +rn+
            "import com.sf.simba.dynamicproxy.fly.InvocationHandler;" +rn+
        " public class TimeBirdProxy implements  "+ infc.getName()+" { "+ rn +

" private InvocationHandler handler;"+rn+

" public TimeBirdProxy(InvocationHandler handler){"+rn +
"super();" +rn +
" this.handler = handler;"+rn +
" }"+rn +

methodStr
+ rn +
"}";
   System.out.println("动态生成的代理类为：\n"+classStr);
   //定义动态文件生成到哪里叫什么名字
   String fileName = System.getProperty("user.dir")+"/src/com/sf/simba/dynamicproxy/fly/TimeBirdProxy.java";
   File file = new File(fileName);
   FileWriter fw = new FileWriter(file);
   //把字符串写入文件
   fw.write(classStr);
   fw.flush();
   fw.close();

   //获得编译器
   JavaCompiler complier = ToolProvider.getSystemJavaCompiler();
   StandardJavaFileManager fileManager = complier.getStandardFileManager(null, null, null);
   Iterable<? extends JavaFileObject> units = fileManager.getJavaFileObjects(fileName);
   CompilationTask task = complier.getTask(null, fileManager, null, null, null, units);
   //编译，生成字节码
   task.call();
   fileManager.close();

   URL[] url = new URL[]{new URL("file:/"+System.getProperty("user.dir")+"/src/")};
   //加载字节码
   URLClassLoader classloder = new URLClassLoader(url);
   Class<?> loadClass = classloder.loadClass("com.sf.simba.dynamicproxy.fly.TimeBirdProxy");
   //获得代理对象构造方法
   Constructor<?> constructor = loadClass.getConstructor(InvocationHandler.class);
   //生成代理对象实例

   Object newInstance = constructor.newInstance(handler);//new Bird()为被代理对象
   System.out.println("-------------------生成的对象类为:"+newInstance.getClass().getName());
   return newInstance;


}

}

测试类：

package com.sf.simba.dynamicproxy.fly;
/**
 * 测试类
 * @author -Simba-
 *
 */
public class ProxyMain {

public static void main(String[] args) throws Exception {
Flyable bird = new Bird();
InvocationHandler handler = new TimeHandler(bird);
Flyable timeproxy = (Flyable)Proxy.newProxyInstance(Flyable.class,handler);
timeproxy.fly();

}
}

生成结果如下：

动态生成的代理类为：
package com.sf.simba.dynamicproxy.fly;
import com.sf.simba.dynamicproxy.fly.Flyable;
import com.sf.simba.dynamicproxy.fly.InvocationHandler;
public class TimeBirdProxy implements com.sf.simba.dynamicproxy.fly.Flyable {
private InvocationHandler handler;
public TimeBirdProxy(InvocationHandler handler){
super();
this.handler = handler;
}
@Override
public void fly(){
try {
java.lang.reflect.Method md = com.sf.simba.dynamicproxy.fly.Flyable.class.getMethod("fly");
handler.invoke(this,md);
}catch(Exception e){
e.printStackTrace();
}
}

}
-------------------生成的对象类为:com.sf.simba.dynamicproxy.fly.TimeBirdProxy
The bird is flying.......
TimeBirdProxy: The Flyable has flown 1960 millisecond

至此，动态代理的模拟已经完成，而JDK下的动态代理比这个更加复杂，加上了参数和一个类实现多个接口的情况，并且JDK动态代理中是直接把java类生成二进制文件，而不是像本文中通过JavaComplier生成字节码然后在生成二进制加入到内存。

秒客网

JAVA动态代理模拟

JAVA动态代理模拟

代理分类

静态代理

动态代理

相关文章