个人认为动态代理在设计模式中算是比较难的, 本篇文章将从无到有, 从一个简单代码示例开始迭代, 逐步深入讲解动态代理思想.
Moveable
接口, 里面有一个move()
移动的方法. 代码如下:class Tank implements Moveable{
@Override
public void move(){
System.out.println("坦克开始移动...");
try {
Thread.sleep((long) (Math.random() * 5000));
System.out.println("坦克移动结束...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
interface Moveable{
public void move();
}
move()
方法的前后添加一些代码, 用于记录坦克move()
方法的执行时间.继承
的方式进行代理.class MoveTimeProxy1 extends Tank{
@Override
public void move() {
long start = System.currentTimeMillis();//开始时间
super.move();//调用坦克的move()方法
long end = System.currentTimeMillis();//结束时间
System.out.println("执行该方法用了" + (end - start) + "毫秒");
}
}
聚合
实现代理的方式class MoveTimeProxy2 implements Moveable{
Tank tank;
public MoveTimeProxy2(Tank tank){
this.tank = tank;
}
@Override
public void move() {
long start = System.currentTimeMillis();//开始时间
tank.move();//调用坦克的move()方法
long end = System.currentTimeMillis();//结束时间
System.out.println("执行该方法用了" + (end - start) + "毫秒");
}
}
继承
方式的代理会差一些. 想想看, 如果现在除了记录时间, 还要记录日志的话, 则要创建一个新的继承
代理类并重写move()
方法. 如果需求变更, 需要先记录日志, 再记录时间的话, 又要创建一个新的继承
代理类. 如此下去, 代理类的创建将没完没了.聚合
实现的代理类则灵活得多. 每一个聚合
代理类能够实现一种代理, 并且代理的顺序是可以替换的. 请看代码(聚合
代理类的代码有所修改)public class ProxyTest {
public static void main(String[] args) {
TimeProxy tp = new TimeProxy(new Tank());
LogProxy lp = new LogProxy(tp);
lp.move();
}
}
class TimeProxy implements Moveable{//记录时间的代理
Moveable m;//不再持有Tank引用, 而是持有Moveable接口引用
public TimeProxy(Moveable m){
this.m = m;
}
@Override
public void move() {
long start = System.currentTimeMillis();//开始时间
m.move();//调用move()方法
long end = System.currentTimeMillis();//结束时间
System.out.println("执行该方法用了" + (end - start) + "毫秒");
}
}
class LogProxy implements Moveable{//打印日志的代理
Moveable m;
public LogProxy(Moveable m){
this.m = m;
}
@Override
public void move() {
System.out.println("日志: 开始测试坦克移动...");
m.move();
System.out.println("日志: 坦克移动结束...");
}
}
?
代理
一词有更深刻的理解. 但是上面的代码中, 为坦克生成的代理类TimeProxy
是我们在代码中写死的, 所以这顶多算个静态代理, 如何通过动态的方式产生代理呢?聚合
代理方式通过持有某个接口的引用完成代理, 所以我们是针对某个接口产生代理, 而不是对某个具体的对象产生代理.Java
中的实现, 我们创建一个Proxy
类, 里面提供一个newProxyInstance()
方法, 用于返回一个代理. 我们希望通过如下代码就能动态生成一个代理.public static void main(String[] args) {
Tank tank = new Tank();
Moveable m = (Moveable)Proxy.newProxyInstance();//动态获得一个代理
m.move();
}
newProxyInstance()
方法中, 我们先把原来TimeProxy
的源代码以字符串的方式存放, 再通过写入文件的方式创建出TimeProxy.java
文件. 然后通过Java原生的编译api将TimeProxy.java
编译成TimeProxy.class
文件. 最后把该class文件加载到内存中, 并调用其构造方法创建对象, 返回该代理对象.class Proxy{
public static Object newProxyInstance() throws Exception {
//把整个TimeProxy类的实现写入字符串, 通过编译这一字符串得到TimeProxy对象
String src = "package designPattern.proxy;\n" +
"\n" +
"class TimeProxy implements Moveable{\n" +
" Moveable m;//不再持有Tank引用, 而是持有Moveable接口引用\n" +
"\n" +
" public TimeProxy(Moveable m){\n" +
" this.m = m;\n" +
" }\n" +
"\n" +
" @Override\n" +
" public void move() {\n" +
" long start = System.currentTimeMillis();//开始时间\n" +
" m.move();//调用坦克的move()方法\n" +
" long end = System.currentTimeMillis();//结束时间\n" +
" System.out.println(\"执行该方法用了\" + (end - start) + \"毫秒\");\n" +
" }\n" +
"}";
String filename = System.getProperty("user.dir")
+ "/src/main/java/designPattern/proxy/TimeProxy.java";//文件名(生成类的路径)
File f = new File(filename);
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//编译
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();//拿到系统当前默认的编译器, 即Javac
StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
Iterable units = fileManager.getJavaFileObjects(filename);//得到文件对象
JavaCompiler.CompilationTask t = compiler.getTask(null, fileManager, null, null, null, units);
t.call();//进行编译
fileManager.close();
//把class文件加载进内存并创建对象
URL[] urls = new URL[]{new URL("file:/" + System.getProperty("user.dir") + "/src")};
URLClassLoader ul = new URLClassLoader(urls);
Class c = ul.loadClass("designPattern.proxy.TimeProxy");//拿到class对象
Constructor ctr = c.getConstructor(Moveable.class);//拿到参数为Moveable的构造方法
Moveable m = (Moveable)ctr.newInstance(new Tank());//创建代理对象
return m;
}
}
moveable
接口的代理对象. 而上面我们提到过动态代理是基于某个接口的(聚合型代理), 所以我们希望能够动态地指定接口, 并生成相应的代理类.public class ProxyTest {
public static void main(String[] args) throws Exception {
Tank tank = new Tank();
Moveable m = (Moveable)Proxy.newProxyInstance(Moveable.class);//传入接口参数动态获得一个代理
m.move();
}
}
class Proxy{
public static Object newProxyInstance(Class intfce) throws Exception {
//把整个TimeProxy类的实现写入字符串, 通过编译这一字符串得到TimeProxy对象
String methodStr = "";
String n = "\n";
Method[] methods = intfce.getMethods();//拿到接口中的所有方法
for(Method m : methods){//拼接方法
methodStr += " @Override\n" +
" public void " + m.getName() + "() {\n" +
" long start = System.currentTimeMillis();//开始时间\n" +
" m.move();//调用坦克的move()方法\n" +
" long end = System.currentTimeMillis();//结束时间\n" +
" System.out.println(\"执行该方法用了\" + (end - start) + \"毫秒\");\n" +
" }\n";
}
//拼接出整个类
String src = "package designPattern.proxy;\n" +
"\n" +
"class TimeProxy implements " + intfce.getName() + "{\n" +
" Moveable m;//不再持有Tank引用, 而是持有Moveable接口引用\n" +
"\n" +
" public TimeProxy(Moveable m){\n" +
" this.m = m;\n" +
" }\n" +
"\n" + methodStr +
"}";
String filename = System.getProperty("user.dir")
+ "/src/main/java/designPattern/proxy/TimeProxy.java";//文件名(生成类的路径)
File f = new File(filename);
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//编译
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();//拿到系统当前默认的编译器, 即Javac
StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
Iterable units = fileManager.getJavaFileObjects(filename);//得到文件对象
JavaCompiler.CompilationTask t = compiler.getTask(null, fileManager, null, null, null, units);
t.call();//进行编译
fileManager.close();
//把class文件加载进内存并创建对象
URL[] urls = new URL[]{new URL("file:/" + System.getProperty("user.dir") + "/src")};
URLClassLoader ul = new URLClassLoader(urls);
Class c = ul.loadClass("designPattern.proxy.TimeProxy");//拿到class对象
Constructor ctr = c.getConstructor(Moveable.class);//拿到参数为Moveable的构造方法
Object m = ctr.newInstance(new Tank());//创建代理对象
return m;
}
}
?
TimeProxy
), 输出日志(LogProxy
), 事务操作等等.InvocationHandler
接口, 并在它的实现类中给出具体的操作. 我们以初始的记录时间操作为例.public class ProxyTest {
public static void main(String[] args) throws Exception {
Tank tank = new Tank();
InvocationHandler h = new TimeHandler(tank);
Moveable m = (Moveable)Proxy.newProxyInstance(Moveable.class, h);//动态获得一个代理
m.move();
}
}
interface InvocationHandler{
public void invoke(Object o, Method m);//参数o指定执行对象(代理对象, 可能会用到), m指定执行的方法
}
class TimeHandler implements InvocationHandler{
private Object target;
public TimeHandler(Object target){
this.target = target;
}
@Override
public void invoke(Object o, Method m) {
long start = System.currentTimeMillis();//这行是用户自己加的增强代码
try{
m.invoke(target);
} catch (Exception e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();//这行是用户自己加的增强代码
System.out.println("执行该方法用了" + (end - start) + "毫秒");//这行是用户自己加的增强代码
}
}
class Proxy{
public static Object newProxyInstance(Class intfce, InvocationHandler h) throws Exception {
//把整个TimeProxy类的实现写入字符串, 通过编译这一字符串得到TimeProxy对象
String methodStr = "";
Method[] methods = intfce.getMethods();//拿到接口中的所有方法
for(Method m : methods){//拼接方法
methodStr += " @Override\n" +
" public void " + m.getName() + "() {\n" +
" try{\n" +
" Method md = " + intfce.getName() + ".class.getMethod(\"" + m.getName() + "\");\n" +
" h.invoke(this, md);\n" +
" }catch(Exception e){e.printStackTrace();}\n" +
" }\n";
}
//拼接出整个类
String src = "package designPattern.proxy;\n" +
"import java.lang.reflect.Method;\n" +
"\n" +
"class $Proxy1 implements " + intfce.getName() + "{\n" +
" designPattern.proxy.InvocationHandler h;\n" +
"\n" +
" public $Proxy1(InvocationHandler h){\n" +
" this.h = h;\n" +
" }\n" +
"\n" + methodStr +
"}";
String filename = System.getProperty("user.dir")
+ "/src/main/java/designPattern/proxy/$Proxy1.java";//文件名(生成类的路径)
File f = new File(filename);
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//编译
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();//拿到系统当前默认的编译器, 即Javac
StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
Iterable units = fileManager.getJavaFileObjects(filename);//得到文件对象
JavaCompiler.CompilationTask t = compiler.getTask(null, fileManager, null, null, null, units);
t.call();//进行编译
fileManager.close();
//把class文件加载进内存并创建对象
URL[] urls = new URL[]{new URL("file:/" + System.getProperty("user.dir") + "/src")};
URLClassLoader ul = new URLClassLoader(urls);
Class c = ul.loadClass("designPattern.proxy.$Proxy1");//拿到class对象
Constructor ctr = c.getConstructor(InvocationHandler.class);//拿到参数为Moveable的构造方法
Object m = ctr.newInstance(h);//创建代理对象
return m;
}
}
class Tank implements Moveable{
@Override
public void move(){
System.out.println("坦克开始移动...");
try {
Thread.sleep((long) (Math.random() * 5000));
System.out.println("坦克移动结束...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//输出结果
坦克开始移动...
坦克移动结束...
执行该方法用了4302毫秒
?
Moveable
接口, 而Tank
坦克类实现了Moveable
接口, 并实现了move()
方法.move()
方法进行增强, 比如说记录这个方法的执行时间, 我们需要动态地获得一个代理类.InvocationHandler
接口, 里面有一个invoke(Object o, Method m)
方法. 调用invoke()
方法时, 需要传递两个参数, 一个是代理对象的引用o
(可能会用上), 另一个是需要被增强的方法, 本例中是move()
方法.invoke()
方法中我们可以在被增强方法的前后添加增强代码.public void invoke(Object o, Method m) {
long start = System.currentTimeMillis();//这行是用户自己加的增强代码
try{
m.invoke(target);//执行被增强的方法, 例子中的move()
} catch (Exception e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();//这行是用户自己加的增强代码
System.out.println("执行该方法用了" + (end - start) + "毫秒");//这行是用户自己加的增强代码
}
InvocationHandler
的具体对象, 比如这里的TimeHander
, 需要传入被增强的对象, 这里是tank
, 因为被增强方法move()
需要由被增强对象执行.?
InvocationHandler
后, 回头看为我们动态产生代理的Proxy
类, 这个类需要有一个属性字段InvocationHandler h
, 因为在进行增强时, 调用的是InvocationHandler
实现类中的invoke()
方法. 在动态代理进阶
一节的最后版本代码中, 我们动态生成的代理类源码是这样的:class $Proxy1 implements designPattern.proxy.Moveable{
designPattern.proxy.InvocationHandler h;
public $Proxy1(InvocationHandler h){
this.h = h;
}
@Override
public void move() {
try{
Method md = designPattern.proxy.Moveable.class.getMethod("move");
h.invoke(this, md);
}catch(Exception e){e.printStackTrace();}
}
}
move()
方法进行增强时, 会调用InvocaitonHandler
的实现类中的invoke()
方法, 传入代理类自身和被增强的方法, 这样就可以使用自定义的增强代码进行增强了.?
原文:https://www.cnblogs.com/tanshaoshenghao/p/10765360.html