• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号
登陆 注册

Swift-使用socket进行通信（附聊天室样例）

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

在Swift开发中，如果我们需要保持客服端和服务器的长连接进行双向的数据通信，使用socket是一种很好的解决方案。

下面通过一个聊天室的样例来演示socket通信，这里我们使用了一个封装好的socket库（SwiftSocket）。

功能如下：
1，程序包含服务端和客服端，这里为便于调试把服务端和客服端都做到一个应用中
2，程序启动时，自动初始化启动服务端，并在后台开启一个线程等待客服端连接
3，同时，客户端初始化完毕后会与服务端进行连接，同时也在后台开启一个线程等待接收服务端发送的消息
4，连接成功后，自动生成一个随机的用户名（如“游客232”）并发送消息告诉服务器这个用户信息
5，点击界面的“发送消息”按钮，则会发送聊天消息到服务端，服务端收到后会把聊天消息发给所有的客服端。客服端收到后显示在对话列表中

注意：消息传递过程使用的json格式数据。
目前这个demo里消息种类有用户登录消息，聊天消息，后面还可以加上用户退出消息等。为了在接收到消息以后，能判断是要执行什么命令。我们创 建消息体的时候使用字典NSDictionary(其中cmd表示命令类型，content表示内容体)，发送消息时把字典转成json串传递，当另一端 接收的时候，又把json串还原成字典再执行响应的动作。

效果图如下：
   

代码如下：
--- ViewController.swift 主页面 ---
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
import UIKit
 
class ViewController: UIViewController {
     
    //消息输入框
    @IBOutlet weak var textFiled: UITextField!
    //消息输出列表
    @IBOutlet weak var textView: UITextView!
     
    //socket服务端封装类对象
    var socketServer:MyTcpSocketServer?
    //socket客户端类对象
    var socketClient:TCPClient?
     
    override func viewDidLoad() {
        super.viewDidLoad()
         
        //启动服务器
        socketServer = MyTcpSocketServer()
        socketServer?.start()
         
        //初始化客户端，并连接服务器
        processClientSocket()
    }
     
    //初始化客户端，并连接服务器
    func processClientSocket(){
        socketClient=TCPClient(addr: "localhost", port: 8080)
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), {
            () -> Void in
             
            //用于读取并解析服务端发来的消息
            func readmsg()->NSDictionary?{
                //read 4 byte int as type
                if let data=self.socketClient!.read(4){
                    if data.count==4{
                        var ndata=NSData(bytes: data, length: data.count)
                        var len:Int32=0
                        ndata.getBytes(&len, length: data.count)
                        if let buff=self.socketClient!.read(Int(len)){
                            var msgd:NSData=NSData(bytes: buff, length: buff.count)
                            var msgi:NSDictionary=NSJSONSerialization.JSONObjectWithData(
                                msgd,
                                options: .MutableContainers, error: nil) as! NSDictionary
                            return msgi
                        }
                    }
                }
                return nil
            }
             
            //连接服务器
            var (success,msg)=self.socketClient!.connect(timeout: 5)
            if success{
                dispatch_async(dispatch_get_main_queue(), {
                    self.alert("connect success", after: {
                    })
                })
                 
                //发送用户名给服务器（这里使用随机生成的）
                var msgtosend=["cmd":"nickname","nickname":"游客\(Int(arc4random()%1000))"]
                self.sendMessage(msgtosend)
                 
                //不断接收服务器发来的消息
                while true{
                    if let msg=readmsg(){
                        dispatch_async(dispatch_get_main_queue(), {
                            self.processMessage(msg)
                        })
                    }else{
                        dispatch_async(dispatch_get_main_queue(), {
                            //self.disconnect()
                        })
                        break
                    }
                }
            }else{
                dispatch_async(dispatch_get_main_queue(), {
                    self.alert(msg,after: {
                    })
                })
            }
        })
    }
     
    //“发送消息”按钮点击
    @IBAction func sendMsg(sender: AnyObject) {
        var content=textFiled.text
        var message=["cmd":"msg","content":content]
        self.sendMessage(message)
        textFiled.text=nil
    }
     
    //发送消息
    func sendMessage(msgtosend:NSDictionary){
        var msgdata=NSJSONSerialization.dataWithJSONObject(msgtosend,
            options: NSJSONWritingOptions.PrettyPrinted, error: nil)
        var len:Int32=Int32(msgdata!.length)
        var data:NSMutableData=NSMutableData(bytes: &len, length: 4)
        self.socketClient!.send(data: data)
        self.socketClient!.send(data:msgdata!)
    }
     
    //处理服务器返回的消息
    func processMessage(msg:NSDictionary){
        var cmd:String=msg["cmd"] as! String
        switch(cmd){
        case "msg":
            self.textView.text = self.textView.text +
                (msg["from"] as! String) + ": " + (msg["content"] as! String) + "\n"
        default:
            println(msg)
        }
    }
     
    //弹出消息框
    func alert(msg:String,after:()->(Void)){
        var alertview=UIAlertView(title: "", message: msg, delegate: nil,
            cancelButtonTitle: nil)
        alertview.show()
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 3), dispatch_get_main_queue(),{
            alertview.dismissWithClickedButtonIndex(0, animated: true)
            after()
        })
    }
     
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
    }
}

 

