kotlin+Socket+协程 示例

最新推荐文章于 2024-05-20 10:04:32 发布
最新推荐文章于 2024-05-20 10:04:32 发布
阅读量2.3k 收藏 13
点赞数 1
分类专栏： 学习笔记 文章标签： socket 协程 kotlin
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tomcat0916/article/details/117415968
版权

kotlin+Socket+协程 示例

Client.kt
class ClientManager(
    var address: String,
    var onLicked: ((String?, Exception?) -> Unit)? = null
) {

    private val scope = MainScope()

    private var socket: Socket? = null

    @Synchronized
    private fun getSocket(block: (Socket) -> Unit) {
        socket?.apply {
            block.invoke(this)
        } ?: let {
            scope.launch(Dispatchers.IO) {
                try {
                    socket = Socket(address, SERVER_PORT).apply {
                        e("启动客户端,IP:${this.inetAddress}端口号:${this.port}")
                        onLicked?.invoke(inetAddress?.hostAddress, null)
                        block.invoke(this)
                    }
                } catch (e: Exception) {
                    e.printStackTrace()
                    onLicked?.invoke("", e)
                }
            }
        }
    }

    fun startClient(
        onReceive: ((String?) -> Unit)? = null,
        success: ((Exception?) -> Unit)? = null
    ) {
        getSocket {
            scope.receive(it, onReceive, success)
        }
    }

    fun sendMsg(msg: String, result: ((Exception?) -> Unit)? = null) {
        getSocket {
            scope.send(socket, msg, result)
        }
    }

    fun close(onCutoff: ((String?) -> Unit)? = null) {
        socket?.closed(onCutoff)
        scope.cancel()
        socket = null
    }
}

