Java使用开源Rxtx实现串口通讯(串口开发)

最新推荐文章于 2024-03-15 14:50:38 发布
最新推荐文章于 2024-03-15 14:50:38 发布
阅读量6.1w 收藏 54
点赞数
分类专栏： Java 文章标签： 通讯 java string exception hashmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiezhiyong3621/article/details/8092150
版权

简单实例下载：http://download.csdn.net/detail/xiezhiyong3621/7186795

Rxtx开源包下载地址：http://users.frii.com/jarvi/rxtx/download.html

http://rxtx.qbang.org/wiki/index.php/Download
使用方法：
windows平台：
1、把rxtxParallel.dll、rxtxSerial.dll拷贝到：C:\WINDOWS\system32下。
2、如果是在开发的时候(JDK),需要把RXTXcomm.jar、rxtxParallel.dll、rxtxSerial.dll拷贝到..\jre...\lib\ext下；如：D:\Program Files\Java\jre1.6.0_02\lib\ext
3、而且需要把项目1.右键->2.Preperties(首选项)->3.Java Build Path->4.Libraries->5.展开RXTXcomm.jar->6.Native library location:(None)->7.浏览External Folder(选择至该项目的lib文件夹，如：E:/Item/MyItem/WebRoot/WEB-INF/lib). 
import gnu.io.*;
import java.io.*; 
import java.util.*; 
import com.call.dao.*;
 
 public class SerialReader extends Observable implements Runnable,SerialPortEventListener
    {
    static CommPortIdentifier portId;
    int delayRead = 100;
    int numBytes; // buffer中的实际数据字节数
    private static byte[] readBuffer = new byte[1024]; // 4k的buffer空间,缓存串口读入的数据
    static Enumeration portList;
    InputStream inputStream;
    OutputStream outputStream;
    static SerialPort serialPort;
    HashMap serialParams;
    Thread readThread;//本来是static类型的
    //端口是否打开了
    boolean isOpen = false;
    // 端口读入数据事件触发后,等待n毫秒后再读取,以便让数据一次性读完
    public static final String PARAMS_DELAY = "delay read"; // 延时等待端口数据准备的时间
    public static final String PARAMS_TIMEOUT = "timeout"; // 超时时间
    public static final String PARAMS_PORT = "port name"; // 端口名称
    public static final String PARAMS_DATABITS = "data bits"; // 数据位
    public static final String PARAMS_STOPBITS = "stop bits"; // 停止位
    public static final String PARAMS_PARITY = "parity"; // 奇偶校验
    public static final String PARAMS_RATE = "rate"; // 波特率

    public boolean isOpen(){
    	return isOpen;
    }
    /**
     * 初始化端口操作的参数.
     * @throws SerialPortException 
     * 
     * @see
     */
    public SerialReader()
    {
    	isOpen = false;
    }

    public void open(HashMap params) 
    { 
    	serialParams = params;
    	if(isOpen){
    		close();
    	}
        try
        {
            // 参数初始化
            int timeout = Integer.parseInt( serialParams.get( PARAMS_TIMEOUT )
                .toString() );
            int rate = Integer.parseInt( serialParams.get( PARAMS_RATE )
                .toString() );
            int dataBits = Integer.parseInt( serialParams.get( PARAMS_DATABITS )
                .toString() );
            int stopBits = Integer.parseInt( serialParams.get( PARAMS_STOPBITS )
                .toString() );
            int parity = Integer.parseInt( serialParams.get( PARAMS_PARITY )
                .toString() );
            delayRead = Integer.parseInt( serialParams.get( PARAMS_DELAY )
                .toString() );
            String port = serialParams.get( PARAMS_PORT ).toString();
            // 打开端口
            portId = CommPortIdentifier.getPortIdentifier( port );
            serialPort = ( SerialPort ) portId.open( "SerialReader", timeout );
            inputStream = serialPort.getInputStream();
            serialPort.addEventListener( this );
            serialPort.notifyOnDataAvailable( true );
            serialPort.setSerialPortParams( rate, dataBits, stopBits, parity );
            
            isOpen = true;
        }
        catch ( PortInUseException e )
        {
           // 端口"+serialParams.get( PARAMS_PORT ).toString()+"已经被占用";
        }
        catch ( TooManyListenersException e )
        {
           //"端口"+serialParams.get( PARAMS_PORT ).toString()+"监听者过多";
        }
        catch ( UnsupportedCommOperationException e )
        {
           //"端口操作命令不支持";
        }
        catch ( NoSuchPortException e )
        {
          //"端口"+serialParams.get( PARAMS_PORT ).toString()+"不存在";
        }
        catch ( IOException e )
        {
           //"打开端口"+serialParams.get( PARAMS_PORT ).toString()+"失败";
        }
        serialParams.clear();
        Thread readThread = new Thread( this );
        readThread.start();
    }

     
    public void run()
    {
        try
        {
            Thread.sleep(50);
        }
        catch ( InterruptedException e )
        {
        }
    } 
    public void start(){
   	  try {  
      	outputStream = serialPort.getOutputStream();
   	     } 
   	catch (IOException e) {}
   	try{ 
   	    readThread = new Thread(this);
     	readThread.start();
   	} 
   	catch (Exception e) {  }
   }  //start() end


   public void run(String message) {
   	try { 
   		Thread.sleep(4); 
           } 
   	 catch (InterruptedException e) {  } 
   	 try {
   		 if(message!=null&&message.length()!=0)
   		 { 	 
   			 System.out.println("run message:"+message);
   	        outputStream.write(message.getBytes());
   		 }
   	} catch (IOException e) {}
   } 
    

    public void close() 
    { 
        if (isOpen)
        {
            try
            {
            	serialPort.notifyOnDataAvailable(false);
            	serialPort.removeEventListener();
                inputStream.close();
                serialPort.close();
                isOpen = false;
            } catch (IOException ex)
            {
            //"关闭串口失败";
            }
        }
    }
    
    public void serialEvent( SerialPortEvent event )
    {
        try
        {
            Thread.sleep( delayRead );
        }
        catch ( InterruptedException e )
        {
            e.printStackTrace();
        }
        switch ( event.getEventType() )
        {
            case SerialPortEvent.BI: // 10
            case SerialPortEvent.OE: // 7
            case SerialPortEvent.FE: // 9
            case SerialPortEvent.PE: // 8
            case SerialPortEvent.CD: // 6
            case SerialPortEvent.CTS: // 3
            case SerialPortEvent.DSR: // 4
            case SerialPortEvent.RI: // 5
            case SerialPortEvent.OUTPUT_BUFFER_EMPTY: // 2
                break;
            case SerialPortEvent.DATA_AVAILABLE: // 1
                try
                {
                    // 多次读取,将所有数据读入
                     while (inputStream.available() > 0) {
                     numBytes = inputStream.read(readBuffer);
                     }
                     
                     //打印接收到的字节数据的ASCII码
                     for(int i=0;i<numBytes;i++){
                    	// System.out.println("msg[" + numBytes + "]: [" +readBuffer[i] + "]:"+(char)readBuffer[i]);
                     }
//                    numBytes = inputStream.read( readBuffer );
                    changeMessage( readBuffer, numBytes );
                }
                catch ( IOException e )
                {
                    e.printStackTrace();
                }
                break;
        }
    }

    // 通过observer pattern将收到的数据发送给observer
    // 将buffer中的空字节删除后再发送更新消息,通知观察者
    public void changeMessage( byte[] message, int length )
    {
        setChanged();
        byte[] temp = new byte[length];
        System.arraycopy( message, 0, temp, 0, length );
        notifyObservers( temp );
    }

    static void listPorts()
    {
        Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();
        while ( portEnum.hasMoreElements() )
        {
            CommPortIdentifier portIdentifier = ( CommPortIdentifier ) portEnum
                .nextElement();
            
        }
    }
    
    
    public void openSerialPort(String message)
    {
        HashMap<String, Comparable> params = new HashMap<String, Comparable>(); 
        otherDAO odao=new otherDAO();
        String port=odao.selectNumberById(15);
        String rate = "9600";
        String dataBit = ""+SerialPort.DATABITS_8;
        String stopBit = ""+SerialPort.STOPBITS_1;
        String parity = ""+SerialPort.PARITY_NONE;    
        int parityInt = SerialPort.PARITY_NONE; 
        params.put( SerialReader.PARAMS_PORT, port ); // 端口名称
        params.put( SerialReader.PARAMS_RATE, rate ); // 波特率
        params.put( SerialReader.PARAMS_DATABITS,dataBit  ); // 数据位
        params.put( SerialReader.PARAMS_STOPBITS, stopBit ); // 停止位
        params.put( SerialReader.PARAMS_PARITY, parityInt ); // 无奇偶校验
        params.put( SerialReader.PARAMS_TIMEOUT, 100 ); // 设备超时时间 1秒
        params.put( SerialReader.PARAMS_DELAY, 100 ); // 端口数据准备时间 1秒
        try {
			open(params);//打开串口
			LoginFrame cf=new LoginFrame();
			addObserver(cf);
			if(message!=null&&message.length()!=0)
			 {
				String str="";
				for(int i=0;i<10;i++)
				{
					str+=message;
				}
				 start(); 
			     run(str);  
			 } 
		} catch (Exception e) { 
		}
    }

    static String getPortTypeName( int portType )
    {
        switch ( portType )
        {
            case CommPortIdentifier.PORT_I2C:
                return "I2C";
            case CommPortIdentifier.PORT_PARALLEL:
                return "Parallel";
            case CommPortIdentifier.PORT_RAW:
                return "Raw";
            case CommPortIdentifier.PORT_RS485:
                return "RS485";
            case CommPortIdentifier.PORT_SERIAL:
                return "Serial";
            default:
                return "unknown type";
        }
    }

     
    public  HashSet<CommPortIdentifier> getAvailableSerialPorts()//本来static
    {
        HashSet<CommPortIdentifier> h = new HashSet<CommPortIdentifier>();
        Enumeration thePorts = CommPortIdentifier.getPortIdentifiers();
        while ( thePorts.hasMoreElements() )
        {
            CommPortIdentifier com = ( CommPortIdentifier ) thePorts
                .nextElement();
            switch ( com.getPortType() )
            {
                case CommPortIdentifier.PORT_SERIAL:
                    try
                    {
                        CommPort thePort = com.open( "CommUtil", 50 );
                        thePort.close();
                        h.add( com );
                    }
                    catch ( PortInUseException e )
                    {
                        System.out.println( "Port, " + com.getName()
                            + ", is in use." );
                    }
                    catch ( Exception e )
                    {
                        System.out.println( "Failed to open port "
                            + com.getName() + e );
                    }
            }
        }
        return h;
    }
}

