【2023】Kotlin教程第四篇项目实战第26章项目实战2：开发Kotlin版QQ聊天工具 26.8 任务7：聊天过程实现

系统管理员 2024-03-23 16:04 38阅读 0赞

### 【2023】Kotlin教程 ###

#### 文章目录 ####

*   *  【2023】Kotlin教程
     *   *  第四篇 项目实战
         *  第26章 项目实战2：开发Kotlin版QQ聊天工具
         *   *  26.8 任务7：聊天过程实现
             *   *  26.8.1 迭代7.1：客户端用户1向用户3发送消息
                 *  26.8.2 迭代7.2：服务器接收用户1消息与转发给用户3消息
                 *  26.8.3 迭代7.3：客户端用户3接收用户1消息

![在这里插入图片描述][4ede5c5878794212a8743397fdabb857.png_pic_center]

#### 第四篇 项目实战 ####

#### 第26章 项目实战2：开发Kotlin版QQ聊天工具 ####

##### 26.8 任务7：聊天过程实现 #####

聊天过程如下图所示，客户端用户1向用户3发送消息，这个过程实现有三个步骤：

![在这里插入图片描述][549ffefcea894649b2bd3f88da121ba3.png_pic_center]

*  第①步。客户端用户1向用户3发送消息。
 *  第②步。服务器接收用户1消息与转发给用户3消息。
 *  第③步。客户端用户3接收用户1消息。

###### 26.8.1 迭代7.1：客户端用户1向用户3发送消息 ######

客户端用户1向用户3发送消息实现是在聊天窗口ChatFrame中实现的。ChatFrame.kt相关代码如下：

ChatFrame.kt

