Java实现Modbus Tcp协议读写模拟工具数据

已于 2023-09-21 14:57:22 修改
阅读量3.2k 收藏 26
点赞数 3
分类专栏： Java后端相关随笔 文章标签： java tcp/ip
于 2023-09-18 14:23:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39615182/article/details/132975277
版权

标题

前言

参考文章：https://www.cnblogs.com/ioufev/p/10831289.html

该文中谈及常见的几种读取设备数据实现，说到modbus4j的通讯实现方式是同步的，实际应用中可能会读取大量的数据，需要异步进行，可以用modbus-master-tcp

本文也是基于modbus-master-tcp依赖库进行开发，它底层是基于Netty写的，所以具备高性能、支持异步

SpringBoot项目配置的核心依赖

<!--Modbus Master -->
<dependency>
    <groupId>com.digitalpetri.modbus</groupId>
    <artifactId>modbus-master-tcp</artifactId>
    <version>1.2.0</version>
</dependency>

<!--Modbus Slave -->
<dependency>
    <groupId>com.digitalpetri.modbus</groupId>
    <artifactId>modbus-slave-tcp</artifactId>
    <version>1.2.0</version>
</dependency>

设备模拟工具选择Modbus Slave，网上很多下载资源

一、读写模拟工具中数据

在这里插入图片描述
一开始我也把Server和Client搞混了，大家注意下面重点知识

重点知识

Modbus一主多从讲的是一次只有一个主机（Master）连接到网络，只有主设备（Master）可以启动通信并向从设备(Slave)发送请求，从设备不能主动发送；从设备(Slave)只能向主设备（Master）发送回复，且从设备就不能自己主动发送。

一个Master（物理网平台），多个Slave（设备）；平台是Client，设备是Server

实现如下：

(1) 定义Controller层

@RestController
@RequestMapping("/modbus")
public class ModbusController {

    @Autowired
    private ModbusTcpService modbusTcpService;

    // 连接slave设备
    @GetMapping(value = "/connect_slave")
    public ResponseMessage connectSlave(){
        return modbusTcpService.connectSlave();
    }

    // 读取保持寄存器
    @PostMapping(value = "/readHoldingRegisters")
    public ResponseMessage readHoldingRegisters(@RequestBody SlaveDto slaveDto) throws ExecutionException, InterruptedException {
        return modbusTcpService.readHoldingRegisters(slaveDto);
    }
    
	// 写单个寄存器
    @PostMapping(value = "/writeSingleRegister")
    public ResponseMessage writeSingleRegister(@RequestBody WriteSlaveDto wsDto) {
        return modbusTcpService.writeSingleRegister(wsDto);
    }

    // 写多个寄存器
    @PostMapping(value = "/writeMultipleRegisters")
    public ResponseMessage writeMultipleRegisters(@RequestBody WriteSlaveDto wsDto){
        return modbusTcpService.writeMultipleRegisters(wsDto);
    }

}

其他相关类

SlaveDto.java

@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
public class SlaveDto {

    private Integer slaveId;

    private Integer address;

    private Integer quantity;
}

WriteSlaveDto.java

@Data
@AllArgsConstructor
@NoArgsConstructor
public class WriteSlaveDto extends SlaveDto {

    // 写单个数值
    private Integer value;

    // 写多个数值
    private int[] values;
}

ResponseMessage.java就是常见的返回msg、code和data的类，随便找一个符合就行

(2) 定义Service层实现

@Service
@Slf4j
public class ModbusTcpService{

	@Autowired
    private ModbusMasterUtil modbusMasterUtil;

	public ResponseMessage connectSlave() {
        try {
            modbusMasterUtil.createModbusConnector(ModbusClientConstants.IP, ModbusClientConstants.TCP_PORT);
            return ResponseMessage.ok();
        }catch (Exception e){
            log.error("connect slave fail, {}", e.getMessage());
            return ResponseMessage.error(e.getMessage());
        }
    }

    private ModbusTcpMaster checkConnectSlave() {
        return modbusMasterUtil.getModbusTcpMaster();
    }