--- MyTcpSocketServer.swift 服务端 ---
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
import UIKit
 
//服务器端口
var serverport = 8080
 
//客户端管理类（便于服务端管理所有连接的客户端）
class ChatUser:NSObject{
    var tcpClient:TCPClient?
    var username:String=""
    var socketServer:MyTcpSocketServer?
     
    //解析收到的消息
    func readMsg()->NSDictionary?{
        //read 4 byte int as type
        if let data=self.tcpClient!.read(4){
            if data.count==4{
                var ndata=NSData(bytes: data, length: data.count)
                var len:Int32=0
                ndata.getBytes(&len, length: data.count)
                if let buff=self.tcpClient!.read(Int(len)){
                    var msgd:NSData=NSData(bytes: buff, length: buff.count)
                    var msgi:NSDictionary=NSJSONSerialization.JSONObjectWithData(msgd,
                        options: .MutableContainers, error: nil) as! NSDictionary
                    return msgi
                }
            }
        }
        return nil
    }
     
    //循环接收消息
    func messageloop(){
        while true{
            if let msg=self.readMsg(){
                self.processMsg(msg)
            }else{
                self.removeme()
                break
            }
        }
    }
     
    //处理收到的消息
    func processMsg(msg:NSDictionary){
        if msg["cmd"] as! String=="nickname"{
            self.username=msg["nickname"] as! String
        }
        self.socketServer!.processUserMsg(user: self, msg: msg)
    }
     
    //发送消息
    func sendMsg(msg:NSDictionary){
        var jsondata=NSJSONSerialization.dataWithJSONObject(msg, options:
            NSJSONWritingOptions.PrettyPrinted, error: nil)
        var len:Int32=Int32(jsondata!.length)
        var data:NSMutableData=NSMutableData(bytes: &len, length: 4)
        self.tcpClient!.send(data: data)
        self.tcpClient!.send(data: jsondata!)
    }
     
    //移除该客户端
    func removeme(){
        self.socketServer!.removeUser(self)
    }
     
    //关闭连接
    func kill(){
        self.tcpClient!.close()
    }
}
 
//服务端类
class MyTcpSocketServer: NSObject {
    var clients:[ChatUser]=[]
    var server:TCPServer=TCPServer(addr: "127.0.0.1", port: serverport)
    var serverRuning:Bool=false
     
    //启动服务
    func start() {
        server.listen()
        self.serverRuning=true
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), {
            while self.serverRuning{
                var client=self.server.accept()
                if let c=client{
                    dispatch_async(
                        dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), {
                        self.handleClient(c)
                    })
                }
            }
        })
        self.log("server started...")
    }
     
    //停止服务
    func stop() {
        self.serverRuning=false
        self.server.close()
        //forth close all client socket
        for c:ChatUser in self.clients{
            c.kill()
        }
        self.log("server stoped...")
    }
 
    //处理连接的客户端
    func handleClient(c:TCPClient){

鲜花
握手
雷人
路过
鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
More+
上一篇：
swift-UITextField的用法发布时间：2022-07-18
下一篇：
Swift-使用atlas图集实现动画效果（SpriteKit游戏开发）发布时间：2022-07-18
热门推荐
More+
热门话题
More+
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服（服务时间 9:00～18:00）

在线QQ客服
地址：深圳市南山区西丽大学城创智工业园
电邮：jeky_zhao#qq.com
移动电话：139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap