【2023】Kotlin教程第四篇项目实战第26章项目实战2：开发Kotlin版QQ聊天工具 26.9 任务8：用户下线

淡淡的烟草味﹌ 2024-03-23 16:04 21阅读 0赞

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

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

*   *  【2023】Kotlin教程
     *   *  第四篇 项目实战
         *  第26章 项目实战2：开发Kotlin版QQ聊天工具
         *   *  26.9 任务8：用户下线
             *   *  26.9.1 迭代8.1：客户端编程
                 *  26.9.2 迭代8.2：服务器端编程

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

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

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

##### 26.9 任务8：用户下线 #####

一个用户单击关闭好友列表窗口，就会下线，在服务器端下线用户登录信息，但不会马上通知其他客户端，而是等到下一次刷新好友列表时，看到该用户已经下线消息。这个过程如下图所示：

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

*  第①步。用户1下线。
 *  第②步。服务器端下线用户。

###### 26.9.1 迭代8.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) {
        
                    //捕获超时异常，继续
                }
            }
        }
    
    }

###### 26.9.2 迭代8.2：服务器端编程 ######

服务器端接收用户下线消息，将该用户下线，就是将用户从clientList集合中删除。

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)
                }
            }
        }
    }

[a3321c1ec8454a4bb735c161036454fe.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/47783b97c65b458db5e5cdba19ca483e.png
[1a89ef896d81492c8ea20c3fd1649134.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/1b4d98c5d2124d5297f53f49eec10590.png