    public ResponseMessage readHoldingRegisters(SlaveDto slaveDto) throws ExecutionException, InterruptedException {
        if (checkConnectSlave() == null) return ResponseMessage.error("not connect slave");

        CompletableFuture<int[]> registerFuture = modbusMasterUtil.readHoldingRegisters(slaveDto.getSlaveId(), slaveDto.getAddress(), slaveDto.getQuantity());
        int[] registerValues = registerFuture.get();
        if (registerFuture == null) return ResponseMessage.error("Read exception, please check json parameters");
        log.info("readHoldingRegisters info={}", Arrays.toString(registerValues));
        return ResponseMessage.ok(registerValues);
    }

    public ResponseMessage writeSingleRegister(WriteSlaveDto wsDto) {
        if (checkConnectSlave() == null) return ResponseMessage.error("not connect slave");

        modbusMasterUtil.writeSingleRegister(wsDto.getSlaveId(), wsDto.getAddress(), wsDto.getValue());
        return ResponseMessage.ok();
    }

    public ResponseMessage writeMultipleRegisters(WriteSlaveDto wsDto) {
        if (checkConnectSlave() == null) return ResponseMessage.error("not connect slave");

        if(wsDto.getValues().length != wsDto.getQuantity()) return ResponseMessage.error("quantity error");

        modbusMasterUtil.writeMultipleRegisters(wsDto.getSlaveId(), wsDto.getAddress(), wsDto.getQuantity(), wsDto.getValues());
        return ResponseMessage.ok();
    }
}

IP和Port就是一个常量类，写着Modbus默认的127.0.0.1和502

Modbus Tcp的工具类为ModbusMasterUtil，这来自于网上的，还挺好用

@Component
@Slf4j
public class ModbusMasterUtil {

    private ModbusTcpMaster modbusMaster = null;

    public ModbusTcpMaster getModbusTcpMaster() {
        return modbusMaster;
    }
 
    /**
     * 将两个int数拼接成为一个浮点数
     *
     * @param highValue 高16位数值
     * @param lowValue  低16位数值
     * @return 返回拼接好的浮点数
     * @author huangji
     */
    public static float concatenateFloat(int highValue, int lowValue) {
        int combinedValue = ((highValue << 16) | (lowValue & 0xFFFF));
        return Float.intBitsToFloat(combinedValue);
    }
 
    public static int[] floatToIntArray(float floatValue) {
        int combinedIntValue = Float.floatToIntBits(floatValue);
        int[] resultArray = new int[2];
        resultArray[0] = (combinedIntValue >> 16) & 0xFFFF;
        resultArray[1] = combinedIntValue & 0xFFFF;
        return resultArray;
    }
 
    /**
     * 将传入的boolean[]类型数组按位转换成byte[]类型数组
     *
     * @param booleans 传入的boolean数组
     * @return 返回转化后的 byte[]
     * @author huangji
     */
    public static byte[] booleanToByte(boolean[] booleans) {
        BitSet bitSet = new BitSet(booleans.length);
        for (int i = 0; i < booleans.length; i++) {
            bitSet.set(i, booleans[i]);
        }
        return bitSet.toByteArray();
    }
 
    /**
     * 将传入的int[]类型数组转换成为byte[]类型数组
     *
     * @param values 传入的int[]数组
     * @return 返回 byte[]类型的数组
     * @author huangji
     */
    public static byte[] intToByte(int[] values) {
        byte[] bytes = new byte[values.length * 2];
        for (int i = 0; i < bytes.length; i += 2) {
            bytes[i] = (byte) (values[i / 2] >> 8 & 0xFF);
            bytes[i + 1] = (byte) (values[i / 2] & 0xFF);
        }
        return bytes;
    }
 
    /**
     * 根据传入的ip地址，创建modbus连接器
     *
     * @param ipAddr ip地址
     * @return 创建连接器，并进行连接，之后返回此连接器
     * @author huangji
     */
    public CompletableFuture<ModbusTcpMaster> createModbusConnector(String ipAddr) {
        return createModbusConnector(ipAddr, ModbusClientConstants.TCP_PORT);
    }
 
    /**
     * 根据传入的ip地址，创建modbus连接器
     *
     * @param ipAddr ip地址
     * @param port   端口号
     * @return 创建连接器，并进行连接，之后返回此连接器
     * @author huangji
     */
    public CompletableFuture<ModbusTcpMaster> createModbusConnector(String ipAddr, int port) {
        return createModbusConnector(new ModbusNetworkAddress(ipAddr, port));
    }
 
