JVM 类加载及执行子系统的案例与实战

最新推荐文章于 2024-05-04 10:26:26 发布
最新推荐文章于 2024-05-04 10:26:26 发布
阅读量277 收藏
点赞数
分类专栏： JVM Java 深入理解JVM虚拟机 文章标签： JVM 远程执行代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wxpqqa/article/details/84549049
版权

本章内容稍作改变，首先介绍一下代理模式和动态代理模式，然后来实现本章提到的实战内容。

1. 代理

所谓代理及让别人来帮你做事，就像生产厂商在各地有代理商来帮他们卖产品(此处只关心买产品的功能)。

1.1 类结构图

-w451

1.2 代码实现
public class ProxyTest {

    interface ISales {
        void sell();
    }

    static class Manufacturer implements ISales {
    
        @Override
        public void sell() {
            System.out.println("卖产品");
        }
    }

    static class Agent implements ISales {
        private Manufacturer manufacturer;
        Agent() {
            manufacturer = new Manufacturer();
        }

        @Override
        public void sell() {
            manufacturer.sell();
        }
    }

    public static void main(String[] args) {
        Agent agent = new Agent();
        agent.sell();
    }
}

在使用第三方库的时候，可以采用代理模式对其进行封装。就图片加载库而言，如果不对其封装，那么这个图片加载库的调用将在项目中到处存在，如果某天需要更快图片加载库，那么需要改动的代码会很多，很容易出错。而采用代理模式对其封装后，就只需要修改代理类即可。

2. 动态代理模式

在上述代理模式中，代理者需要知道被代理对象。而动态代理是代理者不需要知道被代理对象。

在Java中，动态代理需要实现InvocationHandler接口，并实现invoke(Object proxy, Method method, Object[] args)方法。

对上面类进行改造，采用动态代理的方式实现：

2.1 类结构图

-w347

2.2 代码实现
package com.teemo.jvm.chapter9;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class DynamicProxyTest1 {

    interface  ISales {
        void sell();

        void buy();
    }

    /**
     * 需要被代理的类
     */
    static class Manufacturer implements ISales {

        @Override
        public void sell() {
            System.out.println("卖产品");
        }

        @Override
        public void buy() {
            System.out.println("买产品");
        }
    }

    /**
     * 代理类
     */
    static class DynamicProxy implements InvocationHandler {
        private Object originObj;
        Object bind(Object obj) {
            this.originObj = obj;
            // 生成代理类
            return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println(proxy.getClass().getName());
            System.out.println("代理商");
            // 调用需要被代理类的方法
            return method.invoke(originObj, args);
        }
    }

    public static void main(String[] args) {
        // 调用代理类的功能
        ISales iSales = (ISales) new DynamicProxy().bind(new Manufacturer());
        iSales.buy();
        iSales.sell();
    }
}

在上述代码中需要注意的地方有两个

  1. Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);

这代码的目的是通过Proxy.newProxyInstance()创建一个代理类。

  1. ISales iSales = (ISales) new DynamicProxy().bind(new Manufacturer());

这代码的目的是将被代理类与代理类进行绑定，并返回被代理对象，其中 new Manufacturer()指的是被代理对象。置于这里返回的对象类型是ISales的原因是, 1 中返回的类为 $Proxy0， 它实现了ISales接口。

3. 远程执行代码的实现

执行入口

@RequestMapping(name = "/execute")
    public String execute() {
        try {
            File file = new File("/Users/SinPingWu/TestClass.class");
            FileInputStream fileInputStream = new FileInputStream(file);
            BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
            int byteLength = bufferedInputStream.available();
            byte[] clazzBytes = new byte[byteLength];
            bufferedInputStream.read(clazzBytes);

            String result = JavaClassExecuter.execute(clazzBytes);
            System.out.println(result);
            return result;
        } catch (Exception e) {
            e.printStackTrace();
            return e.getMessage();
        }
    }

执行方法

public class JavaClassExecuter {