//ASCII表
//-------------------------------------------------------------
//                 ASCII Characters                            
//                            
//Dec   Hex       Char    Code   Dec   Hex  Char
//                            
//0     0         NUL            64    40    @
//1     1         SOH            65    41    A
//2     2         STX            66    42    B
//3     3         ETX            67    43    C
//4     4         EOT            68    44    D
//5     5         ENQ            69    45    E
//6     6         ACK            70    46    F
//7     7         BEL            71    47    G
//8     8         BS             72    48    H
//9     9         HT             73    49    I
//10    0A        LF             74    4A    J
//11    0B        VT             75    4B    K
//12    0C        FF             76    4C    L
//13    0D        CR             77    4D    M
//14    0E        SO             78    4E    N
//15    0F        SI             79    4F    O
//16    10        SLE            80    50    P
//17    11        CS1            81    51    Q
//18    12        DC2            82    52    R
//19    13        DC3            83    53    S
//20    14        DC4            84    54    T
//21    15        NAK            85    55    U
//22    16        SYN            86    56    V
//23    17        ETB            87    57    W
//24    18        CAN            88    58    X
//25    19        EM             89    59    Y
//26    1A        SIB            90    5A    Z
//27    1B        ESC            91    5B    [
//                               92    5C     \
//28    1C        FS             93    5D    ]
//29    1D        GS             94    5E    ^
//30    1E        RS             95    5F    _
//31    1F        US             96    60    `
//32    20    (space)            97    61    a
//33    21        !              98    62    b
//34    22        "    
//                               99    63    c
//35    23        #              100    64    d
//36    24        $                    
//37    25        %              101    65    e
//38    26        &              102    66    f
//39    27        '              103    67    g
//40    28        (              104    68    h
//41    29        )              105    69    i
//42    2A        *              106    6A    j
//43    2B        +              107    6B    k
//44    2C        ,              108    6C    l
//45    2D        -              109    6D    m
//46    2E        .              110    6E    n
//47    2F        /              111    6F    o
//48    30        0              112    70    p
//49    31        1              113    72    q
//50    32        2              114    72    r
//51    33        3              115    73    s
//52    34        4              116    74    t
//53    35        5              117    75    u
//54    36        6              118    76    v
//55    37        7              119    77    w
//56    38        8              120    78    x
//57    39        9              121    79    y
//58    3A        :              122    7A    z
//59    3B        ;              123    7B    {
//60    3C        <              124    7C    |
//61    3D        =              125    7D    }
//62    3E        >              126    7E    ~
//63    3F        ?              127    7F