    /**
     * 根据传入的ModbusNetworkAddress\引用，创建modbus连接器
     *
     * @param modbusNetworkAddress ModbusNetworkAddress类型的实体对象引用
     * @return 创建连接器，并进行连接，之后返回此连接器
     * @author huangji
     */
    public CompletableFuture<ModbusTcpMaster> createModbusConnector(ModbusNetworkAddress modbusNetworkAddress) {
        String ipAddr = modbusNetworkAddress.getIpAddr();
        int port = modbusNetworkAddress.getPort();
        if (modbusMaster == null) {
            ModbusTcpMasterConfig masterConfig = new ModbusTcpMasterConfig.Builder(ipAddr).setPort(port).setTimeout(Duration.parse(ModbusClientConstants.TIMEOUT_DURATION)).setPersistent(true).setLazy(false).build();
            modbusMaster = new ModbusTcpMaster(masterConfig);
        }
        return modbusMaster.connect();
    }
 
    public void setBooleanArray(short unsignedShortValue, int[] array, int index, int size) {
        for (int i = index; i < index + size; i++) {
            array[i] = (unsignedShortValue & (0x01 << (i - index))) != 0 ? 1 : 0;
        }
    }
 
    /**
     * 异步方法，读取modbus设备的线圈值，对应功能号01
     *
     * @param slaveId  设备id
     * @param address  要读取的寄存器地址
     * @param quantity 要读取的寄存器数量
     * @return 返回 CompletableFuture<int[]>
     * @author huangji
     */
    public CompletableFuture<int[]> readCoils(int slaveId, int address, int quantity) {
        CompletableFuture<ReadCoilsResponse> futureResponse = modbusMaster.sendRequest(new ReadCoilsRequest(address, quantity),
                slaveId);
        return futureResponse.handle((response, ex) -> {
            if (ex != null) {
                ReferenceCountUtil.release(response);
                return null;
            } else {
                ByteBuf byteBuf = response.getCoilStatus();
                int[] values = new int[quantity];
                int minimum = Math.min(quantity, byteBuf.capacity() * 8);
                for (int i = 0; i < minimum; i += 8) {
                    setBooleanArray(byteBuf.readUnsignedByte(), values, i, Math.min(minimum - i, 8));
                }
                ReferenceCountUtil.release(response);
                return values;
            }
        });
    }
 
    /**
     * 异步方法，读取modbus设备的离散输入值，对应功能号02
     *
     * @param slaveId  设备id
     * @param address  要读取的寄存器地址
     * @param quantity 要读取的寄存器数量
     * @return 返回 CompletableFuture<int[]>
     * @author huangji
     */
    public CompletableFuture<int[]> readDiscreteInputs(int slaveId, int address, int quantity) {
        CompletableFuture<ReadDiscreteInputsResponse> futureResponse = modbusMaster.sendRequest(new ReadDiscreteInputsRequest(address, quantity),
                slaveId);
        return futureResponse.handle((response, ex) -> {
            if (ex != null) {
                ReferenceCountUtil.release(response);
                return null;
            } else {
                ByteBuf byteBuf = response.getInputStatus();
                int[] values = new int[quantity];
                int minimum = Math.min(quantity, byteBuf.capacity() * 8);
                for (int i = 0; i < minimum; i += 8) {
                    setBooleanArray(byteBuf.readUnsignedByte(), values, i, Math.min(minimum - i, 8));
                }
                ReferenceCountUtil.release(response);
                return values;
            }
        });
    }

    /**
     * 异步方法，读取modbus设备的保持寄存器值，对应功能号03
     *
     * @param slaveId  设备id
     * @param address  要读取的寄存器地址
     * @param quantity 要读取的寄存器数量
     * @return 返回 CompletableFuture<int[]>
     * @author huangji
     */
    public CompletableFuture<int[]> readHoldingRegisters(int slaveId, int address, int quantity) {
        CompletableFuture<ReadHoldingRegistersResponse> futureResponse = modbusMaster.sendRequest(new ReadHoldingRegistersRequest(address, quantity),
                slaveId);
        return futureResponse.handle((response, ex) -> {
            if (ex != null) {
                ReferenceCountUtil.release(response);
                return null;
            } else {
                ByteBuf byteBuf = response.getRegisters();
                int[] values = new int[quantity];
                for (int i = 0; i < byteBuf.capacity() / 2; i++) {
                    values[i] = byteBuf.readUnsignedShort();
                }
                ReferenceCountUtil.release(response);
                return values;
            }
        });
    }