    /**
     * 执行外部传过来的代表一个Java类的Byte数组
     *
     * 将输入类的byte数组中代表java.lang.System 的 CONSTANT_Utf8_info 常量修改为劫持后的 HackSystem类
     * 执行方法为该类的static main(String[] args)方法, 输出结果为该类向 System.out/err输出的信息
     * @param classByte 代表一个Java类的 byte数组
     * @return 执行结果
     */
    public static String execute(byte[] classByte) {
        HackSystem.clearBuffer();

        ClassModifier cm = new ClassModifier(classByte);
        byte[] modiBytes = cm.modifyUtf8Constant("java/lang/System", "com/youye/remote/HackSystem");
        HotSwapClassLoader loader = new HotSwapClassLoader();
        Class clazz = loader.loadByte(modiBytes);
        try {
            Method method = clazz.getMethod("main", new Class[] { String[].class});
            method.invoke(null, new String[] {null});
        } catch (Exception e) {
            e.printStackTrace();
        }

        return HackSystem.getBufferString();
    }
}

类文件的字节码修改器：

public class ClassModifier {

    /**
     * Class 文件中常量池的起始偏移地址
     */
    private static final int CONSTANT_POOL_COUNT_INDEX = 8;

    /**
     * CONSTANT_Utf8_info 常量的tag标志
     */
    private static final int CONSTANT_Utf8_info = 1;

    /**
     * 常量池中14中常量所占的长度，CONSTANT_Utf8_info 型常量除外，因为它不是定长的
     *
     * 每种常量都有一个tag标签，根据tag的值来获取常量所占的长度，tag最大值为18.
     */
    private static final int[] CONSTANT_ITEM_LENGTH = {-1, -1, 5, -1, 5, 9, 9, 3, 3, 5, 5, 5, 5, -1, -1, 4, 3, -1, 5};

    private static final int u1 = 1;

    private static final int u2 = 2;

    private byte[] classByte;

    public ClassModifier(byte[] classByte) {
        this.classByte = classByte;
    }

    /**
     * 修改常量池中CONSTANT_Utf8_info常量的内容
     * @param oldStr 修改前的字符串
     * @param newStr 修改后的字符串
     * @return 修改结果
     */
    public byte[] modifyUtf8Constant(String oldStr, String newStr) {
        int cpc = getConstantPoolCount();
        int offset = CONSTANT_POOL_COUNT_INDEX + u2;
        for (int i = 0; i < cpc; i++) {
            int tag = ByteUtils.bytes2Int(classByte, offset, u1);
            if (tag == CONSTANT_Utf8_info) {
                // 获取CONSTANT_Utf8_info常量的Utf-8编码的字符串占用的字节数
                int len = ByteUtils.bytes2Int(classByte, offset + u1, u2);
                offset += (u1 + u2);
                // 获取该CONSTANT_Utf8_info常量所对应的字符串内容
                String str = ByteUtils.bytes2String(classByte, offset, len);
                if (str.equalsIgnoreCase(oldStr)) {
                    // 将newStr转换成byte[]
                    byte[] strBytes = ByteUtils.string2Bytes(newStr);
                    // 获取字符串长度对应的所占u2字节的byte[]
                    byte[] strLen = ByteUtils.int2Bytes(newStr.length(), u2);
                    // 替换CONSTANT_Utf8_info常量中代表Utf-8编码的字符串所占用的字节长度
                    classByte = ByteUtils.bytesReplace(classByte, offset - u2, u2, strLen);
                    // 替换字符串内容
                    classByte = ByteUtils.bytesReplace(classByte, offset, len, strBytes);

                    return classByte;
                } else {
                    offset += len;
                }
            } else {
                offset += CONSTANT_ITEM_LENGTH[tag];
            }
        }

        return classByte;
    }

    /**
     * 获取常量池中常量的数量
     *
     * @return 常量池数量
     */
    public int getConstantPoolCount() {
        // 在常量池中，第9-10的两个字节代表常量的数量
        return ByteUtils.bytes2Int(classByte, CONSTANT_POOL_COUNT_INDEX, u2);
    }
}

