【2023】Kotlin教程第四篇项目实战第26章项目实战2：开发Kotlin版QQ聊天工具 26.7 任务6：刷新好友列表

Love The Way You Lie 2024-03-23 16:04 49阅读 0赞

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

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

*   *  【2023】Kotlin教程
     *   *  第四篇 项目实战
         *  第26章 项目实战2：开发Kotlin版QQ聊天工具
         *   *  26.7 任务6：刷新好友列表
             *   *  26.7.1 迭代6.1：刷新好友列表服务器端编程
                 *  26.7.2 迭代6.2：刷新好友列表客户端编程

![在这里插入图片描述][64d998de504f4428866f5a0df7aab6c4.png_pic_center]

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

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

##### 26.7 任务6：刷新好友列表 #####

用户好友列表状态是不断变化的，服务器端会定期发送在线的用户列表，以便于客户端刷新自己的好友列表。这个过程如下图所示，操作步聚如下：

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

第①步。服务器端定期发送在线用户列表给所有在线的客户端。

第② 步。客户端刷新好友列表。

###### 26.7.1 迭代6.1：刷新好友列表服务器端编程 ######

服务器端定期发送在线用户列表给所有在线的客户端，Server.kt代码如下：

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.7.2 迭代6.2：刷新好友列表客户端编程 ######

客户端在好友列表窗口和聊天窗口时都可以刷新好友列表，那么需要在FriendsFrame和ChatFrame中添加接收服务器信息，并刷新好友列表的代码。为了不阻塞主协程(UI协程)，这些处理应该放到子协程中。

【1】FriendsFrame.kt相关代码如下：