    /**
     * 异步方法，读取modbus设备的输入寄存器值，对应功能号04
     *
     * @param slaveId  设备id
     * @param address  要读取的寄存器地址
     * @param quantity 要读取的寄存器数量
     * @return 返回 CompletableFuture<int[]>
     * @author huangji
     */
    public CompletableFuture<int[]> readInputRegisters(int slaveId, int address, int quantity) {
        CompletableFuture<ReadInputRegistersResponse> futureResponse = modbusMaster.sendRequest(new ReadInputRegistersRequest(address, quantity),
                slaveId);
        return futureResponse.handle((response, ex) -> {
            if (ex != null) {
                ReferenceCountUtil.release(response);
                return null;
            } else {
                ByteBuf byteBuf = response.getRegisters();
                int[] values = new int[quantity];
                for (int i = 0; i < byteBuf.capacity() / 2; i++) {
                    values[i] = byteBuf.readUnsignedShort();
                }
                ReferenceCountUtil.release(response);
                return values;
            }
        });
    }
 
    /**
     * 异步方法，写入单个线圈的数值，对应功能号05
     *
     * @param slaveId 设备id
     * @param address 要读取的寄存器地址
     * @param value   要写入的boolean值
     * @return 返回 CompletableFuture<Boolean>
     * @author huangji
     */
    public CompletableFuture<Boolean> writeSingleCoil(int slaveId, int address, boolean value) {
        CompletableFuture<WriteSingleCoilResponse> futureResponse = modbusMaster.sendRequest(new WriteSingleCoilRequest(address, value),
                slaveId);
        return futureResponse.handle((response, ex) -> {
            if (ex != null) {
                ReferenceCountUtil.release(response);
                return false;
            } else {
                boolean responseValue = response.getValue() != 0;
                ReferenceCountUtil.release(response);
                return responseValue == value;
            }
        });
    }
 
    /**
     * 异步方法，写入单个寄存器的数值，对应功能号06
     *
     * @param slaveId 设备id
     * @param address 要读取的寄存器地址
     * @param value   要写入的值
     * @return 返回 CompletableFuture<Boolean>
     * @author huangji
     */
    public CompletableFuture<Boolean> writeSingleRegister(int slaveId, int address, int value) {
        CompletableFuture<WriteSingleRegisterResponse> futureResponse = modbusMaster.sendRequest(new WriteSingleRegisterRequest(address, value),
                slaveId);
        return futureResponse.handle((response, ex) -> {
            if (ex != null) {
                ReferenceCountUtil.release(response);
                return false;
            } else {
                int responseValue = response.getValue();
                ReferenceCountUtil.release(response);
                return responseValue == value;
            }
        });
    }
 
    /**
     * 异步方法，写入多个线圈的数值，对应功能号15
     *
     * @param slaveId  设备id
     * @param address  要写入的寄存器地址
     * @param quantity 要写入的寄存器个数
     * @param values   要写入的boolean[]
     * @return 返回 CompletableFuture<Boolean>
     * @author huangji
     */
    public CompletableFuture<Boolean> writeMultipleCoils(int slaveId, int address, int quantity, boolean[] values) {
        byte[] bytes = booleanToByte(values);
        CompletableFuture<WriteMultipleCoilsResponse> futureResponse = modbusMaster.sendRequest(new WriteMultipleCoilsRequest(address, quantity, bytes),
                slaveId);
        return futureResponse.handle((response, ex) -> {
            if (ex != null) {
                ReferenceCountUtil.release(response);
                return false;
            } else {
                int responseQuantity = response.getQuantity();
                ReferenceCountUtil.release(response);
                return values.length == responseQuantity;
            }
        });
    }
 
