【2023】Kotlin教程第四篇项目实战第26章项目实战2：开发Kotlin版QQ聊天工具 26.6 任务5：用户登录过程实现

忘是亡心i 2024-03-23 16:04 32阅读 0赞

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

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

*   *  【2023】Kotlin教程
     *   *  第四篇 项目实战
         *  第26章 项目实战2：开发Kotlin版QQ聊天工具
         *   *  26.6 任务5：用户登录过程实现
             *   *  26.6.1 迭代5.1：客户端启动
                 *  26.6.2 迭代5.2：客户端登录编程
                 *  26.6.3 迭代5.3：服务器启动

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

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

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

##### 26.6 任务5：用户登录过程实现 #####

用户登录时客户端和服务器互相交互，客户端和服务器端代码比较复杂，涉及到多协程编程。用户登录过程如下图所示，

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

当用户1打开登录对话框，输入QQ号码和QQ密码，单击登录按钮，用户登录过程开始：

*  第①步。用户1登录。客户端将QQ号码和QQ密码数据封装发给服务器。
 *  第②步。服务器接收用户1请求，验证用户1的QQ号码和QQ密码，是否与数据库的QQ号码和QQ密码一致。
 *  第③步。返回给用户1登录结果。服务器端将登录结果发给客户端。客户端接收服务器端返回的消息，登录成功进入用户好友列表，不成功给用户提示。

###### 26.6.1 迭代5.1：客户端启动 ######

在介绍客户端登录编程之前，首先介绍客户端启动程序Client.kt代码如下：

package com.dingjiaxiong.client
    
    import java.net.DatagramSocket
    import com.beust.klaxon.Parser
    
    /**
     * @Projectname: QQ
     * @Classname: Client
     * @Author: Ding Jiaxiong
     * @Data:2023/4/7 14:57
     */
    
    // 操作命令代码
    const val COMMAND_LOGIN = 1 // 登录命令
    const val COMMAND_LOGOUT = 2 // 下线命令
    const val COMMAND_SENDMSG = 3 // 发消息命令
    const val COMMAND_REFRESH = 4 // 刷新好友列表命令
    
    // 服务器端IP
    const val SERVER_IP = "127.0.0.1"
    
    // 服务器端端口号
    const val SERVER_PORT = 7788
    
    var socket = DatagramSocket()
    
    //JSON解析器
    val parser = Parser.default()
    
    fun main() {
        
        // 设置超时2秒，不再等待接收数据
        socket.soTimeout = 2000
        println("客户端运行...")
        LoginFrame().isVisible = true
    }

【注意】socket对象一直没有关闭，这是因为socket对象的生命周期是整个Client应用程序。在这些Client应用程序中有很多协程，一直是使用socket对象发送和接收数据，因比不能关闭socket)对象。只有Client应用程序停止socket对象才关闭。

###### 26.6.2 迭代5.2：客户端登录编程 ######

客户端登录编程需要在LoginFrame中编写代码，LoginFrame代码如下：

package com.dingjiaxiong.client
    
    import com.beust.klaxon.JsonObject
    import com.beust.klaxon.json
    import java.awt.Color
    import java.awt.Font
    import java.awt.Toolkit
    import java.awt.event.WindowAdapter
    import java.awt.event.WindowEvent
    import java.net.DatagramPacket
    import java.net.InetAddress
    import javax.swing.*
    
    /**
     * @Projectname: QQ
     * @Classname: LoginFrame
     * @Author: Ding Jiaxiong
     * @Data:2023/4/7 14:47
     */
    
    class LoginFrame : JFrame() {
        
    
        // 获得当前屏幕的宽和高
        private val screenWidth = Toolkit.getDefaultToolkit().screenSize.getWidth()
        private val screenHeight = Toolkit.getDefaultToolkit().screenSize.getHeight()
    
        // 登录窗口宽和高
        private val frameWidth = 329
        private val frameHeight = 250
    
        // QQ号码文本框
        private var txtUserId = JTextField()
    
        // QQ密码框
        private var txtUserPwd = JPasswordField()
    
        // 蓝线面板
        private val paneLine: JPanel
            get() {
        
    
                val paneLine = JPanel().apply {
        
                    layout = null
                    setBounds(7, 54, 308, 118)
                    border = BorderFactory.createLineBorder(Color(102, 153, 255), 1)
                }
    
                with(JLabel()) {
        
                    //lblHelp
                    setBounds(227, 47, 67, 21)
                    font = Font("Dialog", Font.PLAIN, 12)
                    foreground = Color(51, 51, 255)
                    text = "忘记密码？"
                    paneLine.add(this)
                }
                with(JLabel()) {
        
                    //lblUserPwd
                    text = "QQ密码"
                    font = Font("Dialog", Font.PLAIN, 12)
                    setBounds(21, 48, 54, 18)
                    paneLine.add(this)
                }
    
                with(JLabel()) {
        
                    //lblUserId
                    text = "QQ号码↓"
                    font = Font("Dialog", Font.PLAIN, 12)
                    setBounds(21, 14, 55, 18)
                    paneLine.add(this)
                }
    
                txtUserId.setBounds(84, 14, 132, 18)
                paneLine.add(this.txtUserId)
    
                txtUserPwd.setBounds(84, 48, 132, 18)
                paneLine.add(this.txtUserPwd)
    
                with(JCheckBox()) {
        
                    //chbAutoLogin
                    text = "自动登录"
                    font = Font("Dialog", Font.PLAIN, 12)
                    setBounds(79, 77, 73, 19)
                    paneLine.add(this)
                }
                with(JCheckBox()) {
        
                    //chbHideLogin
                    text = "隐身登录"
                    font = Font("Dialog", Font.PLAIN, 12)
                    setBounds(155, 77, 73, 19)
                    paneLine.add(this)
                }
                return paneLine
            }
    
        init {
        
    
            /// 初始化当前窗口
            iconImage = Toolkit.getDefaultToolkit().getImage("images/QQ.png")
            title = "QQ登录"
            isResizable = false
            layout = null
            // 设置窗口大小
            setSize(frameWidth, frameHeight)
            // 计算窗口位于屏幕中心的坐标
            val x = (screenWidth - frameWidth).toInt() / 2
            val y = (screenHeight - frameHeight).toInt() / 2
            // 设置窗口位于屏幕中心
            setLocation(x, y)
    
            // 添加蓝线面板
            contentPane.add(paneLine)
    
            with(JLabel()) {
        
                icon = ImageIcon("images/QQll.JPG")
                setBounds(0, 0, 325, 48)
                contentPane.add(this)
            }
    
            // 初始化登录按钮
            val btnLogin = JButton().apply {
        
                setBounds(152, 181, 63, 19)
                font = Font("Dialog", Font.PLAIN, 12)
                text = "登录"
                contentPane.add(this)
            }
            // 注册登录按钮事件监听器
            btnLogin.addActionListener {
        
                // 先进行用户输入验证，验证通过再登录
                val userId = txtUserId.text
                val password = String(txtUserPwd.password)
    
                val user = login(userId, password)
                if (user != null) {
        
                    // 登录成功调转界面
                    println("登录成功调转界面")
                    FriendsFrame(user).isVisible = true
                    // 设置登录窗口可见
                    isVisible = false
                } else {
        
                    JOptionPane.showMessageDialog(null, "您QQ号码或密码不正确")
                }
            }
    
            // 初始化取消按钮
            val btnCancel = JButton().apply {
        
                setBounds(233, 181, 63, 19)
                font = Font("Dialog", Font.PLAIN, 12)
                text = "取消"
                contentPane.add(this)
            }
            // 注册取消按钮事件监听器
            btnCancel.addActionListener {
        
                // 关闭Socket
                socket.close()
                // 退出系统
                System.exit(0)
            }
    
            // 初始化【申请号码↓】按钮
            with(JButton()) {
        
                setBounds(14, 179, 99, 22)
                font = Font("Dialog", Font.PLAIN, 12)
                text = "申请号码↓"
                contentPane.add(this)
            }
    
            // 注册窗口事件
            addWindowListener(object : WindowAdapter() {
        
                // 单击窗口关闭按钮时调用
                override fun windowClosing(e: WindowEvent) {
        
                    // 关闭Socket
                    socket.close()
                    // 退出系统
                    System.exit(0)
                }
            })
        }
    
        // 客户端向服务器发送登录请求
        private fun login(userId: String, password: String): Map<String, Any>? {
        
    
            val address = InetAddress.getByName(SERVER_IP)
    
            var jsonObj = json {
        
                obj(
                    "command" to COMMAND_LOGIN,
                    "user_id" to userId,
                    "user_pwd" to password
                )
            }
            // 字节数组
            var buffer = jsonObj.toJsonString().toByteArray()
            // 创建DatagramPacket对象
            var packet = DatagramPacket(buffer, buffer.size, address, SERVER_PORT)
            // 发送数据
            socket.send(packet)
    
            // 接收数据
            // 准备一个缓冲区
            buffer = ByteArray(1024)
            packet = DatagramPacket(buffer, buffer.size, address, SERVER_PORT)
            socket.receive(packet)
    
            val jsonString = String(buffer, 0, packet.length)
            println("从服务器返回的消息：$jsonString")
            jsonObj = parser.parse(StringBuilder(jsonString)) as JsonObject
    
            //登录失败
            if (jsonObj.string("result") == "-1") return null
    
            return jsonObj as Map<String, Any>?
        }
    }

###### 26.6.3 迭代5.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)
                }
            }
        }
    }

[65616723d29f475f8153d01db80cfd46.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/cc9af40610664570b7617993a541d635.png
[23348d19907849eab420d088712687a6.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/015b8d39c3cd4202a6a1090e4765aeb7.png