socket编程（二）——Socket模式

最新推荐文章于 2022-04-22 15:02:16 发布
最新推荐文章于 2022-04-22 15:02:16 发布
阅读量196 收藏
点赞数
文章标签： java 网络
原文链接：http://www.cnblogs.com/barker/p/5435573.html
版权

Socket编程注意点：

Socket connect(SocketAddress endpoint, int timeout)方法：连接到服务器，并指定一个超时值。超时值零被解释为无限超时。在建立连接或者发生错误之前，这个方法一直处于阻塞状态。【在编写程序时这个超时值最好设置上】

Socket setSoTimeout方法：Socket的read方法是一个阻塞方法，setSoTimeout设置阻塞的时间，如果超过阻塞时间会引发SocketTimeoutException；

通过Socket的输入流读取数据：是阻塞的；一般会在流的外面套一个BufferInputStream，通过read(byte[] b)和read(b, 0, b.length)方法读取指定长度的字节，通过结合包头中指定的包体长度可以解决粘包问题。read(byte[] b)和read(b, 0, b.length)，通过重复地调用底层流的read方法，尝试读取尽可能多的字节。这种迭代的read会一直继续下去，直到满足一下条件之一：

　　·已经读取了指定的字节数

　　·底层流的read方法返回-1，指示文件末尾

　　·底层流的available方法返回0，指示将阻塞后续的输入请求

 

Socket isClosed()

Socket isConnected()

 

 

其他设置项

Socket setOOBInline(boolean on)：启用/禁用OOBINLINE（TCP紧急数据的接收）

Socket setSendBufferSize(int size)

Socket setReceiveBufferSize(int size)

Socket setKeepAlive(boolean on)：一种心跳机制，但是不见使用。

Socket setTrafficClass(int tc)

Socket setReuseAddress(boolean on)

Socket setTcpNoDelay(boolean on)

Socket setSoLinger(boolean on, int linger)：设置在关闭套接字时，是否立即返回（不等待底层数据发送完毕）

 

例子：实现基本的通讯（发包解包）、请求、心跳机制

服务端代码

package com.tongxun.server;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 服务器端Socket
 * @author Administrator
 */
public class SocketServer {
    private Map<String, Socket> socketMap = new ConcurrentHashMap<String, Socket>();
    private ServerSocket server; // 服务器端Socket对象
    private int port;//服务端端口
    private int timeout;//连接维持超时
    
    /**
     * 初始化服务器
     * @param port
     * @param timeout
     */
    public SocketServer(int port, int timeout) {
        if(port<=0 || timeout<=0) throw new IllegalArgumentException();
        
        this.port = port;
        this.timeout = timeout;
    }
    