package com.dingjiaxiong.client
    
    import com.beust.klaxon.JsonObject
    import com.beust.klaxon.json
    import kotlinx.coroutines.*
    import java.awt.BorderLayout
    import java.awt.Color
    import java.awt.GridLayout
    import java.awt.Toolkit
    import java.awt.event.MouseAdapter
    import java.awt.event.MouseEvent
    import java.awt.event.WindowAdapter
    import java.awt.event.WindowEvent
    import java.net.DatagramPacket
    import java.net.InetAddress
    import javax.swing.*
    
    /**
     * @Projectname: QQ
     * @Classname: FriendsFrame
     * @Author: Ding Jiaxiong
     * @Data:2023/4/7 14:50
     */
    
    class FriendsFrame(private val user: Map<String, Any>) : JFrame() {
        
    
        // 好友列表
        private val friends: List<Map<String, String>>
    
        // 好友标签控件列表
        private val lblFriendList = mutableListOf<JLabel>()
    
        // 获得当前屏幕的宽
        private val screenWidth = Toolkit.getDefaultToolkit().screenSize.getWidth()
    
        // 登录窗口宽和高
        private val frameWidth = 260
        private val frameHeight = 600
    
        //声明一个协程引用
        private var job: Job? = null
    
        // 协程运行状态
        private var isRunning = true
    
        init {
        
            /// 初始化当前Frame
            title = "QQ2006"
            setBounds(screenWidth.toInt() - 300, 10, frameWidth, frameHeight)
    
            iconImage = Toolkit.getDefaultToolkit().getImage(("images/QQ.png"))
    
            // 设置布局
            val borderLayout = contentPane.layout as BorderLayout
            borderLayout.vgap = 5
    
            /// 初始化用户列表
            friends = user["friends"] as List<Map<String, String>>
            val userId = user["user_id"] as String
            val userName = user["user_name"] as String
            val userIcon = user["user_icon"] as String
    
            with(JLabel(userName)) {
        
                horizontalAlignment = SwingConstants.CENTER
                val iconFile = "images/$userIcon.jpg"
                icon = ImageIcon(iconFile)
                contentPane.add(this, BorderLayout.NORTH)
            }
    
            val panel1 = JPanel()
            panel1.layout = BorderLayout(0, 0)
    
            with(JScrollPane()) {
        
                border = BorderFactory.createLineBorder(Color.blue, 1)
                setViewportView(panel1)
                contentPane.add(this, BorderLayout.CENTER)
            }
    
            with(JLabel("我的好友")) {
        
                horizontalAlignment = SwingConstants.CENTER
                panel1.add(this, BorderLayout.NORTH)
            }
    
            // 好友列表面板
            val friendListPanel = JPanel()
            friendListPanel.layout = GridLayout(50, 0, 0, 5)
            panel1.add(friendListPanel)
    
            // 初始化好友列表
            friends.forEach {
         friend ->
    
                val friendUserId = friend["user_id"]
                val friendUserName = friend["user_name"]
                val friendUserIcon = friend["user_icon"]
                // 获得好友在线状态
                val friendUserOnline = friend["online"]
    
                val lblFriend = JLabel(friendUserName).apply {
        
    
                    toolTipText = friendUserId
                    val friendIconFile = "images/$friendUserIcon.jpg"
                    icon = ImageIcon(friendIconFile)
                    // 在线设置可用，离线设置不可用
                    isEnabled = friendUserOnline != "0"
    
                    // 添加到列表集合
                    lblFriendList.add(this)
                    // 添加到面板
                    friendListPanel.add(this)
                }
    
                lblFriend.addMouseListener(object : MouseAdapter() {
        
                    override fun mouseClicked(e: MouseEvent) {
        
                        // 用户图标双击鼠标时显示对话框
                        if (e.clickCount == 2) {
        
                            stopCoroutine()
                            ChatFrame(this@FriendsFrame, user, friend).isVisible = true
                        }
                    }
                })
            }
    
            // 注册窗口事件
            addWindowListener(object : WindowAdapter() {
        
                // 单击窗口关闭按钮时调用
                override fun windowClosing(e: WindowEvent) {
        
                    // 当前用户下线
                    val jsonObj = json {
        
                        obj("command" to COMMAND_LOGOUT, "user_id" to userId)
                    }
    
                    val b = jsonObj.toJsonString().toByteArray()
                    val address = InetAddress.getByName(SERVER_IP)
                    // 创建DatagramPacket对象
                    val packet = DatagramPacket(b, b.size, address, SERVER_PORT)
                    // 发送
                    socket.send(packet)
                    // 关闭Socket
                    socket.close()
                    // 退出系统
                    System.exit(0)
                }
            })
            println("启动接收消息子协程")
            resetCoroutine()
        }
    
        // 刷新好友列表
        fun refreshFriendList(userIdList: List<String>) {
        
            // 初始化好友列表
            lblFriendList.forEach {
        
                val friendId = it.toolTipText!!
                //在线用户列表userIdList中存在friendId
                it.isEnabled = userIdList.contains(friendId)
            }
        }
    
        // 重新启动接收消息子协程
        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")
    
                    if (cmd != null && cmd == COMMAND_REFRESH) {
        
                        val userIdList = jsonObj["OnlineUserList"] as List<String>
                        // 刷新好友列表
                        refreshFriendList(userIdList)
                    }
                    delay(100L)
                } catch (e: Exception) {
        
                    //捕获超时异常，继续
                }
            }
        }
    
    }

![在这里插入图片描述][697aff4162e64523a244a5b21d2b78ed.png_pic_center]

【提示】如果不使用cancelAndJoin函数而使用cancel函数，虽然也可以取消协程，但不能阻塞主协程，这样在子协程还没有停止的情况下进入到了下一个窗口。在下一个窗口中还会启动一个新的接收消息的协程，这会导致客户端有些消息无法正常接收。

【2】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) {
        
                    //捕获超时异常，继续
                }
            }
        }
    }

![在这里插入图片描述][3cd83e0f31bc4fd6adb6b29456df1ee4.png_pic_center]

[64d998de504f4428866f5a0df7aab6c4.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/8669536a8d054a8aba99f08c9fbed491.png
[cddc68039a6e4b518b550ffc4aec2287.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/0d2ba63bbcce42f199ee57afaf30c524.png
[697aff4162e64523a244a5b21d2b78ed.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/ae4a71f755e74c2582e354843aaf3d7a.png
[3cd83e0f31bc4fd6adb6b29456df1ee4.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/46dd1849c08744689943d0b3d8bfe9e4.png