ProtocolBuffer的基本环境搭建：ProtocolBuffer-Swift使用
TCP：传输控制协议 。是专门设计用于在不可靠的因特网上提供可靠的，端到端的字节流通信的协议。它是一种面向连接的协议。TCP连接是字节流而非报文流。
TCP连接流程图：
TCP连接过程图.png
UDP：用户数据报协议 。不需要建立连接，不可靠。
UDP连接流程图：
UDP连接过程图.png
iOS中Socket编程
BSD Socket
BSD Socket 是UNIX系统中通用的网络接口，它不仅支持各种不同的网络类型，而且也是一种内部进程之间的通信机制。在我们iOS中也可以使用，但是它所有的函数都是基于C语言的，所有在实际的项目开发中，我们都是使用封装好的。
CFSocket
CFSocket是苹果官方提供给我们进行Socket编程，里面还是有很多C语言的东西，使用起来稍微麻烦一点。
AsyncSocket
AsyncSocket是一个开源的库，用来进行iOS的Socket编程就非常方便, 但是目前只有OC版本, 并且长时间没有更新
ysocket
目前使用Swift进行Socket编程时,常用的一个库
消息传输
TCP在传输数据时,传输的是字节流在读取消息时,需要知道数据的长度, 否则就会出现读取不完整或者读取长度过多的情况, 因此读取方法要求我们传入本次读取的消息长度如何解决该问题呢?
方案一: 客户端发送两次消息消息一是记录后续消息长度, 消息二是真正的消息
消息1.png
方案二: 客户端发送一次消息消息有一个Header,用于记录消息的长度, 后续为真实消息内容
消息2.png
消息类型
开发中经常遇到类似这样的场景:我们的客户端是使用Swift/OC/Java来写的, 可以运行在不同的平台, iOS/Android/Window/Linux.服务器基于Linux平台并使用C++开发完成的, 两种程序之间采用什么进行通信呢?
直接传递C/C++语言中一字节对齐的结构体数据，只要结构体的声明为定长格式，那么该方式对于C/C++程序而言就非常方便了, 但是对于java这种不常用结构体的语言, 处理起来就相当麻烦
使用
SOAP协议(WebService)作为消息报文的格式载体，由该方式生成的报文是基于文本格式的，同时还存在大量的XML描述信息，因此将会大大增加网络IO的负担。又由于XML解析的复杂性，这也会大幅降低报文解析的性能。总之，使用该设计方式将会使系统的整体运行性能明显下降。Json交换格式, 目前比较理想的一种通信格式, 也是在Http请求数据时, 最常见的用法(Demo程序)
ProtocolBuffer(也称PB/GPB): google 的一种数据交换的格式, 可以实现跨平台, 方便的序列化&反序列化, 并且数据量相对Json小很多
Json/GPB对比优缺点对比
- 跨平台ProtoBuf支持多平台和语言, 包括C++/Java/Python等等
- 序列化&反序列号ProtoBuf支持直接将对象序列化成Data, 也支持直接将Data序列化为对象类型
- 消息大小一条消息数据，用protobuf序列化后的大小是json的10分之一，xml格式的20分之一，是二进制序列化的10分之一对于即时通信消息来说, 减小数据量的大小非常有必须
基本代码：
Server服务器基本代码配置
import Cocoa
class ServerManager: NSObject {
fileprivate lazy var serverSocket : TCPServer = TCPServer(addr: "0.0.0.0", port: 8888)
fileprivate lazy var Managers : [ClientManager] = [ClientManager]()
fileprivate lazy var isRuning : Bool = false
}
extension ServerManager {
func startRuning() {
// 1.开始监听
serverSocket.listen()
isRuning = true
// 2.开始接收
DispatchQueue.global().async {
while self.isRuning {
if let client = self.serverSocket.accept() {
DispatchQueue.global().async {
self.handlerClient(client)
}
}
}
}
}
func stopRuning() {
isRuning = false
}
}
依据流程图中第一步serverSocket.listen()开始监听客户端是否链接到服务器,监听到客户端链接查看服务器是否能接收到信息let client = self.serverSocket.accept()，在这个过程中是一直阻塞的状态直到客户端链接，所以最好是DispatchQueue.global().async异步执行操作
extension ServerManager {
//处理client操作
fileprivate func handlerClient(_ client : TCPClient){
// 1.用一个ClientManager管理TCPClient
let Manager = ClientManager(tcpClient: client)
Manager.delegate = self
// 2.保存客户端manger
Managers.append(Manager)
// 3.读取/接收消息
Manager.startReadMessages()
}
}
//ClientManagerDelegate
extension ServerManager : ClientManagerDelegate {
func SendMessageToClient(_ data: Data) {
// 将消息转发给其他的客户端
for msg in Managers {
msg.clientManger.send(data:data)
}
}
}
服务器中ClientManager
import Cocoa
protocol ClientManagerDelegate : class {
func SendMessageToClient(_ data : Data)
}
class ClientManager: NSObject {
var clientManger : TCPClient
weak var delegate : ClientManagerDelegate?
fileprivate var isReadMessge : Bool = false
init(tcpClient : TCPClient) {
self.clientManger = tcpClient
}
}
extension ClientManager {
func startReadMessages() {
isReadMessge = true
while isReadMessge {
if let message = clientManger.read(4){
// 1.读取消息长度
let HeadMsgData = Data(bytes: message, count: 4)
var lenght : Int = 0
(HeadMsgData as NSData).getBytes(&lenght, length: 4)
// 2. 读取消息类型
var type : Int = 0
guard let typeMsg = clientManger.read(2) else { return }
let typeData = Data(bytes: typeMsg, count: 2)
var typelenght : Int = 0
(typeData as NSData).getBytes(&typelenght, length: 2)
// 3. 根据长度 读取真实消息
guard let Msg = clientManger.read(lenght) else {
return
}
let MsgData = Data(bytes: Msg, count: lenght)
/*
switch type {
case 0, 1:
let user = try! UserInfo.parseFrom(data: MsgData)
print(user.name)
print(user.level)
default:
print("未知类型")
}
*/
// let Msgstring = String(data: MsgData, encoding: .utf8)
// print(Msgstring ?? "123")
// 消息长度
let total = HeadMsgData + typeData + MsgData
delegate?.SendMessageToClient(total)
print(total )
}else {
isReadMessge = false
print("断开了链接")
}
}
}
}
Client客户端配置
extension HJSocket {
//是否链接到服务器
func connectServer() -> Bool {
return clientSocket.connect(timeout: 5).0
}
}
检查Client能不能链接到服务器clientSocket.connect(timeout: 5).0并且设置链接时长为5秒
func sendMsg(MsgData : Data) {
// 如果不需要返回值 则可以在方法中加入 @discardableResult 可遗弃的结果
clientSocket.send(data: MsgData)
}
Client能链接到Server的时候 ，发送信息给Server
func startReadMessages() {
DispatchQueue.global().async {
while true {
guard let message = self.clientSocket.read(4) else {
continue
}
// 1.读取消息长度
let HeadMsgData = Data(bytes: message, count: 4)
var lenght : Int = 0
(HeadMsgData as NSData).getBytes(&lenght, length: 4)
// 2. 读取消息类型
var type : Int = 0
guard let typeMsg = self.clientSocket.read(2) else {
return
}
let typeData = Data(bytes: typeMsg, count: 2)
var typelenght : Int = 0
(typeData as NSData).getBytes(&typelenght, length: 2)
// 3. 根据长度 读取真实消息
guard let Msg = self.clientSocket.read(lenght) else {
return
}
let MsgData = Data(bytes: Msg, count: lenght)
switch type {
case 0, 1:
let user = try! UserInfo.parseFrom(data: MsgData)
print(user.name)
print(user.level)
default:
print("未知类型")
}
}
}
}
接收到Server转发到Client的消息 并且依据消息的类型来解析消息,因为Client 和 Server需要一直保持链接状态所以使得一直循环保持下去while true
Client客户端HJSocket中Demo:
import UIKit
class HJSocket: NSObject {
fileprivate var clientSocket : TCPClient
init(addr: String, port: Int) {
clientSocket = TCPClient(addr: addr, port: port)
}
}
extension HJSocket {
//是否链接到服务器
func connectServer() -> Bool {
return clientSocket.connect(timeout: 5).0
}
// 客户端开始接收服务器发送的消息
func startReadMessages() {
DispatchQueue.global().async {
while true {
guard let message = self.clientSocket.read(4) else {
continue
}
// 1.读取消息长度
let HeadMsgData = Data(bytes: message, count: 4)
var lenght : Int = 0
(HeadMsgData as NSData).getBytes(&lenght, length: 4)
// 2. 读取消息类型
var type : Int = 0
guard let typeMsg = self.clientSocket.read(2) else {
return
}
let typeData = Data(bytes: typeMsg, count: 2)
var typelenght : Int = 0
(typeData as NSData).getBytes(&typelenght, length: 2)
// 3. 根据长度 读取真实消息
guard let Msg = self.clientSocket.read(lenght) else {
return
}
let MsgData = Data(bytes: Msg, count: lenght)
switch type {
case 0, 1:
let user = try! UserInfo.parseFrom(data: MsgData)
print(user.name)
print(user.level)
default:
print("未知类型")
}
}
}
}
func sendMsg(MsgData : Data) {
// 如果不需要返回值 则可以在方法中加入 @discardableResult 可遗弃的结果
clientSocket.send(data: MsgData)
}
}
Client客户端ViewController中Demo:
import UIKit
class ViewController: UIViewController {
fileprivate lazy var socket : HJSocket = HJSocket(addr: "192.168.0.7", port: 8888)
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view, typically from a nib.
if socket.connectServer() {
print("链接上服务器")
socket.startReadMessages()
}
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
let userInfo = UserInfo.Builder()
userInfo.name = "name\(arc4random_uniform(10))"
userInfo.level = 10
let MsgData = (try! userInfo.build()).data()
// // 1. 获取消息长度
// let message = "你好，小伙子"
// let messagedata = message.data(using: .utf8)!
// var lenght = messagedata.count
// print(lenght)
// 2.将消息长度写入到data
var lenght = MsgData.count
let headerData = Data(bytes: &lenght, count: 4)
// 3.消息类型
var type = 0
let typeData = Data(bytes: &type, count: 2)
// 4. 发送真实消息
let totalData = headerData + typeData + MsgData
socket.sendMsg(MsgData : totalData)
}
}