    /**
     * 启动服务器socket
     */
    public void start(){
        try {
            // 创建一个ServerSocket在端口2121监听客户请求
            server = new ServerSocket(this.port);
            System.out.println("Server starts...");
        } catch (Exception e) {
            System.out.println("Can not listen to. " + e);
        }
        
        //接收客户端连接
        while (true) {
            try {
                acceptConn();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * 接收客户端连接
     * @throws IOException
     */
    private void acceptConn() throws IOException{
        Socket socket = server.accept();
        socket.setSoTimeout(1000);
        
        StringBuffer sb = new StringBuffer();
        sb.append(socket.getInetAddress().getHostAddress());
        sb.append(":");
        sb.append(socket.getPort());
        
        socketMap.put(sb.toString(), socket);
        
        new SRecvThread(socket, this).start();
    }

    public int getTimeout() {
        return timeout;
    }

    /**
     * 主方法
     * @param args
     */
    public static void main(String[] args) {
        SocketServer server = new SocketServer(2121, 10000);
        server.start();
    }
}

 

package com.tongxun.server;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.text.MessageFormat;

import com.tongxun.util.Message;
import com.tongxun.util.PackageHead;

/**
 * 接收线程
 * @author zhangjc
 */
public class SRecvThread extends Thread {
    
    private Socket socket; // 保存与本线程相关的Socket对象
    private BufferedInputStream inputStream;
    private BufferedOutputStream outputStream;
    private byte[] head = new byte[10];
    private long lastRecv = System.currentTimeMillis();//最近一次接收时间
    private boolean running = true;
    private BusiHandler handler;
    private SocketServer context;
    
    public SRecvThread(Socket socket, SocketServer context) {
        this.socket = socket;
        try {
            this.context = context;
            inputStream = new BufferedInputStream(this.socket.getInputStream(), 1024);
            outputStream = new BufferedOutputStream(this.socket.getOutputStream(), 1024);
            handler = new BusiHandler(outputStream);
            System.err.println(MessageFormat.format("客户端{0}登录系统", this.getConnInfo()));
        } catch (IOException e) {
            e.printStackTrace();
            close();
        }
    }
    
    public void run() {
        try {        
            while (running) {
                recv();
            }
        } catch (Exception e) {
            e.printStackTrace();
            this.close();
        }
    }

    /**
     * 连接关闭和收尾动作
     */
    private void close(){
        try {
            running = false;
            if(inputStream!=null) inputStream.close();
            if(outputStream!=null) outputStream.close();
            if(!socket.isConnected()) socket.close();
            System.out.println("连接断开");
        } catch (IOException e) {
            e.printStackTrace();
        } 
    }
    
    private String getConnInfo(){
        return this.socket.getInetAddress().getHostAddress()+":"+this.socket.getPort();
    }
    
    /**
     * 接收处理
     * @return
     * @throws Exception
     */
    private Message recv() throws Exception{
        Message msg = new Message();
        try {
            read(head);
            PackageHead headPack = new PackageHead(head);
            byte[] body = new byte[headPack.getLen()];
            if(headPack.getLen()>0){
                inputStream.read(body);
            }
            msg.setHead(headPack);
            msg.setBody(body);
            
            this.lastRecv = System.currentTimeMillis();
            
            handler.exe(msg);
        } catch (SocketTimeoutException e) {
            if(System.currentTimeMillis()-lastRecv >= context.getTimeout()){
                System.out.println(System.currentTimeMillis()-lastRecv);
                System.out.println("超时");
                this.close();
            }
        } 
        
        return msg;
    }
    
    /**
     * 读取buff长度的数据，如果len为-1则表示连接断开了
     * @param buff
     * @return
     * @throws Exception 
     */
    private int read(byte[] buff) throws Exception{
        int len = inputStream.read(buff);
        if(len==-1) throw new Exception("客户端连接断开");
        return len;
    }
}

 

package com.tongxun.server;

import java.io.BufferedOutputStream;
import java.io.IOException;

import com.tongxun.util.Message;
import com.tongxun.util.PackageHead;

/**
 * 业务处理
 * @author zhangjc
 */
public class BusiHandler {
    private BufferedOutputStream outputStream;
    
    public BusiHandler(BufferedOutputStream outputStream){
        this.outputStream = outputStream;
    }
    
    public void exe(Message msg) throws IOException{
        //心跳包处理
        System.out.println(msg.getHead());
        if(msg.getHead().getType() == 2){
            System.out.println("接收心跳");
            PackageHead retHead = new PackageHead();
            Message retMsg = new Message();
            retHead.setType((short)2);
            retMsg.setHead(retHead);
            retMsg.setBody(new byte[0]);
            
            outputStream.write(retMsg.toBytes());
            outputStream.flush();
        }
        
        //时间请求处理
        if(msg.getHead().getType() == 1){
            System.out.println("接收时间请求");
            PackageHead retHead = new PackageHead();
            Message retMsg = new Message();
            byte[] retBody = String.valueOf(System.currentTimeMillis()).getBytes();
            retHead.setType((short)1);
            retHead.setLen((short)retBody.length);
            retMsg.setHead(retHead);
            retMsg.setBody(retBody);
            
            outputStream.write(retMsg.toBytes());
            outputStream.flush();
        }
    }
}

 

客户端代码

package com.tongxun.client;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;

import com.tongxun.util.Message;
import com.tongxun.util.PackageHead;

/**
 * 客户端Socket
 * @author Administrator
 */
public class SocketClient {
    private int port;//服务器端口
    private String address;//服务器地址
    private int connTimeout;//建立连接时超时
    private int timeout;//连接维持超时
    private final int interval = 5000;//心跳包发送间隔
    private final int minTimeout = 9000;//最小超时时间
    private CRecvThread recvThread;//接收线程
    private HearbeatThread hearbeatThread;//心跳包发送线程
    private Socket socket;
    private BufferedInputStream inputStream;
    private BufferedOutputStream outputStream;
    
    /**
     * socket初始化
     * @param address 服务端地址
     * @param port 服务器端口
     * @param connTimeout 建立连接的超时时间
     */
    public SocketClient(String address, int port, int connTimeout, int timeout) {
        socket = new Socket();
        if(address == null || port<=0 || connTimeout<=0 || timeout<=0) throw new IllegalArgumentException();
        this.address = address;
        this.port = port;
        this.connTimeout = connTimeout;
        this.timeout = timeout;
    }
    
    /**
     * 建立连接并开启心跳发送线程和接收线程
     */
    public void start(){
        
        try{
            //在建立连接或发生错误之前，一直处于阻塞状态
            //所以最好设置一个超时时间
            socket.connect(new InetSocketAddress(address, port), connTimeout);
            //设置read方法最长阻塞时间，超过会触发SocketTimeoutException
            socket.setSoTimeout(1000);
            inputStream = new BufferedInputStream(this.socket.getInputStream(), 1024);
            outputStream = new BufferedOutputStream(this.socket.getOutputStream(), 1024);
        }catch(Exception e){
            //提示用户建立连接出错
            System.err.println(e);
            close(e);
        }
        System.err.println("Established a connection...");
        
        //接收线程
        recvThread = new CRecvThread(this);
        recvThread.start();
        
        //心跳发送线程
        hearbeatThread = new HearbeatThread(this);
        hearbeatThread.start();
    }
    
    /**
     * 关闭socket并做相应的收尾处理
     * @param e
     */
    public void close(Exception e){
        if(e!=null) e.printStackTrace();
        if(recvThread!=null) recvThread.close();
        if(hearbeatThread!=null) hearbeatThread.close();
        
        try {
            if(inputStream!=null) inputStream.close();
            if(outputStream!=null) outputStream.close();
            if(socket.isConnected()) socket.close();
            System.out.println("连接断开");
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
    
    /**
     * 发送时间请求
     */
    public void sendReq(){
        Message msg = new Message();
        PackageHead head = new PackageHead();
        head.setType((short)1);
        msg.setHead(head);
        msg.setBody(new byte[0]);
        try {
            outputStream.write(msg.toBytes());
            outputStream.flush();
            System.out.println("发送请求");
        } catch (Exception e) {
            close(e);
        }
    }
    
    public BufferedInputStream getInputStream() {
        return inputStream;
    }

    public BufferedOutputStream getOutputStream() {
        return outputStream;
    }

    public int getTimeout() {
        return timeout;
    }
    
    public int getInterval() {
        return interval;
    }

    public int getMinTimeout() {
        return minTimeout;
    }

    /**
     * 主方法
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        SocketClient client = new SocketClient("localhost", 2121, 5000, 10000);
        client.start();
        
        Thread.sleep(5000);
        client.sendReq();
    }
}

 

package com.tongxun.client;

import java.net.SocketTimeoutException;

import com.tongxun.util.Message;
import com.tongxun.util.PackageHead;

/**
 * 回包接收线程
 * @author zhangjc
 */
public class CRecvThread extends Thread {
    private byte[] head = new byte[10];//用来存放包头的缓存
    private long lastRecv = System.currentTimeMillis();//最后一次接收回包的时间
    private boolean running = true;
    private SocketClient context;
    
    public CRecvThread(SocketClient context) {
        this.context = context;
    }

    public void run() {
        try {
            while (running) {
                recv();
            }
        } catch (Exception e) {
            e.printStackTrace();
            context.close(e);
        }
    }

    public void close(){
        running = false;
    }
    
    private Message recv() throws Exception{
        Message msg = new Message();
        try {
            //读取包头
            read(head);
            PackageHead headPack = new PackageHead(head);
            byte[] body = new byte[headPack.getLen()];
            if(headPack.getLen()>0){
                read(body);    
            }
            msg.setHead(headPack);
            msg.setBody(body);
            
            this.lastRecv = System.currentTimeMillis();
            
            //心跳包处理
            if(msg.getHead().getType() == 2){
                System.out.println("心跳");
            }
            
            //时间请求回包
            if(msg.getHead().getType() == 1){
                if(msg.getBody()!=null){
                    System.out.println(new String(msg.getBody()));
                }
            }
            
        } catch (SocketTimeoutException e) {
            //定时触发SocketTimeoutException来判断连接是否超时
            if(System.currentTimeMillis()-lastRecv >= context.getTimeout()){
                context.close(e);
            }
        }
        
        return msg;
    }
    
    /**
     * 读取buff长度的数据，如果len为-1则表示连接断开了
     * @param buff
     * @return
     * @throws Exception 
     */
    private int read(byte[] buff) throws Exception{
        int len = context.getInputStream().read(buff);
        if(len==-1) throw new Exception("服务器连接断开");
        return len;
    }
}

 

package com.tongxun.client;

import com.tongxun.util.Message;
import com.tongxun.util.PackageHead;

/**
 * 心跳发送线程
 * @author zhangjc
 */
public class HearbeatThread extends Thread {
    private SocketClient context;
    private boolean running = true;
    
    public HearbeatThread(SocketClient context) {
        if(context==null){
            throw new IllegalArgumentException("context不能为null");
        }
        if(context.getTimeout() <= context.getMinTimeout()){
            throw new IllegalArgumentException("超时时间不能小于"+context.getMinTimeout());
        }
        
        this.context = context;
    }
    
    public void run() {
        try {
            sleep(context.getInterval());
            while (running) {
                //组包
                Message msg = new Message();
                PackageHead head = new PackageHead();
                head.setType((short)2);
                msg.setHead(head);
                msg.setBody(new byte[0]);
                //发送
                context.getOutputStream().write(msg.toBytes());
                context.getOutputStream().flush();
                
                sleep(context.getInterval());
            }
        } catch (Exception e) {
            context.close(e);
        }
    }
    
    public void close(){
        running = false;
    }
}

 

 

工具类

package com.tongxun.util;

/**
 * 基础数据与字节数组的转化
 * @author zhangjc
 */
public class BytesUtil {
    
    public static short getShort(byte[] b, int index) {  
        return (short) (((b[index + 1] << 8) | b[index + 0] & 0xff));  
    }  
    
    public static void putShort(byte b[], short s, int index) { 
        b[index + 1] = (byte) (s >> 8);  
        b[index + 0] = (byte) (s >> 0);  
    }  
}

 

package com.tongxun.util;

import java.io.ByteArrayOutputStream;
import java.io.IOException;

/**
 * 消息结构
 * @author zhangjc
 */
public class Message {
    private PackageHead head;
    private byte[] body;
    
    public PackageHead getHead() {
        return head;
    }
    public void setHead(PackageHead head) {
        this.head = head;
    }
    public byte[] getBody() {
        return body;
    }
    public void setBody(byte[] body) {
        this.body = body;
    }
    
    public byte[] toBytes() throws IOException{
        ByteArrayOutputStream array = new ByteArrayOutputStream();
        array.write(head.toBytes());
        array.write(getBody());
        return array.toByteArray();
    }
}

 

package com.tongxun.util;

/**
 * 消息头
 * 保留4个字节
 * @author zhangjc
 */
public class PackageHead{
    private byte[] bytes = new byte[10];
    
    /**长度*/
    private short len;
    /**数据类型*/
    private short type;
    /**目的地*/
    private short target;
    
    public PackageHead(byte[] bytes){
        this.bytes = bytes;
        
        this.len = BytesUtil.getShort(bytes, 0);
        this.type = BytesUtil.getShort(bytes, 2);
        this.target = BytesUtil.getShort(bytes, 4);
    }
    
    public PackageHead(){}
    
    public byte[] getBytes() {
        return bytes;
    }
    public void setBytes(byte[] bytes) {
        this.bytes = bytes;
    }
    public short getLen() {
        return len;
    }
    public void setLen(short len) {
        this.len = len;
    }
    public short getType() {
        return type;
    }
    public void setType(short type) {
        this.type = type;
    }
    public short getTarget() {
        return target;
    }
    public void setTarget(short target) {
        this.target = target;
    }
    
    public byte[] toBytes(){
        byte[] ret = new byte[10];
        BytesUtil.putShort(ret, (short)this.len, 0);
        BytesUtil.putShort(ret, (short)this.type, 2);
        BytesUtil.putShort(ret, (short)this.target, 4);
        ret[9] = 124;
        return ret;
    }
}

 

转载于:https://www.cnblogs.com/barker/p/5435573.html

dizai3980
关注
流式Socket编程
weixin_43136689的博客
04-09 1310
流式Socket编程 1、实现基于流式套接字的网络功能框架，包括客户端与服务端两个部分（以类的形式）； 2、在第一步的基础上，实现服务器/客户端之间的回射功能； 3、改进服务端程序，使其支持多线程，即为每个客户端请求创建一个服务线程； 客户端 // EchoTCPClientDemo.cpp : 定义控制台应用程序的入口点。 #include "stdafx.h" #define WIN32_LE...
java socket超时时间_java中socket 默认超时时间 | 学步园
weixin_30296363的博客
02-12 722
MS:永远吧Java代码connectpublicvoidconnect(SocketAddressendpoint,inttimeout)throwsIOExceptionConnectsthissockettotheserverwithaspecifiedtimeoutvalue.Atimeoutofzeroisinterpretedasaninfinite...
Socket编程模式理解与对比
diemi9921的博客
06-30 140
本文主要分析了几种Socket编程的模式。主要包括基本的阻塞Socket、非阻塞Socket、I/O多路复用。其中，阻塞和非阻塞是相对于套接字来说的，而其他的模式本质上来说是基于Socket的并发模式。I/O多路复用又主要分析了分析linux和windows下的常用模型。最后，比较这几种Socket编程模式的优缺点，并讨论多线程与Socket的组合使用和服务器开发的常用模式。 阻塞模式...
[网络编程]Socket_流式套接字编程
CSDN_orangeP
06-07 1527
流式套接字基本使用 在一个应用程序创建套接字进行通信时，socket()中的通信类型参数会让用户从数据流、数据报、原始类型中作出选择。其中数据流的传输方式就是基于TCP，而TCP因其数据流、可靠的特点适用于大多数情况。 流式套接字特点及适用情况 流式套接字基于传输控制协议提供面向连接的、可靠的（但也会比UDP付出更多传输代价的）数据流传输服务。 因其保证数据能无错无重发出、有序接收的可靠性，...
Socket(3)——Socket一般应用模式(服务器端和客户端)
qq_34573534的博客
08-27 744
1.服务端welcoming socket ：开始监听端口(负责监听客户端连接信息) 。 2.客户端client socket ：连接服务端指定端口(负责接收和发送服务端消息) 。 3.服务端welcoming socket ：监听到客户端连接，创建connection socket。(负责和客户端通信)。 说明：welcoming socket、client socket、welcomi...
Android Socket全部方法详情
7758258博客
12-26 1143
bind(SocketAddress bindpoint)//将套接字绑定到本地地址。 close()//关闭 connect(SocketAddress endpoint, int timeout)//使用指定的超时值将此套接字连接到服务器。 connect(SocketAddress endpoint)//将此套接字连接到服务器。 getChannel()//返回与此套接字关联的唯一S...
Linux Socket编程入门——浅显易懂
01-06
Socket3. 网络字节序4. sockaddr 数据结构5. 网络套接字API函数 5.1 socket（） 5.2 bind（） 5.3 listen（） 5.4 accept（） 5.5 connect（）6. 一个简单的C/S模型代码实例7.总结 1. 概述   网络通信，首先...
socket编程源码——TCP协议
06-04
在IT领域，Socket编程是构建网络应用程序的基础，它允许程序通过网络进行通信。TCP（Transmission Control Protocol）是一种面向连接的、可靠的传输层协议，广泛应用于互联网中的数据交换。本示例是一个C++实现的TCP...
socket编程——c语言封装——c++封装(一对一对话).zip
04-08
Socket编程是计算机网络通信的核心技术之一，特别是在C和C++这样的低级编程语言中，它提供了与操作系统底层网络服务直接交互的能力。本压缩包包含的资料着重于如何使用C语言和C++对Socket进行封装，以实现一对一对话...
socket编程源码——UDP协议
06-04
在UDP编程中，我们首先需要调用`socket()`函数创建一个套接字，指定协议族（AF_INET）和套接字类型（SOCK_DGRAM）。 2. **地址结构体**：在UDP中，数据报发送和接收需要知道对方的IP地址和端口号。这通常通过`...
Linux环境下C语言Socket编程——客户端向服务端单次发送一个或多个文件的功能
03-23
网上很多有关socket文件传输的源码都是每次只能发送一个文件，如果想传输多个文件，不但需要多次交互，还需要把每个文件的文件名都输入进去，很不方便，所以进行了一个小扩展：即客户端可以将打算传送的多个文件都先...
《Java TCP/IP Socket编程》读书笔记(15)
随风的专栏
01-30 2749
4.4 控制默认的行为 4.4.1 Keep-alive 如果一段时间内没有数据交换，通信的每个终端可能都会怀疑对方是否还处于活跃状态。TCP协议提供了一种keep-alive的机制，该机制在经过一段不活动时间后，将向另一个终端发送一个探测消息。如果另一个终端还出于活跃状态，它将回复一个确认消息。如果经过几次尝试后依然没有收到另一终端的确认消息，则终止发送探测信息，关闭套接字，并在下一
Socket类的使用
吴声子夜歌的博客
06-08 1205
绑定bind与connect以及端口生成的时机 public void bind (SocketAddress bindpoint)方法的作用是将套接字绑定到本地地址。如果地址为null,则系统将随机挑选一个空闲的端口和一个有效的本地地址来绑定套接字。 在Socket通信的过程中，服务端和客户端都需要端口来进行通信。而在前面的示例中,都是使用“new ServerSocket (8888)”的代码格式来创建Socket服务端，其中8888就是服务端的端口号。使用代码“new Socket (“localho
Androin学习笔记四十三：Socket(示例,出错代码)
自由的天空
05-20 1453
出处：http://www.apihome.cn/api/java/Socket.html java.net 类 Socket java.lang.Object java.net.Socket 直接已知子类：SSLSocket public class Socketextends Object 此类实现客户端套接字（也可以就叫“套接字”）。套接字是两台机器
java socket客户端连接池
热门推荐
一杯咖啡
08-29 1万+
最近因项目需要，需要使用socket长连接服务器，但是在网上查资料发现都是服务器的连接池，于是自己动手写了个客户端socket连接池，记之，仅供参考，里面的意义变量请自行替换，废话少说，上代码。 1.   socet信息类     package cn.richinfo.cloudp.dm.common.util; import java.net.Socket; /** * @C
java socket 的参数选项解读
weixin_30950607的博客
03-08 241
java socket中有很多参数可以选择，这篇博客的目的是沉淀出这些参数的语义和用法，供自己以后查阅。 1、java socket参数选项总览 在JDK1.6中有如下参数选项： 1 public final static int TCP_NODELAY = 0x0001; 2 3 public final static int SO_BINDADDR ...
socket技术详解（看清socket编程）
m0_67400973的博客
04-22 5037
socket编程是网络常用的编程，我们通过在网络中创建socket关键字来实现网络间的通信，通过收集大量的资料，通过这一章节，充分的了解socket编程，文章用引用了大量大神的分析，加上自己的理解，做个总结性的文章 1：socket大致介绍 socket编程是一门技术，它主要是在网络通信中经常用到 既然是一门技术，由于现在是面向对象的编程，一些计算机行业的大神通过抽象的理念，在现实中通过反复的理论或者实际的推导，提出了抽象的一些通信协议，基于tcp/ip协议，提出大致的构想，一些泛型的程序大牛在这个协议的基
TCP Socket编程实现——计算机网络原理实验报告
"计算机网络原理(双语)-TCP协议的Socket编程实现 实验报告涵盖了使用Java或Python编程语言实现TCP协议的Socket编程，旨在实现客户端和服务器端的数据双向通信。实验过程中，学生需按照特定步骤建立TCP服务器连接，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值