package com.dingjiaxiong.client
    
    import com.beust.klaxon.JsonObject
    import kotlinx.coroutines.*
    import java.awt.Color
    import java.awt.Toolkit
    import java.awt.event.WindowAdapter
    import java.awt.event.WindowEvent
    import java.net.DatagramPacket
    import java.net.InetAddress
    import java.text.SimpleDateFormat
    import java.util.*
    import javax.swing.*
    
    /**
     * @Projectname: QQ
     * @Classname: ChatFrame
     * @Author: Ding Jiaxiong
     * @Data:2023/4/7 14:53
     */
    
    class ChatFrame(// 好友列表Frame
        private val friendsFrame: FriendsFrame,
        user: Map<String, Any>,
        friend: Map<String, String>
    ) : JFrame() {
        
    
        // 当前用户Id
        private val userId = user["user_id"] as String
    
        // 聊天好友用户Id
        private val friendUserId: String
    
        // 聊天好友用户名
        private val friendUserName: String
    
        // 获得当前屏幕的高和宽
        private val screenHeight = Toolkit.getDefaultToolkit().screenSize.getHeight()
        private val screenWidth = Toolkit.getDefaultToolkit().screenSize.getWidth()
    
        // 登录窗口宽和高
        private val frameWidth = 360
        private val frameHeight = 330
    
        // 查看消息文本区
        private val txtMainInfo = JTextArea()
    
        // 发送消息文本区
        private val txtInfo = JTextArea()
    
        // 消息日志
        private val infoLog = StringBuffer()
    
        // 日期格式化
        private val dateFormat = SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
    
        //声明一个协程引用
        private var job: Job? = null
    
        // 协程运行状态
        private var isRunning = true
    
        // 查看消息面板
        private val panLine1: JPanel
            get() {
        
                txtMainInfo.isEditable = false
    
                val panLine1 = JPanel().apply {
        
                    layout = null
                    setBounds(5, 5, 330, 210)
                    border = BorderFactory.createLineBorder(Color.blue, 1)
                }
                with(JScrollPane()) {
        
                    setBounds(5, 5, 320, 200)
                    panLine1.add(this)
                    setViewportView(txtMainInfo)
                }
    
                return panLine1
            }
    
        // 发送消息面板
        private val panLine2: JPanel
            get() {
        
                val panLine2 = JPanel().apply {
        
                    layout = null
                    setBounds(5, 220, 330, 50)
                    border = BorderFactory.createLineBorder(Color.blue, 1)
                    add(sendButton)
                }
                with(JScrollPane()) {
        
                    setBounds(5, 5, 222, 40)
                    panLine2.add(this)
                    setViewportView(txtInfo)
                }
    
                return panLine2
            }
    
        private val sendButton: JButton
            get() {
        
                val button = JButton("发送").apply {
        
                    setBounds(232, 10, 90, 30)
                }
                button.addActionListener {
        
                    sendMessage()
                    txtInfo.text = ""
                }
                return button
            }
    
        init {
        
    
            val userIcon = user["user_icon"]!!
            friendUserId = friend["user_id"]!!
            friendUserName = friend["user_name"]!!
    
            /// 初始化当前Frame
            val iconFile = "images/$userIcon.jpg"
            iconImage = Toolkit.getDefaultToolkit().getImage(iconFile)
            title = "与${
          friendUserName}聊天中..."
            isResizable = false
            layout = null
    
            // 设置Frame大小
            setSize(frameWidth, frameHeight)
            // 计算Frame位于屏幕中心的坐标
            val x = (screenWidth - frameWidth).toInt() / 2
            val y = (screenHeight - frameHeight).toInt() / 2
            // 设置Frame位于屏幕中心
            setLocation(x, y)
    
            // 初始化查看消息面板
            contentPane.add(panLine1)
            // 初始化发送消息面板
            contentPane.add(panLine2)
    
            // 注册窗口事件
            addWindowListener(object : WindowAdapter() {
        
                // 单击窗口关闭按钮时调用
                override fun windowClosing(e: WindowEvent) {
        
                    //停止协程
                    stopCoroutine()
                    isVisible = false
                    // 重启好友列表协程
                    friendsFrame.resetCoroutine()
                }
            })
            // 启动接收消息子协程
            resetCoroutine()
        }
    
        private fun sendMessage() {
        
    
            if (txtInfo.text != "") {
        
    
                // 获得当前时间，并格式化
                val date = dateFormat.format(Date())
    
                val info = "#$date#\n您对${
          friendUserName}说：${
          txtInfo.text}"
                infoLog.append(info).append('\n')
                txtMainInfo.text = infoLog.toString()
    
                val jsonObj = JsonObject()
                jsonObj["receive_user_id"] = friendUserId
                jsonObj["user_id"] = userId
                jsonObj["message"] = txtInfo.text
                jsonObj["command"] = COMMAND_SENDMSG
    
                val address = InetAddress.getByName(SERVER_IP)
                // 发送数据报
                val buffer = jsonObj.toJsonString().toByteArray()
                val packet = DatagramPacket(buffer, buffer.size, address, SERVER_PORT)
                socket.send(packet)
            }
        }
    
        // 重新启动接收消息子协程
        fun resetCoroutine() = runBlocking<Unit> {
        
            isRunning = true
            // 创建协程
            job = GlobalScope.launch {
        
                run()
            }
        }
    
        // 停止接收消息子协程
        fun stopCoroutine() = runBlocking<Unit> {
        
            isRunning = false
            //取消协程
            job?.cancelAndJoin()
        }
    
        //协程体执行的挂起函数
        suspend fun run() {
        
            // 准备一个缓冲区
            val buffer = ByteArray(1024)
            while (isRunning) {
        
    
                val address = InetAddress.getByName(SERVER_IP)
                /* 接收数据报 */
                val packet = DatagramPacket(buffer, buffer.size, address, SERVER_PORT)
                try {
        
                    // 开始接收
                    socket.receive(packet)
    
                    val stringObj = String(buffer, 0, packet.length)
                    // 打印接收的数据
                    println("从服务器接收的数据：$stringObj")
    
                    val jsonObj = parser.parse(StringBuilder(stringObj)) as JsonObject
    
                    val cmd = jsonObj.int("command")
                    //command不等于空值时候执行，不等于空值或是
                    if (cmd != null && cmd == COMMAND_REFRESH) {
        
                        // 获得好友列表
                        val userIdList = jsonObj["OnlineUserList"] as List<String>
                        // 刷新好友列表
    //                    friendsFrame.refreshFriendList(userIdList)
                    } else {
        
                        // 获得当前时间，并格式化
                        val date = dateFormat.format(Date())
                        val message = jsonObj.string("message")
                        if (message != null) {
        
                            val info = "#$date#\n${
          friendUserName}对您说：$message"
                            infoLog.append(info).append('\n')
    
                            txtMainInfo.text = infoLog.toString()
                            txtMainInfo.caretPosition = txtMainInfo.document.length
                        }
                    }
                    delay(100L)
                } catch (e: Exception) {
        
                    //捕获超时异常，继续
                }
            }
        }
    }

