吃透Java中的动态代理
来源:互联网 发布:时时彩合买源码 编辑:程序博客网 时间:2024/05/16 12:37
动态代理在Java中是很重要的一部分,在很多框架中都会用到,如Spring中的AOP、Hadoop中的RPC等。为此在这把我对Java中的动态代理的理解分享给大家,同时写了一个模拟AOP编程的实例。(Demo实例提供下载)
引入场景
如果要对第三方提供的JAR包中的某个类中的某个方法的前后加上自己的逻辑,比如打LOG,注意此时我们只有第三方提供的CLASS文件,因此根本不可能去修改别人的源代码,那该怎么办?
有两种方法可以实现,一种是利用继承,另一种是利用聚合。举例说明:
假设第三方中提供一个Run接口,里面只一个run方法,以及它的实现类Person。
Run.java
package com.cloud.proxy.example;public interface Run { public void run();}
Person.java
package com.cloud.proxy.example;public class Person implements Run { @Override public void run() { System.out.println("person running..."); }}
第一种利用继承实现
SuperMan1.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
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
package com.cloud.proxy;public interface AOP { public void show(String str); public String say(String str);}
AOPImpl,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
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
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
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
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 version="1.0" encoding="UTF-8"?><config> <transaction>true</transaction></config>
运行结果
当config.xml文件中配置为true时,运行结果:
Transaction start...show: cloudTransaction commit...Transaction start...Transaction commit...say: 芝加哥09
我们可以发现,在执行每个方法的前会开启事务,每个方法后提交事务。
当config.xml文件中配置为false时,运行结果:
show: cloudsay: 芝加哥09
我们可以发现这样就可以将事务机制关掉。
这样我们模拟了一个AOP编程。
- 吃透Java中的动态代理
- 吃透Java中的动态代理
- java中的动态代理
- java中的动态代理》》》》》
- JAVA 中的 动态代理
- java中的动态代理
- java中的动态代理
- Java中的动态代理
- Java中的动态代理
- JAVA中的动态代理
- java中的动态代理
- java中的动态代理
- java 中的动态代理
- Java中的动态代理
- java中的动态代理
- Java中的动态代理
- java中的动态代理
- java中的动态代理
- 设计模式——六大原则
- 手动内存管理转ARC项目实战
- 一步一步学zedboard之七单独编译u-boot
- javascript异步加载方式方法及思考
- 指针操作
- 吃透Java中的动态代理
- github简单使用教程
- CentOS 7 DNS服务器架设
- JAVAWEB项目如何实现验证码
- Unity3D 人形血条制作小知识
- 正则表达式
- 软件测试职业发展,到底该向何处?
- lua基础01
- MapReduce作业shuffle分析