byte[] 转换工具

public class ByteUtils {

    public static int bytes2Int(byte[] b, int start, int len) {
        int sum = 0;
        int end = start + len;
        for (int i = start; i < end; i++) {
            // 将b[i] 转成二进制，并取低8位，
            // 因为0xff高8位全为0，低0位全为1，任何数A与0xff,导致A的高位全为0，低8位不变。
            int n = ((int) b[i]) & 0xff;
            // 高8位左移8位，低8位不变
            n <<= (--len) * 8;
            sum = n + sum;
        }
        return sum;
    }

    public static byte[] int2Bytes(int value, int len) {
        byte[] b = new byte[len];
        for (int i = 0; i < len; i++) {
            b[len - i - 1] = (byte) ((value >> 8 * i) & 0xff);
        }

        return b;
    }

    public static String bytes2String(byte[] b, int start, int len) {
        return new String(b, start, len);
    }

    public static byte[] string2Bytes(String str) {
        return str.getBytes();
    }

    public static byte[] bytesReplace(byte[] originalBytes, int offset, int len, byte[] replaceBytes) {
        byte[] newBytes = new byte[originalBytes.length + (replaceBytes.length - len)];

        System.arraycopy(originalBytes, 0, newBytes, 0, offset);
        System.arraycopy(replaceBytes, 0, newBytes, offset, replaceBytes.length);
        System.arraycopy(originalBytes, offset + len, newBytes, offset + replaceBytes.length, originalBytes.length - offset - len);

        return newBytes;
    }
}

输出函数

public class HackSystem {

    public final static InputStream in = System.in;

    private static ByteArrayOutputStream buffer = new ByteArrayOutputStream();

    public final static PrintStream out = new PrintStream(buffer);

    public final static PrintStream err = out;

    public static String getBufferString() {
        return buffer.toString();
    }

    public static void clearBuffer() {
        buffer.reset();
    }

    public static void setSecurityManager(final SecurityManager s) {
        System.setSecurityManager(s);
    }

    public static SecurityManager getSecurityManager() {
        return System.getSecurityManager();
    }

    public static long currentTimeMillis() {
        return System.currentTimeMillis();
    }

    public static long nanoTime() {
        return System.nanoTime();
    }

    public static void arrayCopy(Object src, int srcPos, Object dest, int destPos, int length) {
        System.arraycopy(src, srcPos, dest, destPos, length);
    }

    public static int identityHashCode(Object x) {
        return System.identityHashCode(x);
    }

    public static Console console() {
        return System.console();
    }

    public static Channel inheritedChannel() throws IOException {
        return System.inheritedChannel();
    }

    public static Properties getProperties() {
        return System.getProperties();
    }

    public static String lineSeparator() {
        return System.lineSeparator();
    }

    public static void setProperties(Properties props) {
        System.setProperties(props);
    }

    public static String getProperty(String key) {
        return System.getProperty(key);
    }

    public static String getProperty(String key, String def) {
        return System.getProperty(key, def);
    }

    public static String setProperty(String key, String value) {
        return System.setProperty(key, value);
    }

    public static String clearProperty(String key) {
        return System.clearProperty(key);
    }

    public static String getenv(String name) {
        return System.getenv(name);
    }

    public static java.util.Map<String, String> getenv() {
        return System.getenv();
    }

    public static void exit(int status) {
        System.exit(status);
    }

    public static void gc() {
        System.gc();
    }

    public static void runFinalization() {
        System.runFinalization();
    }

    public static void runFinalizersOnExit(boolean value) {
        System.runFinalizersOnExit(value);
    }

    public static void load(String filename) {
        System.load(filename);
    }

    public static void loadLibrary(String libname) {
        System.loadLibrary(libname);
    }

    public static void mapLibraryName(String libname) {
        System.mapLibraryName(libname);
    }

}

类加载器

public class HotSwapClassLoader extends ClassLoader{