    /**
     * 异步方法，写入多个寄存器的数值，对应功能号16
     *
     * @param slaveId  设备id
     * @param address  要写入的寄存器地址
     * @param quantity 要写入的寄存器个数
     * @param values   要写入的int[]
     * @return 返回 CompletableFuture<Boolean>
     * @author huangji
     */
    public CompletableFuture<Boolean> writeMultipleRegisters(int slaveId, int address, int quantity, int[] values) {
        byte[] bytes = intToByte(values);
        CompletableFuture<WriteMultipleRegistersResponse> futureResponse = modbusMaster.sendRequest(new WriteMultipleRegistersRequest(address, quantity, bytes),
                slaveId);
        return futureResponse.handle((response, ex) -> {
            if (ex != null) {
                ReferenceCountUtil.release(response);
                return false;
            } else {
                int responseQuantity = response.getQuantity();
                ReferenceCountUtil.release(response);
                return values.length == responseQuantity;
            }
        });
    }
 
    /**
     * 关闭连接器并释放相关资源
     *
     * @author huangji
     */
    public void disposeModbusConnector() {
        if (modbusMaster != null) {
            modbusMaster.disconnect();
        }
        Modbus.releaseSharedResources();
    }
 
}

二、调试

首先要在Modbus Slave工具点击Connect进行连接，随便输入一些数字，然后发送请求；

注：可以先用connect_slave接口发送请求建立平台与设备的连接

(1) 读数据

在这里插入图片描述

(2) 向寄存器写单个数据

在这里插入图片描述

(3) 向寄存器写多个数据

在这里插入图片描述