internal fun Socket.closed(onCutoff: ((String?) -> Unit)? = null) {
    try {
        close()
        e("关闭客户端")
        onCutoff?.invoke(this.inetAddress?.hostAddress)
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

internal fun CoroutineScope.send(
    socket: Socket?,
    msg: String,
    result: ((Exception?) -> Unit)? = null,
    onCutoff: ((String?) -> Unit)? = null
): Job {
    return this.launch(Dispatchers.IO) {
        try {
            withTimeout(Constant.TIME_OUT_SEND) {
                socket?.getOutputStream()?.let {
                    e("客户端发送:$msg")
                    it.write(msg.toByteArray(Charsets.UTF_8))
                    it.flush()
                    withMain { result?.invoke(null) }
                }
                    ?: withMain { result?.invoke(NullPointerException("socket or OutputStream is null")) }
            }
        } catch (e: Exception) {
            e.printStackTrace()
            socket?.closed(onCutoff)
            withMain { result?.invoke(e) }
        }
    }
}

internal fun CoroutineScope.receive(
    socket: Socket?,
    onReceive: ((String?) -> Unit)? = null,
    success: ((Exception?) -> Unit)? = null,
    onCutoff: ((String?) -> Unit)? = null
): Job {
    return this.launch(Dispatchers.IO) {
        socket?.apply {
            if (isClosed) {
                withMain { success?.invoke(SocketException("Socket is closed")) }
            }
            while (!isClosed) {
                try {
                    getInputStream()?.use { input ->
                        withMain { success?.invoke(null) }
                        val buffer = ByteArray(1024)
                        var len: Int
                        while (input.read(buffer).also { len = it } != -1) {
                            val msg = String(buffer, 0, len)
                            if (!msg.isReceipt()) {
                                getOutputStream()?.let {
                                    it.write(
                                        "${Constant.TAG_RECEIPT_HEADER}客户端回执:已收到消息".toByteArray(
                                            Charsets.UTF_8
                                        )
                                    )
                                    it.flush()
                                }
                            }
                            val s = msg.removeHeader()
                            withMain { onReceive?.invoke(s) }
                            e("收到来自${socket.inetAddress.hostAddress}:${socket.port}的数据为：$s")
                        }
                        withMain { onReceive?.invoke("断开连接") }
                        socket.closed(onCutoff)
                    }
                        ?: withMain { success?.invoke(NullPointerException("socket or InputStream is null")) }
                } catch (e: Exception) {
                    e.printStackTrace()
                    socket.closed(onCutoff)
                    withMain { success?.invoke(e) }
                }
            }
        } ?: withMain { success?.invoke(NullPointerException("socket is null")) }
    }
}
Server.kt
class ServerManager(var launch: ((String?, Exception?) -> Unit)? = null) {
    private var clientCount = 0
    private val socketMap = HashMap<String, Socket>()
    private val clientAddress = ArrayList<String>()
    private val scope = MainScope()
    private var serverSocket: ServerSocket? = null

    private fun addSocket(address: String?, socket: Socket?) {
        if (!(address.isNullOrEmpty() || clientAddress.contains(address))) {
            socket?.apply {
                clientAddress.add(address)
                socketMap[address] = socket
                clientCount = socketMap.size
                e(address, clientCount)
            }
        }
    }

    private fun removeSocket(address: String?) {
        if (!address.isNullOrEmpty()) {
            clientAddress.remove(address)
            socketMap.remove(address)
            clientCount = socketMap.size
        }
    }

    @Synchronized
    private fun getServerSocket(block: (ServerSocket) -> Unit) {
        serverSocket?.apply {
            block.invoke(this)
        } ?: let {
            try {
                serverSocket =
                    ServerSocket(
                        Constant.SERVER_PORT,
                        Constant.MAX_BACKLOG,
                        InetAddress.getByName(getIpV4String())
                    ).apply {
                        e("启动服务 IP:${this.localSocketAddress}")
                        launch?.invoke(this.inetAddress.hostAddress, null)
                        block.invoke(this)
                    }
            } catch (e: Exception) {
                launch?.invoke("", e)
            }
        }
    }

    fun startServer(
        onReceive: ((String?) -> Unit)? = null,
        onLink: ((address: String?, socket: Socket?, error: Exception?) -> Unit)? = null
    ) {
        getServerSocket {
            scope.accept(it, onReceive, {
                removeSocket(it)
            }) { address, socket, error ->
                onLink?.invoke(address, socket, error)
                addSocket(address, socket)
            }
        }
    }

    fun close() {
        serverSocket?.closed()
        scope.cancel()
        socketMap.forEach {
            try {
                it.value.close()
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
        socketMap.clear()
        clientAddress.clear()
    }

    fun sendMsg(msg: String, result: ((Exception?) -> Unit)? = null) {
        scope.launch(Dispatchers.IO) {
            try {
                var count = 0
                socketMap.forEach {
                    it.value.getOutputStream()?.let { out ->
                        out.write(msg.toByteArray(Charsets.UTF_8))
                        out.flush()
                        val s = "服务端发送:$msg"
                        e(s)
                        count++
                    }
                }
                if (count != clientCount) {
                    withMain { result?.invoke(SocketException("${clientCount - count} failed")) }
                }
            } catch (e: Exception) {
                e.printStackTrace()
                withMain { result?.invoke(e) }
            }
        }
    }

    fun sendMsg(address: String, msg: String, result: ((Exception?) -> Unit)? = null) {
        scope.launch(Dispatchers.IO) {
            try {
                socketMap[address]?.getOutputStream()?.let { out ->
                    out.write(msg.toByteArray(Charsets.UTF_8))
                    out.flush()
                    val s = "服务端发送:$msg"
                    e(s)
                    withMain { result?.invoke(null) }
                }
                    ?: withMain { result?.invoke(NullPointerException("socket or OutputStream is null")) }
            } catch (e: Exception) {
                e.printStackTrace()
                withMain { result?.invoke(e) }
            }
        }
    }

    private fun getIpV4String(): String? {
        try {
            val enNetI: Enumeration<NetworkInterface> = NetworkInterface.getNetworkInterfaces()
            while (enNetI.hasMoreElements()) {
                val netI: NetworkInterface = enNetI.nextElement()
                val enumIp: Enumeration<InetAddress> = netI.inetAddresses
                while (enumIp.hasMoreElements()) {
                    val ip: InetAddress = enumIp.nextElement()
                    if (ip is Inet4Address && !ip.isLoopbackAddress) {
                        return ip.hostAddress
                    }
                }
            }
        } catch (e: SocketException) {
            e.printStackTrace()
        }
        return "127.0.0.1"
    }
}

internal fun ServerSocket.closed(onCutoff: ((String?) -> Unit)? = null) {
    try {
        close()
        e("关闭服务端")
        onCutoff?.invoke(this.inetAddress?.hostAddress)
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

internal fun CoroutineScope.accept(
    serverSocket: ServerSocket?,
    onReceive: ((String?) -> Unit)? = null,
    onCutoff: ((String?) -> Unit)? = null,
    success: ((address: String?, socket: Socket?, error: Exception?) -> Unit)? = null
): Job {
    return this.launch(Dispatchers.IO) {
        val mutex = Mutex()
        serverSocket?.apply {
            if (isClosed) {
                withMain { success?.invoke("", null, SocketException("serverSocket is closed")) }
            }
            while (!isClosed) {
                try {
                    accept()?.let { socket ->
                        socket.remoteSocketAddress?.apply {
                            mutex.withLock(this) {
                                withMain {
                                    success?.invoke(
                                        socket.inetAddress.hostAddress,
                                        socket,
                                        null
                                    )
                                }
                                receive(socket, onReceive, onCutoff)
                            }
                        }
                    }
                } catch (e: Exception) {
                    serverSocket.closed()
                    withMain { success?.invoke("", null, e) }
                }
            }
        } ?: withMain { success?.invoke("", null, NullPointerException("serverSocket is null")) }
    }
}

internal fun CoroutineScope.receive(
    socket: Socket?,
    onReceive: ((String?) -> Unit)? = null,
    onCutoff: ((String?) -> Unit)? = null
): Job {
    return this.launch(Dispatchers.IO) {
        socket?.apply {
            try {
                getInputStream()?.let { input ->
                    val buffer = ByteArray(1024)
                    var len: Int
                    while (input.read(buffer).also { len = it } != -1) {
                        val msg = String(buffer, 0, len)
                        if (!msg.isReceipt()) {
                            getOutputStream()?.let {
                                it.write(
                                    "${Constant.TAG_RECEIPT_HEADER}服务端回执:已收到消息".toByteArray(
                                        Charsets.UTF_8
                                    )
                                )
                                it.flush()
                            }
                        }
                        val s = msg.removeHeader()
                        withMain { onReceive?.invoke(s) }
                        e("收到来自${socket.inetAddress.hostAddress}:${socket.port}的数据为：$s")
                    }
                    withMain { onReceive?.invoke("断开连接") }
                    socket.closed(onCutoff)
                }
            } catch (e: Exception) {
                socket.closed(onCutoff)
                e.printStackTrace()
            }
        }
    }
}
工具
Constant
public interface Constant {
    String TAG_RECEIPT_HEADER = "${HZ}$:";
    int SERVER_PORT = 10086;
    long TIME_OUT_SEND = 30000;
    long TIME_OUT_LINK = 30000;
    int MAX_BACKLOG = 50;
}
Utils.kt
internal fun String.isReceipt() = startsWith(Constant.TAG_RECEIPT_HEADER)

internal fun String.removeHeader() = if (isReceipt()) StringBuffer(this)
    .replace(0, getHeaderLength(), "")
    .toString() else this

internal fun getHeaderLength() = Constant.TAG_RECEIPT_HEADER.length

internal suspend fun <T> withMain(block: suspend CoroutineScope.() -> T) {
    withContext(Dispatchers.Main, block = block)
}

internal suspend fun <T> withIO(block: suspend CoroutineScope.() -> T) {
    withContext(Dispatchers.IO, block = block)
}
Log.kt
private fun getInfo(): String {
    val targetElement = Thread.currentThread().stackTrace[4]
    var className = targetElement.className
    val classNameInfo = className.split("\\.".toRegex()).toTypedArray()
    if (classNameInfo.isNotEmpty()) {
        className = classNameInfo[classNameInfo.size - 1]
    }
    if (className.contains("$")) {
        className = className.split("\\$".toRegex()).toTypedArray()[0]
    }
    return "Thread: ${Thread.currentThread().name}, ${targetElement.methodName}(${className}.java:${targetElement.lineNumber})${
        System.getProperty(
            "line.separator"
        )
    }"
}

internal fun e(vararg msgs: Any?) {
    val info = getInfo()
    Log.e("header", info)
    msgs.forEach {
        Log.e("body", it.toString())
    }
    Log.e("end", "________________________________________")
}

internal fun i(vararg msgs: Any?) {
    val info = getInfo()
    Log.i("header", info)
    msgs.forEach {
        Log.i("body", it.toString())
    }
    Log.i("end", "________________________________________")
}


internal fun d(vararg msgs: Any?) {
    val info = getInfo()
    Log.d("header", info)
    msgs.forEach {
        Log.d("body", it.toString())
    }
    Log.d("end", "________________________________________")
}

internal fun w(vararg msgs: Any?) {
    val info = getInfo()
    Log.w("header", info)
    msgs.forEach {
        Log.w("body", it.toString())
    }
    Log.w("end", "________________________________________")
}
MainActivity
class MainActivity : AppCompatActivity() {
    private var clientManager: ClientManager? = null
    private var serverManager: ServerManager? = null
    override fun onDestroy() {
        clientManager?.close()
        serverManager?.close()
        super.onDestroy()
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        serverManager ?: let {
            serverManager = ServerManager { s, e ->
                e(s, e?.message)
            }.apply {
                startServer({
                    e(it)
                    onReceive(it)
                }, { s, sc, e ->
                    e(s, e?.message)
                    if (s.isNullOrEmpty()) {
                        onReceive("连接客户端失败")
                    } else {
                        onReceive("连接客户端:$s")
                    }
                })
            }
        }
        btn_link?.setOnClickListener {
            link()
        }
        btn_client_send?.setOnClickListener { clientSend() }
        btn_server_send?.setOnClickListener { serverSend() }
        tv_receive_msg?.movementMethod = ScrollingMovementMethod.getInstance()
    }

    @SuppressLint("SetTextI18n")
    fun onReceive(msg: String?) {
        runOnUiThread {
            tv_receive_msg?.text = "${tv_receive_msg?.getString()}\n$msg"
        }
    }

    private fun link() {
        et_server_address?.getString()?.apply {
            if (!isNullOrEmpty()) {
                clientManager = ClientManager(this) { s, e ->
                    e(s, e)
                    if (s.isNullOrEmpty()) {
                        onReceive("连接服务端失败")
                    } else {
                        onReceive("连接服务端:$s")
                    }
                }.apply {
                    startClient({
                        e(it)
                        onReceive(it)
                    }, {
                        e(it?.message)
                    })
                }
            } else {
                toast("地址不能为空")
            }
        }
    }

    private fun clientSend() {
        et_send_msg?.getString()?.apply {
            if (!isNullOrEmpty()) {
                clientManager?.sendMsg(this) {
                    e(it?.message)
                }
                et_send_msg?.setText("")
            } else {
                toast("消息不能为空")
            }
        }
    }

    private fun serverSend() {
        et_send_msg?.getString()?.apply {
            if (!isNullOrEmpty()) {
                serverManager?.sendMsg(this) {
                    e(it?.message)
                }
                et_send_msg?.setText("")
            } else {
                toast("消息不能为空")
            }
        }
    }

    private fun TextView.getString() = text?.toString() ?: ""

    private fun toast(msg: String) {
        Toast.makeText(this, msg, Toast.LENGTH_SHORT).show()
    }
}
TomCat0916
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Kotlin+MVVM+Retrofit+协程+ViewBinding+EventBus
05-21
Kotlin+MVVM+Retrofit+协程+ViewBinding+EventBus，准备入门kotlin和mvvm的完全可以以本项目为基础，强大、简单、易用！
MVVMLin:一个基于MVVM用Kotlin+Retrofit+协程+Databinding+LiveData来封装的快速开发框架
05-23
MVVMLin 一个基于MVVM用Kotlin+Retrofit+协程+Databinding(ViewBinding)+LiveData来封装的快速开发框架： 项目地址： 框架简介 使用技术 基于MVVM模式用了 kotlin+协程+retrofit+livedata+DataBinding 基本封装 封装了BaseActivity、BaseFragment、BaseViewModel基于协和的网络请方式更加方便，考虑到有些小伙伴不太喜欢用DataBinding在xml中绑定数据的方式，也提供了相应的适配，两种方式自行选择。Retrofit2.6及以上版本提供了对协程的支持，使用起来更加方便，不用考虑类型的转换了。 特点 使用Rxjava 处理不好的话会有内存泄露的风险，我们会用使用AutoDispose、RxLifecycle等方式来处理，但是使用协程来请求数据，完全不用担心这个问题，
SocketioDemo(Kotlin)
08-27
一个用socketio实现长连接的demo，与官方的demo相比，该代码显得不这么多，杂。更适合Socketio初学者。kotlin编写
探索 RSocket Kotlin：新一代的异步通信协议实现
最新发布
gitblog_00043的博客
05-20 865
探索 RSocket Kotlin：新一代的异步通信协议实现 项目地址:https://gitcode.com/rsocket/rsocket-kotlin 在寻求高效、灵活且具有反应式流语义的通信框架时，RSocket Kotlin 是一个值得尝试的创新解决方案。这个开源项目基于 Kotlin 的协程库 kotlinx.coroutines 和 ktor-io 实现，为多平台交互提供了强大的支持...
安卓Kotlin 简易带缓冲Socket 客户端(Client)
星空千代
06-01 901
如果实现progress接口，还可以做到进度显示 Client.kt 本客户端在实现缓冲时还用到了安卓Kotlin 简易 ByteArray 先入先出(FIFO)队列 //Fumiama 20210601 //Client.kt import android.util.Log import java.io.* import java.lang.Thread.sleep import java.net.Socket class Client(private val ip: String, private.
Kotlin进程通信------Socket
双斧狂暴战专栏
07-13 3833
Socket作为进程通信的一种方式，在日常的进程通信中使用的不频繁，它更常用的是即时通讯、跨设备的一对多场景等。android进程间通信中使用socket，一般是一对一的场景，是常用Socket方式的降级、简单化的使用方式。 Socket的使用，需要了解、注意的是它的握手、挥手机制。 简洁明了的，可以参考： 为什么不能用两次握手进行连接？ 为什么socket是三次握手挥手却是四次？ 详细解释的，可以参考：HTTP、HTTPS、TCP/IP、Socket通信、三次握手四次挥手过程？ 回到andro
Kotlin中的IO
weixin_34279246的博客
11-05 377
博客地址sguotao.top/Kotlin-2018… IO流是Java中很重要的一部分内容，常用的数据传输，文件的上传和下载都和它分不开。那么与Java中的IO相比，Kotlin中的IO又是怎样的呢？ Java中的IO Java中的IO根据处理数据的方式，可以分为字节流和字符流，同时根据传输方向的不同，又可以分为输入流和输出流。先来看一张Java IO的框架图。 在这张图中，整理了在Java...
kotlin,socket网络传输数据
qq_63053996的博客
03-01 477
kotlin,socket网络传输数据
简单的Kotlin使用Socket与服务端进行通信
xz2dai的博客
08-19 6689
简单Kotlin使用Socket与服务端进行通信客户端连接发送信息接收信息断开连接服务端监听端口&连接完整客户端代码 个人的一些学习经验分享 客户端 连接 与http不同，Socket是长连接，所以只要开始的时候连接一次就好了，理论上客户端和服务端一旦建立连接，则不会主动断掉 fun initConnect():Socket{ val sc:Socket = Socket(ip, port) //通过socket连接服务器,参数ip为服务端ip地址，port为服务端监听端口
简单天气--Kotlin+JetPack+协程+MVVM架构
05-21
简单天气APP，使用彩云天气api，使用Kotlin语言基于MVVM模式结合JetPack组件库：LiveData、ViewModel、Lifecycle、Navigation、Room组件，以及使用协程+Retrofit进行网络请求 开发的一款天气app
kotlin-rxokhttp-websocket,基于okhttp和gson的kotlin和rxkotlin的websocket绑定.zip
10-10
基于okhttp和gson的kotlin和rxjava/rxkotlin的websocket库
AndroidServer:基于 Kotlin + Netty 开发，为 Android App 提供 Server 的功能，包括 Http、TCP、WebSocket 服务
04-15
AndroidServer 基于 Kotlin + Netty 开发，为 Android App 提供 Server 的功能，包括 Http、TCP、WebSocket 服务 Feature: 支持 Http、TCP、WebSocket 服务 支持 Rest 风格的 API、文件上传、下载 支持加载静态网页 Http 的路由表、全局的 HttpFilter 均采用字典树(Tried Tree)实现 日志隔离，开发者可以使用自己的日志库 core 模块只依赖 netty-all，不依赖其他第三方库 最新版本 模块 最新版本 android-server-core android-server-converter-gson 下载安装 Gradle: implementation 'com.safframework.server:android-server-core:<latest-versi
tut-spring-webflux-kotlin-rsocket:带有Kotlin协程和RSocket的Spring Boot
04-28
目录 本教程向您展示如何使用Spring Boot和Kotlin构建一个简单的聊天应用程序。 您将从语法的角度了解使用Kotlin进行服务器端开发的好处。 我们将从最小的应用程序实现开始，然后逐步进行开发，首先，该应用程序将生成并显示虚假消息，并使用经典的阻塞请求-响应模型将数据获取到UI。在本教程中，我们将通过添加持久性和扩展来发展应用程序，并迁移到非阻塞流样式以从后端向UI提供数据。 本教程包括5个部分： 第1部分：初始设置和项目简介 第2部分：添加持久性和集成测试 第3部分：实现扩展 第4部分：使用Kotlin Coroutines重构到Spring WebFlux 第5部分：使用RSocket进行流传输 本教程是为Java开发人员设计的，他们已经接触过Spring MVC / WebFlux，并且想了解如何在Spring中使用Kotlin。 第1部分：初始设置和项目简介
rsocket-kotlin：RSocket Kotlin多平台实现
02-03
索科特·Kotlin 基于RSocket Kotlin多平台实现。 RSocket是一种二进制协议，可用于字节流传输，例如TCP，WebSockets和Aeron。 它通过通过单个连接传递的异步消息来启用以下对称交互模型： 请求/响应（1个流） 请求/流（有限的流） 一劳永逸（无回应） 事件订阅（无限多） 进一步了解 支持的平台和运输： 传输基于实施，以确保Kotlin多平台。 因此，它取决于可用的传输和平台（JVM，JS，Native）的ktor引擎： JVM-客户端和服务器均使用TCP和WebSocket JS-仅WebSocket客户端 本机-仅TCP客户端（Linu
Jetpack-WanAndroid：Kotlin + Jetpack +协程+ Retrofit + koin完成的MVVM组件化客户端:fire::fire:
02-04
【标题】中的“Jetpack-WanAndroid”是一个基于Kotlin、Jetpack、协程(Coroutines)、Retrofit和Koin库开发的MVVM架构组件化的Android客户端项目。这个项目展示了如何利用现代Android开发工具和技术栈来构建一个高效...
kotlin+ViewModel+LiveData+协程的练习小项目
03-02
在这个“kotlin+ViewModel+LiveData+协程”的练习小项目中，我们将深入探讨这四个关键概念以及它们如何协同工作以创建高性能的Android应用。 首先，Kotlin是Google推荐的Android开发语言，它提供了许多Java没有的...
Kotlin学习系列之：协程的创建（二）
xlh1191860939的博客
08-01 369
在系列一中，我们已经对协程有了初步的了解，我们在此篇继续。前面我们是通过GlobalScope.launch{}这个协程建造器来创建协程的，它的特点就是： Launches a new coroutine without blocking the current thread. 即不会阻塞当前的线程的运行。我们再来接触一个不一样的协程建造器： runBlocking{} ...
Android Kotlin WebSoket使用总结
m0_50774720的博客
08-28 471
【代码】Android Kotlin WebSoket使用总结。
kotlin socket设置超时时间
change_fate的博客
02-01 210
socket 不主动关闭的情况下，超时时间一般很长。如何设置连接超时时间
kotlin+深入理解协程
11-10
Kotlin协程是一种轻量级的线程处理机制，它可以在不创建新线程的情况下实现异步操作。Kotlin协程的优势在于它提供了一种结构化并发的方式，使得异步代码更加易于编写和维护。下面是深入理解Kotlin协程的一些方法和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值