    public HotSwapClassLoader() {
        super(HotSwapClassLoader.class.getClassLoader());
    }

    public Class loadByte(byte[] classByte) {
        return defineClass(null, classByte, 0, classByte.length);
    }
}

具体代码请见https://github.com/SinPingWu/MiChatServer.git 的RemoteExecuteController。欢迎fork and start

第9章 类加载及执行子系统的案例与实战
lyw4631的博客
08-12 375
文章目录9.1 概述9.2 案例分析9.2.1 Tomcat：正统的类加载器架构9.2. 2 OSGi：灵活的类加载器架构9.2.3 字节码生成技术与动态代理的实现9.2.4 Backport工具：Java的时光机器9.3 实战：自己动手实现远程执行功能9.4 本章小结 第9章 类加载及执行子系统的案例与实战    代码编译的结果从本地机器码转变为字节码，是存储格式发展的一小步，却是编程语言发展的一大步。 9.1 概述    在Class文件格式与执行引擎这部分里，用户的程序能直接参与的内容并不太多，Cla
类加载及执行子系统的案例与实战
青葱暖咖啡
01-10 209
类加载及执行子系统的案例与实战 在Class文件格式与执行引擎这部分里，用户的程序能直接影响的内容并不太多。能通过程序进行操作的，主要是字节码生成与类加载器这两部分的功能。 .1 Tomcat：正统的类加载器架构 主流的Java Web服务器，如Tomcat、Jetty、WebLogic、WebSphere或其他笔者没有列举的服务器，都实现了自己定义的类加载器 在Tomcat目录结构中，一共四组，...
类加载及执行子系统的案例与实践
jiaxiuya的专栏
07-23 627
1：案例分析1.1 Tomcat：正统的类加载器架构    一个功能鉴权的Web服务器，需要解决的问题： 部署在同一服务器上的两个Web应用程序所使用的Java类库可以实现相互隔离。 服务器需要尽可能的保证自身的安全不受部署的Web应用程序影响。 支持Jsp应用的Web服务器，大多数都要支持HotSwap功能。     对于Tomcat5.X的版本，存在common、server、shared、和应
Java类加载机制详解与实战项目案例分享
3. **初始化（Initialization）**：在这个阶段，执行类构造器`()`方法的过程。该方法是编译器收集类中所有类变量的赋值动作和静态代码块中的语句合并而来。 ### Java类加载器 类加载器（ClassLoader）是Java的核心...
讲透JVM类加载机制，向高手进阶！
石杉的架构笔记
10-03 471
今天，我们来搞清楚“类加载”这个过程，以后在面试时，对面试官常问的JVM类加载机制，就能把一些核心概念说清楚了。
自定义Java类加载器：深入理解JVM类加载机制及应用
本文全面介绍了Java类加载的基本概念、JVM中的类加载过程、自定义Java类加载器的原理与实践，以及类加载器的应用场景与案例分析。通过深入解析类的加载、链接和初始化阶段，阐述了双亲委派模型及其实现细节，讨论了...
《深入理解Java虚拟机 4》类加载与执行子系统的案例与实战
2401_83621384的博客
03-28 297
经过日积月累， 以下是小编归纳整理的深入了解Java虚拟机文档，希望可以帮助大家过关斩将顺利通过面试。由于整个文档比较全面，内容比较多，篇幅不允许，下面以截图方式展示。由于篇幅限制，文档的详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！vip1024b 备注Java获取（资料价值较高，非无偿）**[外链图片转存中…(img-hNQJLhCD-1711592154298)]
最新Java安全——JVM类加载器
最新发布
2401_82645688的博客
05-04 901
0x02 ClassLoader 类关系及类结构笔者本小节主要介绍ClassLoader的类结构以及类关系，ClassLoader在代码实现上是抽象类。这就意味着在程序中ClassLoader应该有很多的子类，那么ClassLoader及其子类中有什么关键类方法和类属性，在这一小节中进行介绍。
深入理解Java虚拟机--类加载及执行子系统的案例与实战xmind文件
03-15
深入理解Java虚拟机--类加载及执行子系统的案例与实战xmind文件
Java高级——类加载及执行子系统的案例与实战
松仔Log的博客
09-09 271
Class文件以何种格式存储、字节码指令如何执行等都是由JVM控制字节码生成与类加载器这两部分的功能，可由用户自定义，接下来将对一些实际应用进行介绍。
《深入理解Java虚拟机》读书笔记5——类加载及执行子系统的案例与实战
零下九度
12-13 1469
1.Tomcat：正统的类加载器架构 2.OSGi：灵活的类加载器架构         OSGi中的每个模块(成为Bundle)与普通的Java类库区别并不太大，两者一般都以JAR格式进行封装，并且内部存储的都是Java Package和Class。但是一个Bundle可以声明它所依赖的Java Package(通过Import-Package描述)，也可以声明它允许导出发布的
JVM第八卷---类加载与执行子系统的案例与实战
m0_53157173的博客
02-26 629
JVM第八卷---类加载与执行子系统的案例与实战类加载器服务器困境Tomcat: 正统的类加载架构OSGi：灵活的类加载器结构字节码生成技术与动态代理的实现实战：自己动手实现远程执行功能目标思路实现 类加载器 JVM第六卷—类加载机制中已经讲述了类加载器的相关知识，这里简单回顾一些重点 Java虚拟机设计团队有意把类加载阶段中的"通过一个类的全限定名来获取描述类的二进制字节流",这个动作放到Java虚拟机外部实现，以便让应用程序自己决定如何去获取所需的类，实现这个动作的代码被称为"类加载器" 比较两个类是
JVM之类加载及执行子系统的案例与实战（九）
qq_26564827的博客
06-04 490
在Class文件格式与执行引擎这部分中，用户能直接影响的内容并不多。能通过程序进行操作的，主要是字节码生成和类加载器这两部分功能，但仅仅在如何处理这两点上，就已经出现了许多值得欣赏和借鉴的思路，这些思路后来成为了许多常用的功能和程序实现的基础。 关于类加载器和字节码案例： 一、正统的类加载器架构 主流的java Web服务器如tomcat、Jetty、WebLogic、WebSphere等，...
jvm运行原理实例说明
Davin_（幸福在于感悟）..........
03-22 975
demo类如下，我们仅用此类来说明jvm运行过程与原理。 /** * @Title: JvmRunDemo.java * @Package: * @Desc: jvm运行demo * @Copyright: AsiaInfo-Linkage * @author: gaoyb * @date: Mar 22, 2012 7:4
JVM 之 运行原理及例子剖析
Dusty丶one的博客
04-26 314
前言 上一节中，我们学习了JVM的基本结构个内存结构(特指运行时数据区结构)，本节我们讲学习一下JVM的运行流程，并通过一个实际例子来剖析一下在运行时JVM是如何分配内存结构中各个组成部分工作的。 1、JVM运行原理 JVM 运行原理 说起Java，人们首先想到的是Java编程语言，然而事实上，Java是一种技术，它由四方面组成：Java编程语言、Java类文件格式、Java...
深入理解JVM——案例实战（一）
m0_58559010的博客
08-04 300
本文概述 排查Full Gc的套路是什么，这里用一个电商案例来进行说明。 spilt()方法是如何造成内存泄露的？如何通过可视化图形分析出问题。以及如何从源代码层面发现根本问题 思维导图： 电商案例-排查Full GC套路 主要业务： ​ 在日常场景进行发邮箱，短信以及APP 的推送消息一些特别活动。 ​ 这种业务的特点是短时间之内会有大量的用户进入APP进行参与，这时候系统的压力会突然增加。 问题： ​ 在业务流量高峰的时候，CPU的使用率十分十分高，并且直接导致系统卡死，无法进行任何
JVM 第四章 案例分析一
CopyCat
12-09 272
class文件案例分析
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值