小样x
关注
  • 3
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java 整合 Modbus TCP
SSL 的博客
03-05 5091
使用Java整合Modbus TCP，实现代码控制Modbus设备模拟器。
modbus的读写java实现
06-07
modbus的读写java实现
JAVA实现Modbus RTU或Modbus TCPIP数据采集.rar
06-03
1.多线程可以提高资源的利用率，可以充分利用现代多核处理器的特性，让每个线程负责处理同类型的任务，更加容易维护，同时通过异步处理提高响应性。 2.多线程之间为更方便的实现数据共享采用了共享相同内存地址空间的形式，并且是并发运行，导致多个线程可能会同时访问或修改其他线程正在使用的变量值，导致安全性，同时如果线程之间相互等待对方拥有的锁，会出现活跃性即死锁问题。如果线程计算部分不多，更多的线程只会导致频繁的切换上下文，让CPU的时间更多的花在线程调度而不是任务执行上。 3.java同步的几种方式：synchronized,volatile,显示锁,原子变量,线程及对象的基础同步方法。 4.所谓线程安全就是当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在主调代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为。 5.将复合操作放在一个原子操作中执行,或用相同的锁来保护每个共享的和可变的变量。 6.增加同步必然会导致代码的复杂性，为性能牺牲代码简单性时不要太盲目，因为越复杂的代码，其不安全性越大。
有关Java读取Modbus协议连接PLC的示例（使用modbus4j）
最新发布
qq_29317911的博客
05-11 1310
我最近碰到一个项目，获取数据来方式很多，其中一种便是Modbus协议。这个协议分为Modbus-Tcp和Modbus-RTU两种，我是这么简单理解这个协议的，主要用于信息的采集与下发，而且信息的获取和下发需要对应硬件的物理地址。下面先讲一下一些实用的知识点，看完之后说不定你就不用开发了。网上也有卖集成485串口的类似交换机的东西，可以去某宝搜索一下。还可以把串口的Modbus协议转换为ModbusTCP协议，并实现双向通信，即可以获取数据，也可以下发指令。甚至可以把数据发送到消息队列中。
【2023】java通过modbus4j实现modus TCP通讯
weixin_52315708的博客
07-12 8185
Modbus RTU:——传输的是字节数组（bit[]）通信：读写输出：可以读写输入：只能读存储区：输出线圈、输入线圈、输出寄存器、输入寄存器存储区范围：5位和6位功能代码0x01：读线圈0x02：读离散量输入0x03：读保持寄存器0x04：读输入寄存器测试使用Modbus Slave（） 模拟saveid：看资料"从站在modbus总线上可以有多个"，仿真软件就能模拟一个从站，就是ID=1，当然可以修改成ID=2。
Java与Modbus-TCP/IP网络通讯
bobo_supper的博客
08-24 1897
通过Java与Modbus-TCP/IP网络通讯实现举例5中的功能。
基于Java的Modbus通讯
11-30
使用Java通过Modbus读取任何Modbus设备的数据代码及使用案例
Modbus通讯协议(四)——Java实现ModbusTCP Slave(从机)
三毛村滴雪鱼粉的博客
06-08 1万+
本文通过Java开源库jlibmodbus实现modbusTCP通讯 从机端 添加依赖 <dependency> <groupId>com.intelligt.modbus</groupId> <artifactId>jlibmodbus</artifactId> <version>1.2.9.7</version> </dependency> Java实现从机读写操作 ModbusSl
Modbus - ModbusTCP基于Java代码实现的操作真机 (并非模拟)
weixin_43652507的博客
01-16 2549
对远程空调实时控制: 开关、温度 、模式、风速
Java实现modbus tcp协议数据读写，项目内包含modbus slave仿真软件
09-28
本项目专注于使用Java语言实现Modbus TCP/IP协议的读写功能，提供了两种不同的实现方案：jlibmodbus和modbus4j库。这两种库都是Java社区开发的开源工具，专门用于处理Modbus通信。 首先，我们来看jlibmodbus。...
java 通过modbus rtu协议，tcp 协议 通讯源码
06-15
Java编程语言在工业自动化和设备通信领域中广泛应用于实现Modbus通信协议，这是一种标准化的通信协议，用于设备间的数据交换。本项目提供了基于Modbus RTU（远程终端单元）和TCP（传输控制协议）的通信源码，适用于...
modbusTCP协议java实现（带注释）
05-02
modbusTCP协议java实现（带注释）
JAVA写的利用ModbusTCP协议控制现场设备
02-26
这是一个JAVA写的利用ModbusTCP协议控制现场设备的软件，里边有源码，其中通讯池感觉还不错，需要的可以借鉴一下，里边的按钮做的效果不太好。
modbus TCP/IP 调试工具 Modbus Poll 和java 开发工具jar包
07-20
6. **开发工具jar包**: 压缩文件中可能包含的Java开发所需的jar包，这些库可能包含了实现Modbus协议的类和方法，方便开发者在Java项目中集成Modbus通信功能。使用这些库，开发者可以创建自己的Modbus主站或从站应用...
JAVA读写PLC物联网Modbus RTU Modbus TCP Modbus UDP通信，JAVA与Modbus通信源码
01-11
Modbus比其他通信协议使用的更广泛的... 最近在研究处理java与modbus RTU通信，分别使用几套工具，模拟modbus从站、模拟串口等才能正常在电脑测试成功。 https://blog.csdn.net/weijia3624/article/details/127888192
Modbus Poll读取plc数据(TCP/IP读取)，并查看指定地址指定数据
Ronion123的博客
11-21 8786
1.首先连接，点击Connection-connect，选择Modbus TCP/IP,输入IP和端口号（Server Port）
Java实现ModbusTCP通信
weixin_44768683的博客
07-14 5383
Java实现ModbusTCP通信
ModbusTcp协议的Java Socket
热门推荐
yuke的专栏
06-30 1万+
模拟了直接发送Socket套接字（上位机）跟Modbus Slave软件（下位机）进行通信，代码如下：         Socket socket = new Socket("192.1.1.4",9600);         InputStream is=socket.getInputStream();         OutputStream os=socket.getOutputStr
基于TCP/IP协议的java与Modbus Slave 的通信
coChen666的博客
07-18 4440
本文档介绍的是基于TCP/IP协议的java与Modbus Slave 的通信。 首先java中添加这几个包到路径下；   这里SlaveID与下图java里的1所在位置对应，表示从机地址。Start， readLength表示读从start开始的寄存器个数。 上图IP ，port要与从机保持一致。 这些设置好后先将从机连接。接着运行程序得到结果...
splash_data.splash_display
09-01
抱歉，我没有找到与"splash_data.splash_display"相关的引用内容。根据提供的信息，我无法给出关于此特定文件的详细解释。 请提供更多上下文或相关信息，以便我可以更好地回答您的问题。<span class="em">1</span><span class="em">2</span> #### 引用[.reference_title] - *1* [catalina.log localhost.log localhost_access_log.txt manager.log tomcat-stdout.log 文件占用过大，处理...](https://blog.csdn.net/sunny_day_day/article/details/120128201)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* [dlpc3435.pdf](https://download.csdn.net/download/egtnyjjyy/11234104)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小样x

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值