###### 26.8.2 迭代7.2：服务器接收用户1消息与转发给用户3消息 ######

服务器接收用户1消息与转发给用户3消息是在Server中完成，相关代码如下：

Server.kt

package com.dingjiaxiong.server
    
    import com.beust.klaxon.JsonObject
    import com.beust.klaxon.Parser
    import com.beust.klaxon.json
    import java.net.DatagramPacket
    import java.net.DatagramSocket
    
    /**
     * @Projectname: QQ
     * @Classname: Server
     * @Author: Ding Jiaxiong
     * @Data:2023/4/7 15:02
     */
    
    // 操作命令代码
    const val COMMAND_LOGIN = 1 // 登录命令
    const val COMMAND_LOGOUT = 2 // 下线命令
    const val COMMAND_SENDMSG = 3 // 发消息命令
    const val COMMAND_REFRESH = 4 // 刷新好友列表命令
    
    // 服务器端口
    const val SERVER_PORT = 7788
    
    fun main() {
        
    
        println("服务器启动, 监听自己的端口$SERVER_PORT...")
        //JSON解析器
        val parser = Parser.default()
        // 创建数据访问对象
        val dao = UserDAO()
        // 所有已经登录的客户端信息
        val clientList = mutableListOf<ClientInfo>()
    
        // 创建DatagramSocket对象，监听自己的端口7788
        DatagramSocket(SERVER_PORT).use {
         socket ->
    
            //主协程循环
            while (true) {
        
    
                // 准备一个缓冲区
                var buffer = ByteArray(1024)
                // 创建数据报包对象，用来接收数据
                var packet = DatagramPacket(buffer, buffer.size)
                // 接收数据报包
                socket.receive(packet)
                // 接收的字符串
                val jsonString = String(buffer, 0, packet.length)
                // 从客户端传来的数据包中得到客户端地址
                val address = packet.address
                // 从客户端传来的数据包中得到客户端端口号
                val port = packet.port
                println("服务器接收客户端，消息：$jsonString")
    
                var jsonObject = parser.parse(StringBuilder(jsonString)) as JsonObject
                //取出客户端传递过来的操作命令
                val cmd = jsonObject.int("command")
    
                when (cmd) {
        
                    COMMAND_LOGIN -> {
        // 用户登录过程
    
                        val userId = jsonObject["user_id"] as String
                        val userPwd = jsonObject["user_pwd"] as String
                        // 通过用户Id查询用户信息
                        val user = dao.findById(userId)
    
                        // 判断客户端发送过来的密码与数据库的密码是否一致
                        if (user != null && userPwd == user["user_pwd"]) {
        
                            // 通过user对象创建JsonObject对象，其中user是Map类型
                            val sendJsonObj = JsonObject(user)
                            // 添加返回结果信息 result:0键值对，"0"表示成功，"-1"表示失败
                            sendJsonObj["result"] = "0"
    
                            // 创建客户端信息对象cInfo保存客户端的用户Id和地址
                            val cInfo = ClientInfo(port, address, userId)
    
                            // 如果客户端端列表clientList中没有该客户端信息，则添加该客户端数据
                            if (clientList.none {
         it.userId == userId }) {
        
                                clientList.add(cInfo)
                            }
    
                            // 根据客用户Id查询他的好友列表
                            val friends = dao.findFriends(userId)!!.map {
        
                                // 将好友转换为可变Map对象
                                val friend = it.toMutableMap()
                                // 取出好友的用户Id
                                val fid = it["user_id"]
                                // 添加好友状态 "1"在线 "0"离线
                                if (clientList.any {
         it.userId == fid })
                                // 好友在clientList集合中存在时说明好友【在线】，否【离线】
                                    friend["online"] = "1" else friend["online"] = "0"
                                //返回数据
                                friend
                            }.map {
        
                                JsonObject(it)
                            }
    
                            sendJsonObj["friends"] = json {
        
                                array(friends)
                            }
                            println("服务器发送用户成功，消息：${
          sendJsonObj.toJsonString()}")
                            // 创建DatagramPacket对象，用于向客户端发送数据
                            buffer = sendJsonObj.toJsonString().toByteArray()
                            packet = DatagramPacket(buffer, buffer.size, address, port)
                            socket.send(packet)
                        } else {
        
                            // 发送失败消息
                            val jsonObj = json {
        
                                obj("result" to "-1")
                            }
                            println("服务器给用户登录失败，消息：${
          jsonObj.toJsonString()}")
                            buffer = jsonObj.toJsonString().toByteArray()
                            packet = DatagramPacket(buffer, buffer.size, address, port)
                            // 向请求登录的客户端发送数据
                            socket.send(packet)
                        }
                    }
    
                    COMMAND_SENDMSG -> {
        // 用户发送消息
                        // 获得好友Id
                        val friendUserId = jsonObject["receive_user_id"] as String
                        // 向客户端发送数据
                        clientList.filter {
        
                            // 找到好友过滤条件
                            it.userId == friendUserId
                        }.forEach {
        
                            println("服务器转发聊天，消息：${
          jsonObject.toJsonString()}")
                            // 创建DatagramPacket对象，用于向客户端发送数据
                            buffer = jsonObject.toJsonString().toByteArray()
                            packet = DatagramPacket(buffer, buffer.size, it.address, it.port)
                            // 发送消息给好友
                            socket.send(packet)
                        }
                    }
    
                    COMMAND_LOGOUT -> {
        // 用户发送下线命令
                        // 获得用户Id
                        val userId = jsonObject["user_id"] as String
                        val clientInfo = clientList.first {
        
                            it.userId == userId
                        }
                        // 从clientList集合中删除用户
                        clientList.remove(clientInfo)
                    }
                }
    
                ///刷新用户列表
                //如果clientList中没有元素时跳到下次循环
                if (clientList.isEmpty()) continue
    
                val jsonObj = JsonObject()
                jsonObj["command"] = COMMAND_REFRESH
    
                val userIdList = clientList.map {
        
                    it.userId
                }
                jsonObj["OnlineUserList"] = json {
        
                    array(userIdList)
                }
                println("服务器向客户端发送消息，刷新用户列表：${
          jsonObj.toJsonString()}")
                // 向客户端发送数据刷新用户列表
                clientList.forEach {
        
                    buffer = jsonObj.toJsonString().toByteArray()
                    packet = DatagramPacket(buffer, buffer.size, it.address, it.port)
                    socket.send(packet)
                }
            }
        }
    }

###### 26.8.3 迭代7.3：客户端用户3接收用户1消息 ######

客户端用户3接收用户1消息是在聊天窗口类ChatFramet中的，接收消息子协程体中完成，这个接收消息代码与ChatFrame中刷新好友列表代码共用一个协程。

ChatFrame.kt相关代码如下：

ChatFrame.kt

[4ede5c5878794212a8743397fdabb857.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/0360bc021bf94332b8f07880ff3195f5.png
[549ffefcea894649b2bd3f88da121ba3.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/1c63c98b393c429f872f11b7afc9b595.png