Java中的动态代理

来源：互联网发布：埙淘宝编辑：程序博客网时间：2024/05/22 17:52

动态代理在Java中是很重要的一部分，在很多框架中都会用到，如Spring中的AOP、Hadoop中的RPC等。为此在这把我对Java中的动态代理的理解分享给大家，同时写了一个模拟AOP编程的实例。（Demo实例提供下载）

引入场景

如果要对第三方提供的JAR包中的某个类中的某个方法的前后加上自己的逻辑，比如打LOG，注意此时我们只有第三方提供的CLASS文件，因此根本不可能去修改别人的源代码，那该怎么办？

有两种方法可以实现，一种是利用继承，另一种是利用聚合。举例说明：

假设第三方中提供一个Run接口，里面只一个run方法，以及它的实现类Person。

Run.java

Java代码

package com.cloud.proxy.example;
public interface Run {
public void run();
}

Person.java

Java代码

package com.cloud.proxy.example;
public class Person implements Run {
@Override
public void run() {
System.out.println("person running...");
}
}

第一种利用继承实现

SuperMan1.java

Java代码

package com.cloud.proxy.example;
public class SuperMan1 extends Person {
@Override
public void run() {
//方法开始前打LOG
LOG.info("super man1 before run...");
super.run();
//方法结束后打LOG
LOG.info("super man1 after run...");
}
}

第二种利用聚合实现

SuperMan2.java

Java代码

package com.cloud.proxy.example;
public class SuperMan2 implements Run {
private Run person;
public SuperMan2(Run person) {
this.person = person;
}
@Override
public void run() {
//方法开始前打LOG
LOG.info("super man2 before run...");
person.run();
//方法结束后打LOG
LOG.info("super man2 after run...");
}
}

这两种实现方式，哪一种更好呢？

显然是第二种利用聚合实现方法好，因为这种方式很灵活，同时又不会有多层的父子类关系。而继承最不好的地方就是不灵活，同时会很容易形成臃肿的父子类关系，不利于后期的维护。

点题

其实SuperMan1类和SuperMan2类都是Person类的代理类，对Person类中的方法进行加强，只不过这种代理是静态代理，很受限制。因为SuperMan1和SuperMan2只能代理Run类型的类，其它类型没法代理。为了解决这个问题，Java中引入动态代理。

理解动态代理

看了上面的分析，动态代理的意思就是一个类的（比如Person）的代理类（比如SuperMan2）是动态生成的，也就是说这个代理类不是提前写好的，是在程序运行时动态的生成的。而且能够代理实现了某个接口的任何类型的类。我们暂且把动态代理这个过程当作一个黑箱子，然后看它的输入和输出。对于输入，就是要被代理的类和它实现的接口，对于输出就是代理类，如图所示：

分析动态代理过程

根据上图，我们大致可以得知动态代理会有这样的过程：

1.根据输入的接口，利用反射机制，肯定可以拿到有哪些方法；

2.根据输入的被代理类，同样利用反射机制，肯定去调用其实现的方法。

到了这里，好像少了一点东西，就是少了对某个方法的前后的加强的逻辑。那么该如何解决这个问题呢？为此，我们必须对输入进行改造，如图：

看图我们可以发现，被代理类不是直接给黑箱子了，而是先给Handler这样的一个类，再给黑箱子，那么在Handler类中我们就是添加相应的加强的逻辑了。

Java中的动态代理

其实上面对动态代理的分析过程，也就是Java中动态代理的过程。我们来一一对应一下：

黑箱子：就是Java中的Proxy类；

Handler：就是Java中的InvocationHandler的子类。

利用Proxy类中的newProxyInstance静态方法，就可以动态生成一个代理类。这个方法有三个参数：

第一个是要一个类加载器，它的作用是将动态生成的代理类的字节码文件加载到JVM虚拟机中，一般我们可以用被代理类的加载器；

第二个是被代理类实现的接口的Class类；

第三个是InvocationHandler的子类，在这个类中的invoke方法中，对某个方法的前后加入加强的逻辑。

实例

这个实例是简单的模拟Spring是的AOP机制，即只要我们在配置文件打开了事务机制，那么在调用方法时就会开启事务，同样我们在配置文件关闭了事务机制，那么在调用方法时就不会开启事务了。

AOP.java

Java代码

package com.cloud.proxy;
public interface AOP {
public void show(String str);
public String say(String str);
}

AOPImpl,java

Java代码

package com.cloud.proxy;
public class AOPImpl implements AOP {
@Override
public void show(String str) {
System.out.println("show: " + str);
}
@Override
public String say(String str) {
return "say: " + str;
}
}

AOPHandler.java

Java代码

package com.cloud.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Map;
public class AOPHandler implements InvocationHandler {
private Object obj;
private boolean flag;
public AOPHandler(Object obj) {
this.obj = obj;
}
public void setFlag(Map<String, String> config) {
if (null == config) {
flag = false;
} else {
if (config.containsKey("transaction") && "true".equalsIgnoreCase(config.get("transaction"))) {
flag = true;
} else {
flag = false;
}
}
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (flag) {
doBefore();
}
Object result = method.invoke(obj, args);
if (flag) {
doAfter();
}
return result;
}
private void doBefore() {
System.out.println("Transaction start...");
}
private void doAfter() {
System.out.println("Transaction commit...");
}
}

Client.java

Java代码

package com.cloud.proxy;
import java.lang.reflect.Proxy;
import com.cloud.proxy.util.JVMCache;
public class Client {
public static void main(String[] args) throws Exception {
AOPImpl impl = new AOPImpl();
AOPHandler handler = new AOPHandler(impl);
handler.setFlag(JVMCache.getConfig());
AOP aop = (AOP) Proxy.newProxyInstance(AOPImpl.class.getClassLoader(), new Class<?>[] {AOP.class}, handler);
aop.show("cloud");
String result = aop.say("芝加哥09");
System.out.println(result);
}
}

JVMCache.java

Java代码

package com.cloud.proxy.util;
import java.util.Map;
public class JVMCache {
private static Map<String, String> config;
public synchronized static Map<String, String> getConfig() throws Exception {
if (null == config) {
config = XMLUtil.parseXML();
}
return config;
}
}

XMLUtil.java

Java代码

package com.cloud.proxy.util;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class XMLUtil {
public static Map<String, String> parseXML() throws Exception {
Map<String, String> result = new HashMap<String, String>();
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
InputStream in = XMLUtil.class.getClassLoader().getResourceAsStream("config.xml");
Document document = db.parse(in);
Element root = document.getDocumentElement();
NodeList xmlNodes = root.getChildNodes();
for (int i = 0; i < xmlNodes.getLength(); i++) {
Node config = xmlNodes.item(i);
if (null != config && config.getNodeType() == Node.ELEMENT_NODE) {
String nodeName = config.getNodeName();
if ("transaction".equals(nodeName)) {
String textContent = config.getTextContent();
result.put("transaction", textContent);
}
}
}
return result;
}
}

config.xml

Xml代码

<?xml version="1.0" encoding="UTF-8"?>
<config>
<transaction>true</transaction>
</config>

运行结果

当config.xml文件中配置为true时，运行结果：

运行结果代码

Transaction start...
show: cloud
Transaction commit...
Transaction start...
Transaction commit...
say: 芝加哥09

我们可以发现，在执行每个方法的前会开启事务，每个方法后提交事务。

当config.xml文件中配置为false时，运行结果：

运行结果代码

show: cloud
say: 芝加哥09

我们可以发现这样就可以将事务机制关掉。

这样我们模拟了一个AOP编程。

0 0