简单实例下载：http://download.csdn.net/detail/xiezhiyong3621/7186795

shenhua
关注
  • 0
    点赞
  • 踩
  • 54
    收藏
    觉得还不错? 一键收藏
  • 176
    评论
专栏目录
64位与32位 rxtxserial.dll/rxtxParallel.dll
12-28
windows64位/32位串口开发用到的rxtxParallel.dll和rxtxSerial.dll
[rxtxSerial.dll+0x4465]及打包运行后遇到的坑
weixin_50556778的博客
11-22 1344
[rxtxSerial.dll+0x4465]及打包运行后遇到的坑
RXTX for java在arm上的使用
最新发布
qq_32124537的博客
03-15 176
因为rxtx for java在http://fizzed.com/oss/rxtx-for-java上提供的so文件为amd架构下编译生成的所以它不能应用到arm架构下的系统中。4、注释RawImp.c文件104行 #include 所以只能自己编译 基于jetson的ubuntu系统 aarch64。3、下载最新的config.guess和config.sub。2、修改version.h头文件。1、下载rxtx2.2源码。
Java串口操作RXTX，报错 no rxtxSerial in java.library.path thrown while loading gnu.io.RXTXCommDriver解决方案
beiback的博客
11-05 2896
错误原因由错误提示可知，缺少rxtxParallel.dll和rxtxSerial.dll文件解决办法windows平台将rxtxParallel.dll和rxtxSerial.dll文件放到${JAVA_HOME}\jre\bin目录下，将RXTXcomm.jar 包放到{JAVA_HOME}\jre\lib\ext目录下即可。
[已解决]no rxtxSerial in java.library.path问题出现的原因和解决
会者定离，一期一祈
11-19 1万+
no rxtxSerial in java.library.path问题出现的原因和解决 今天在公司的项目中进行串口通信的开发，启动项目的时候报错 异常：java.lang.UnsatisfiedLinkError: no rxtxSerial in java.library.path thrown while loading gnu.io.RXTXCommDriver 解决方法是： 将rxtxSerial.dll和rxtxParallel.dll添加到java.library.path中 这两个文件
java串口通讯开发rxtxSerial.dll的闪退问题解决
qq_40903561的博客
08-22 1988
java串口通讯开发遇到的问题排查过程、解决办法
java实现rs485串口通讯
zsj777的专栏
12-24 3679
https://www.cnblogs.com/jinghuyue/p/10226848.html 　需要先要下载RXTX的jar包，win64位下载地址：http://pan.baidu.com/s/1o6zLmTc）；将解压后的rxtxParallel.dll和rxtxSerial.dll两个文件放在%JAVA_HOME%/jre/bin目录下,这样该包才能被正常的加载和调用。 　　...
Java使用开源Rxtx实现串口通讯 串口开发
04-13
Java使用开源Rxtx实现串口通讯 串口开发，里面包含实例，下载后按自己的要求进行修改即可（仅限对java有基础的人员）。
Java使用开源Rxtx实现串口通讯
08-26
主要为大家详细介绍了Java使用开源Rxtx实现串口通讯，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
rxtx开发串口通讯
07-15
本资源利用Java语言以及rxtx开源包实现的一个串口通讯demo
java串口通信的jar包rxtx-2.2 for win-x64
03-07
使用方法： 拷贝 RXTXcomm.jar 到 JAVA_HOME\jre\lib\ext目录中； 拷贝 rxtxSerial.dll 到 JAVA_HOME\jre\bin目录中； 拷贝 rxtxParallel.dll 到 JAVA_HOME\jre\bin目录中； JAVA_HOME为jdk安装路径
RXTX for Java 64位 rxtxserial.dll、rxtxParallel.dll
03-07
RXTX for Java void Init():初始化(只调用一次) int WINAPI CommOpen(int comno,int baud,int devType): 打开串口 comno 串口号 baud 波特率 devType 保留参数(值为2) 返回值: 0 为失败 1为成功 int WINAPI CommClose(int comno):关闭串口 comno 串口号 返回值: 0 为失败 1为成功 int WINAPI SendMsg(int comno,char* phone,char* message):发送短信 comno 串口号 phone 手机号 message 短信内容 返回值: 0 为失败 1为成功 int WINAPI RecvMsg(int comno,char* xml):接收短信 comno 串口号 xml 接收短信内容(XML格式) 返回值: 0 为失败 1为成功
java串口编程RXTXcomm.jar包以及RXTXcomm.src源文件
05-30
java串口编程RXTXcomm.jar包以及RXTXcomm.src源文件,提示：源文件没有注释,jar包不光要导入工程buildPath目录，还要进行其他的配置，具体请看：http://blog.csdn.net/xiezhiyong3621/article/details/8092150
rxtxParallel.dll和rxtxSerial.dll
06-09
rxtxParallel.dll和rxtxSerial.dll两个插件
rxtxParallel+rxtxSerial（32位和64位）
03-04
编写JAVA串口程序用rxtxParallel+rxtxSerial（32位和64位）
串口通信关于串口找不到的问题解决
热门推荐
qq291545540的专栏
09-17 1万+
1.      很多人都是用 javacomm20-win32.zip 如下图： 通过正确的配置 comm.jar  javax.comm.properties  win32com.dll即可进行串口通信， 配置如下： 将comm.jar复制到%java_home%/jre/lib/ext 将javax.comm.properties复制到%java_home%/jre/lib 将
java RXTXcomm 串口通信
SongYuLong
10-14 6758
RXTXcomm：提供了 Windows x64, x86, ia64 and Linux x86, x86_64等操作系统支持。 下载地址 http://fizzed.com/oss/rxtx-for-java 使用RXTXcomm首先要安排JRE环境，开发IED可能eclipse. 1.下载系统相应的RXTXcomm。 2.将rxtxSerial.dll、rxtxParallel.dll
使用RXTXcomm进行串口通信,以及开发中遇到的问题
lonely233的博客
09-21 3527
这篇文章主要将串口通信开发，以及在开发中遇到的一些细节问题和大问题，不管是什么问题都是折磨人的，永远忘不了上百度一个问题闹腾一下午的煎熬RXTXcomm有32位的，也有64位的包，我们大多用到的都是64而且jdk都是1.8版本的，所以开干。。
java实现 串口通讯
09-27
### 回答1： 在Java中，可以使用JavaComm API来实现串口通讯。以下是实现串口通讯的基本步骤： 1. 下载并安装JavaComm API，该API包括了访问串口的类和方法。 2. 导入JavaComm API库。 ```java import javax.comm.*; ``` 3. 使用CommPortIdentifier类获取可用的串口。 ```java Enumeration portList = CommPortIdentifier.getPortIdentifiers(); while (portList.hasMoreElements()) { CommPortIdentifier portId = (CommPortIdentifier) portList.nextElement(); if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) { System.out.println(portId.getName()); } } ``` 4. 打开选定的串口。 ```java CommPortIdentifier portId = CommPortIdentifier.getPortIdentifier("COM1"); SerialPort serialPort = (SerialPort) portId.open("MyApp", 2000); ``` 5. 配置串口参数，例如波特率、数据位、停止位、奇偶校验位等。 ```java serialPort.setSerialPortParams(9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); ``` 6. 获取输入输出流并进行数据传输。 ```java InputStream in = serialPort.getInputStream(); OutputStream out = serialPort.getOutputStream(); out.write("Hello World".getBytes()); byte[] buffer = new byte[1024]; int len = in.read(buffer); System.out.println(new String(buffer, 0, len)); ``` 7. 关闭串口。 ```java serialPort.close(); ``` 以上是Java实现串口通讯的基本步骤，根据具体需求可以进行进一步的修改和扩展。 ### 回答2： Java可以通过使用第三方库来实现串口通讯。其中最常用的库之一是RXTX，它可以在 Java 平台上提供串口通讯的功能。 RXTX是一个开源的串口通讯库，支持跨平台运行。以下是实现串口通讯的一般步骤： 1. 添加RXTX库：首先，你需要下载RXTX库的最新版本。然后，将库的JAR文件添加到你的Java项目的classpath中。 2. 打开串口：使用RXTX提供的类，打开你要进行通讯的串口。你可以选择串口的名称、波特率和其他参数。 3. 设置串口监听器：通过注册一个监听器来监听串口的输入数据。这样，当串口接收到数据时，你就可以在监听器中处理它。 4. 发送数据：使用串口对象的输出流，你可以将数据发送到串口设备上。 5. 接收数据：使用串口对象的输入流，你可以读取从串口设备接收到的数据。 6. 关闭串口：当你完成通讯后，要记得关闭串口，释放资源。 需要注意的是，在使用RXTX库之前，你需要在你的操作系统上安装相应的驱动程序。具体的驱动程序安装方法和操作系统有关。 总结起来，通过使用RXTX库，我们可以在Java平台上实现串口通讯。我们可以打开和关闭串口，发送和接收数据。这为与硬件设备的交互提供了便利，例如与传感器、机器人或其他串口设备进行通讯。 ### 回答3： 串口通讯在Java中可以通过Java的Comm API来实现。下面是一个简单的示例来说明如何使用Java实现串口通讯。 1. 首先，我们需要下载并安装Java Comm API。可以从Oracle官方网站上下载相应版本的Java Comm API。 2. 在Java代码中，我们需要导入相应的类，包括javax.comm包中的SerialPort和CommPortIdentifier类。 3. 然后，我们需要通过调用CommPortIdentifier类的getPortIdentifiers()方法获取当前系统中可用的串口列表。 4. 对于每个可用的串口，我们可以调用CommPortIdentifier类的方法来获得串口对象。 5. 通过打开串口，我们可以得到一个串口输入流和一个串口输出流。 6. 通过串口输出流，我们可以发送数据。通过串口输入流，我们可以接收数据。 7. 当需要关闭串口时，我们需要调用close()方法来关闭串口。 下面是一个简单的示例代码： ``` import javax.comm.*; public class SerialCommunication { public static void main(String[] args) { CommPortIdentifier portId; try { // 获取当前系统中可用的串口列表 Enumeration portList = CommPortIdentifier.getPortIdentifiers(); while (portList.hasMoreElements()) { // 获取串口对象 portId = (CommPortIdentifier) portList.nextElement(); // 判断串口类型 if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) { // 打开串口 SerialPort serialPort = (SerialPort) portId.open("SerialCommunication", 2000); // 配置串口参数 serialPort.setSerialPortParams(9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); // 获取串口输入流和输出流 InputStream in = serialPort.getInputStream(); OutputStream out = serialPort.getOutputStream(); // 使用串口输出流发送数据 out.write("Hello, Serial Port!".getBytes()); out.flush(); // 接收串口输入流数据 byte[] buffer = new byte[1024]; int len = in.read(buffer); String receivedData = new String(buffer, 0, len); System.out.println("Received Data: " + receivedData); // 关闭串口 serialPort.close(); } } } catch (Exception e) { e.printStackTrace(); } } } ``` 这就是一种基本的方法来实现Java中的串口通讯。当然，还有其他的一些高级应用，比如监听串口数据事件等。 希望这个简单的示例可以帮助您理解在Java中如何实现串口通讯。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值