动态代理在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: cloud
Transaction commit...
Transaction start...
Transaction commit...
say: 芝加哥09
我们可以发现,在执行每个方法的前会开启事务,每个方法后提交事务。
当config.xml文件中配置为false时,运行结果:
show: cloud
say: 芝加哥09
我们可以发现这样就可以将事务机制关掉。
这样我们模拟了一个AOP编程。
相关推荐
Java中的String类是编程中最常用的数据结构之一,它在日常开发中扮演着至关重要的角色。本文将深入探讨String类的特性、构造、方法以及在内存中的表现,帮助你全面理解这个核心类。 首先,String类在Java中是不可变...
全面吃透JAVA Stream流操作,让代码更加的优雅 (2023_4_6 11_01_07).html
资料及代码 一、互联网并发编程 五、数据库设计与优化 四、Linux部分 ...三、JAVA虚拟机 七、互联网框架应用 六、互联网中间件架构设计 二、互联网网络通信编程 八、互联网分布式综合项目实战
因为太大存入百度云盘, 因为,描述字数有限制 下面目录只是部分 阶段01: Java语言基础(JDK17) 阶段02: MySQL数据库技术 阶段03: Web开发与实战 阶段04: Web框架核心技术 阶段05:项目—:权限管理系统 阶段06:...
由浅入深吃透 Docker,资源失效留言,包你满意
在本资料中,从入门到精通的《吃透PID 2.0》主要介绍了自动调节系统的概念、发展、以及PID(比例-积分-微分)控制器的相关知识。 在自动调节系统的发展历程中,我们可以追溯到中国古代的发明,例如指南车,该发明...
负反馈的概念是控制论中的核心,通过比较系统输出与期望值之间的偏差,然后反向调整输入,以减少这种偏差。 1-4【PID控制器的引入】PID控制器是一种基于误差的控制器,P代表比例作用,它立即响应误差的大小;I代表...
List是Java中最常用的集合类型,但其操作不当可能导致意外的元素丢失、重复或顺序混乱。文档可能详细解释了常见的错误用法,如并发修改异常、未初始化的列表引用、遍历时修改列表等,并提供了最佳实践。 "加餐1丨带...
在“由入门到精通吃透PID.pdf”这本书中,你将详细学习到PID控制器的数学模型,了解它们如何影响系统行为。同时,书中还会介绍不同的PID控制策略,如PI、PD和纯比例控制,以及自适应PID、模糊PID等高级应用。此外,...
在 Java 学习中,需要注意基础的重要性,基础一定要打扎实,吃透,否则上层建筑的建起就不会很顺利甚至没法起步。 在 JavaWeb 方向的学习中,需要学习 JSP、JavaBean、Servlet、JDBC 技术等,都是 Java 学习的重要...
标签:“吃透PID”反映了本文的核心目标,就是让读者不仅理解PID的基础知识,还要能够深入掌握并应用到实际的工程实践中去。 内容部分包含的PID参数调整的数值和公式,虽然因OCR扫描错误显得混乱,但可以推断出包含...
- **控制论**:20世纪中叶,诺伯特·维纳提出了控制论这一学科,它是研究动态系统控制和通信的一门跨学科科学,为现代自动控制理论奠定了基础。 - **PID**:比例-积分-微分控制器(Proportional-Integral-...
在“从入门到精通吃透PID.pdf”这份资料中,读者将学习到如何分析系统特性,选择合适的PID结构,以及如何通过实验或软件工具进行参数调试。此外,还会深入探讨PID在不同应用场景下的具体实现,如温度控制、速度控制...
03 反向压力:如何避免异步系统中的 OOM 问题?.md 04 流与异步:为什么说掌握流计算先要理解异步编程?.md 05 有向无环图(DAG):如何描述、分解流计算过程?.md 06 CompletableFuture:如何理解 Java 8 ...
### 入门到精通吃透PID #### 自动调节系统的发展历程 - **1-1 中国古代的自动调节系统**:自动调节系统的历史可以追溯到古代中国,早在几千年前,中国的工匠们就已经能够设计出具备一定自动调节功能的装置,如水钟...
本书“由入门到精通-吃透PID第二版”深入浅出地介绍了PID控制器的基本概念、工作原理以及在实际应用中的调参技巧。无论你是自动化领域的初学者还是有经验的工程师,都能从中获得宝贵的理论知识和实践经验。通过阅读...