基于Kotlin实现一个简单的TCP自定义协议

一. 开发背景

想要成为一名优秀的Android开发,你需要一份完备的 知识体系,在这里,让我们一起成长为自己所想的那样~。

基于 Kotlin 实现一个简单的 TCP 自定义协议

我们的项目需要开发一款智能硬件。它由 Web 后台发送指令到一款桌面端应用程序,再由桌面程序来控制不同的硬件设备实现业务上的操作。从 Web 后台到桌面端是通过一个 WebSocket 长链接来进行维护,而桌面程序到各个硬件设备也是一个 TCP 长链接来维护的。

本文讲述的,其实是从桌面程序到各个硬件之间的通讯。

二. 自定义通讯协议

首先,需要设计一个通用的 TCP 网络协议。

网络协议结构如下

 1.       +--------------+---------------+------------+---------------+-----------+----------+
    
2.       | 魔数(4)       | version(1)    |序列化方式(1) | command(1)    |数据长度(4) |数据(n)    |
    
3.       +--------------+---------------+------------+---------------+-----------+----------+ 
  • 魔数:4字节,本项目中使用 20200803(这一天编写的日子),为了防止该端口被意外调用,我们在收到报文后取前4个字节与魔数比对,如果不相同则直接拒绝并关闭连接。
  • 版本号:1字节,仅表示协议的版本号,便于协议升级时使用
  • 序列化方式:1字节,表示如何将 Java 对象转化为二进制数据,以及如何反序列化。
  • 指令:1字节,表示该消息的意图(如拍照、拍视频、心跳、App 升级等)。最多支持 2^8 种指令。
  • 数据长度:4字节,表示该字段后数据部分的长度。最多支持 2^32 位。
  • 数据:具体数据的内容。

根据上述所设计的网络协议,定义一个抽象类 Packet:

1.  abstract class Packet {
    

3.      var magic:Int? = MAGIC_NUMBER     // 魔数
    
4.      var version:Byte = 1              // 版本号,当前协议的版本号为 1
    

6.      abstract val serializeMethod:Byte // 序列化方式
    
7.      abstract val command:Byte         // Watcher 跟 App 相互通讯的指令
    
8.  } 

有多少个指令就需要定义多少个 Packet,下面以心跳的 Packet 为例,定义一个 HeartBeatPacket:

1.  data class HeartBeatPacket(var msg:String = "ping",
    
2.                             override val serializeMethod: Byte = Serialize.JSON,
    
3.                             override val command: Byte = Commands.HEART_BEAT) : Packet() {
    
4.  } 

HeartBeatPacket 是由 TCP 客户端发起,由 TCP 服务端接收并返回给客户端。

每个 Packet 类都包含了该 Packet 所使用的序列化方式。

1.  /**
    
2.   * 序列化方式的常量列表
    
3.   */
    
4.  interface Serialize {
    

6.      companion object {
    

8.          const val JSON: Byte = 0
    
9.      }
    
10.  } 

每个 Packet 也包含了其对应的 command。下面是 Commands 是指令集,支持256个指令。

1.  /**
    
2.   * 指令集,支持从 -128 到 127 总共 256 个指令
    
3.   */
    
4.  interface Commands {
    

6.      companion object {
    

8.          /**
    
9.   * 心跳包
    
10.   */
    
11.          const val HEART_BEAT: Byte = 0
    

13.          /**
    
14.   * 登录(App 需要告诉 Watcher :cameraPosition 的位置)
    
15.   */
    
16.          const val LOGIN: Byte = 1
    

18.          ......
    
19.     }
    
20.  } 

由于使用自定义的协议,必须要有对报文的 encode、decode,PacketManager 负责这些事情。
encode 时按照协议的结构进行组装报文,同理 decode 是其逆向的过程。

1.  /**
    
2.   * 报文的管理类,对报文进行 encode、decode
    
3.   */
    
4.  object PacketManager {
    

6.      fun encode(packet: Packet):ByteBuf = encode(ByteBufAllocator.DEFAULT, packet)
    

8.      fun encode(alloc:ByteBufAllocator, packet: Packet) = encode(alloc.ioBuffer(), packet)
    

10.      fun encode(buf: ByteBuf, packet: Packet): ByteBuf {
    

12.          val serializer = SerializerFactory.getSerializer(packet.serializeMethod)
    

14.          val bytes: ByteArray = serializer.serialize(packet)
    

16.          //组装报文:魔数(4字节)+ 版本号(1字节)+ 序列化方式(1字节)+ 指令(1字节)+ 数据长度(4字节)+ 数据(N字节)
    
17.          buf.writeInt(MAGIC_NUMBER)
    
18.          buf.writeByte(packet.version.toInt())
    
19.          buf.writeByte(packet.serializeMethod.toInt())
    
20.          buf.writeByte(packet.command.toInt())
    
21.          buf.writeInt(bytes.size)
    
22.          buf.writeBytes(bytes)
    

24.          return buf
    
25.      }
    

27.      fun decode(buf:ByteBuf): Packet {
    

29.          buf.skipBytes(4) // 魔数由单独的 Handler 进行校验
    
30.          buf.skipBytes(1)
    

32.          val serializationMethod = buf.readByte()
    
33.          val serializer = SerializerFactory.getSerializer(serializationMethod)
    

35.          val command = buf.readByte()
    
36.          val clazz = PacketFactory.getPacket(command)
    

38.          val length = buf.readInt()  // 数据的长度
    
39.          val bytes = ByteArray(length)   // 定义需要读取的字符数组
    
40.          buf.readBytes(bytes)
    
41.          return serializer.deserialize(clazz, bytes)
    
42.      }
    

44.  } 

三. TCP 服务端

启动 TCP 服务的方法

 1.      fun execute() {
    
2.          boss = NioEventLoopGroup()
    
3.          worker = NioEventLoopGroup()
    
4.          val bootstrap = ServerBootstrap()
    
5.          bootstrap.group(boss, worker).channel(NioServerSocketChannel::class.java)
    
6.                  .option(ChannelOption.SO_BACKLOG, 100)
    
7.                  .childOption(ChannelOption.SO_KEEPALIVE, true)
    
8.                  .childOption(ChannelOption.SO_REUSEADDR, true)
    
9.                  .childOption(ChannelOption.TCP_NODELAY, true)
    
10.                  .childHandler(object : ChannelInitializer<NioSocketChannel>() {
    

12.                      @Throws(Exception::class)
    
13.                      override fun initChannel(nioSocketChannel: NioSocketChannel) {
    

15.                          val pipeline = nioSocketChannel.pipeline()
    
16.                          pipeline.addLast(ServerIdleHandler())
    
17.                          pipeline.addLast(MagicNumValidator())
    
18.                          pipeline.addLast(PacketCodecHandler)
    
19.                          pipeline.addLast(HeartBeatHandler)
    
20.                          pipeline.addLast(ResponseHandler)
    
21.                      }
    
22.                  })
    

24.          val future: ChannelFuture = bootstrap.bind(TCP_PORT)
    

26.          future.addListener(object : ChannelFutureListener {
    

28.              @Throws(Exception::class)
    
29.              override fun operationComplete(channelFuture: ChannelFuture) {
    
30.                  if (channelFuture.isSuccess) {
    
31.                      logInfo(logger, "TCP Server is starting...")
    
32.                  } else {
    
33.                      logError(logger,channelFuture.cause(),"TCP Server failed")
    
34.                  }
    
35.              }
    
36.          })
    
37.      } 

其中,ServerIdleHandler: 表示 5 分钟内没有收到心跳,则断开连接。

1.  class ServerIdleHandler : IdleStateHandler(0, 0, HERT_BEAT_TIME) {
    

3.      private val logger: Logger = LoggerFactory.getLogger(ServerIdleHandler::class.java)
    

5.      @Throws(Exception::class)
    
6.      override fun channelIdle(ctx: ChannelHandlerContext, evt: IdleStateEvent) {
    
7.          logInfo(logger) {
    
8.              ctx.channel().close()
    
9.              "$HERT_BEAT_TIME 秒内没有收到心跳,则断开连接"
    
10.          }
    
11.      }
    

13.      companion object {
    

15.          private const val HERT_BEAT_TIME = 300
    
16.      }
    
17.  } 

MagicNumValidator:用于 TCP 报文的魔数校验。

1.  class MagicNumValidator : LengthFieldBasedFrameDecoder(Int.MAX_VALUE, LENGTH_FIELD_OFFSET, LENGTH_FIELD_LENGTH) {
    

3.      private val logger: Logger = LoggerFactory.getLogger(this.javaClass)
    

5.      @Throws(Exception::class)
    
6.      override fun decode(ctx: ChannelHandlerContext, `in`: ByteBuf): Any? {
    

8.          if (`in`.getInt(`in`.readerIndex()) !== MAGIC_NUMBER) { // 魔数校验不通过,则关闭连接
    
9.              logInfo(logger,"魔数校验失败")
    
10.              ctx.channel().close()
    
11.              return null
    
12.          }
    

14.          return super.decode(ctx, `in`)
    
15.      }
    

17.      companion object {
    
18.          private const val LENGTH_FIELD_OFFSET = 7
    
19.          private const val LENGTH_FIELD_LENGTH = 4
    
20.      }
    
21.  } 

PacketCodecHandler: 解析报文的 Handler。

PacketCodecHandler 继承自 ByteToMessageCodec ,它是用来处理 byte-to-message 和message-to-byte,便于解码字节消息成 POJO 或编码 POJO 消息成字节。

1.  @ChannelHandler.Sharable
    
2.  object PacketCodecHandler : MessageToMessageCodec<ByteBuf, Packet>() {
    

4.      override fun encode(ctx: ChannelHandlerContext, msg: Packet, list: MutableList<Any>) {
    
5.          val byteBuf = ctx.channel().alloc().ioBuffer()
    
6.          PacketManager.encode(byteBuf, msg)
    
7.          list.add(byteBuf)
    
8.      }
    

10.      override fun decode(ctx: ChannelHandlerContext, msg: ByteBuf, list: MutableList<Any>) {
    
11.          list.add(PacketManager.decode(msg));
    
12.      }
    

14.  } 

HeartBeatHandler:心跳的 Handler,接收 TCP 客户端发来的"ping",然后给客户端返回"pong"。

1.  @ChannelHandler.Sharable
    
2.  object HeartBeatHandler : SimpleChannelInboundHandler<HeartBeatPacket>(){
    

4.      private val logger: Logger = LoggerFactory.getLogger(this.javaClass)
    

6.      override fun channelRead0(ctx: ChannelHandlerContext, msg: HeartBeatPacket) {
    
7.          logInfo(logger,"收到心跳包:${GsonUtils.toJson(msg)}")
    

9.          msg.msg = "pong" // 返回 pong 给到客户端
    
10.          ctx.writeAndFlush(msg)
    
11.      }
    

13.  } 

ResponseHandler:通用的处理接收 TCP 客户端发来指令的 Handler,可以根据对应的指令去查询对应的 Handler 并处理其命令。

1.  object ResponseHandler: SimpleChannelInboundHandler<Packet>() {
    

3.      private val logger: Logger = LoggerFactory.getLogger(this.javaClass)
    
4.      private val handlerMap: ConcurrentHashMap<Byte, SimpleChannelInboundHandler<out Packet>> = ConcurrentHashMap()
    

6.      init {
    
7.          handlerMap[LOGIN] = LoginHandler
    
8.          ......
    

10.          handlerMap[ERROR] = ErrorHandler
    
11.      }
    

13.      override fun channelRead0(ctx: ChannelHandlerContext, msg: Packet) {
    
14.          logInfo(logger,"收到客户端的指令: ${msg.command}")
    

16.          val handler: SimpleChannelInboundHandler<out Packet>? = handlerMap[msg.command]
    

18.          handler?.let {
    
19.              logInfo(logger,"找到响应指令的 Handler: ${it.javaClass.simpleName}")
    
20.              it.channelRead(ctx, msg)
    
21.          } ?: logInfo(logger,"未找到响应指令的 Handler")
    
22.      }
    

24.      @Throws(Exception::class)
    
25.      override fun channelInactive(ctx: ChannelHandlerContext) {
    
26.          val insocket = ctx.channel().remoteAddress() as InetSocketAddress
    
27.          val clientIP = insocket.address.hostAddress
    
28.          val clientPort = insocket.port
    

30.          logError(logger,"客户端掉线: $clientIP : $clientPort")
    
31.          super.channelInactive(ctx)
    
32.      }
    
33.  } 

四. TCP 客户端

模拟一个客户端的实现

1.  val topLevelClass = object : Any() {}.javaClass.enclosingClass
    
2.  val logger: Logger = LoggerFactory.getLogger(topLevelClass)
    

4.  fun main() {
    

6.      val worker = NioEventLoopGroup()
    
7.      val bootstrap = Bootstrap()
    
8.      bootstrap.group(worker).channel(NioSocketChannel::class.java)
    
9.              .handler(object : ChannelInitializer<SocketChannel>() {
    

11.                  @Throws(Exception::class)
    
12.                  override fun initChannel(channel: SocketChannel) {
    
13.                      channel.pipeline().addLast(PacketCodecHandler)
    
14.                      channel.pipeline().addLast(ClientIdleHandler())
    
15.                      channel.pipeline().addLast(ClientLogin())
    
16.                  }
    
17.              })
    

19.      val future: ChannelFuture = bootstrap.connect("127.0.0.1", TCP_PORT).addListener(object : ChannelFutureListener {
    

21.          @Throws(Exception::class)
    
22.          override fun operationComplete(channelFuture: ChannelFuture) {
    
23.              if (channelFuture.isSuccess()) {
    
24.                  logInfo(logger,"connect to server success!")
    
25.              } else {
    
26.                  logger.info("failed to connect the server! ")
    
27.                  System.exit(0)
    
28.              }
    
29.          }
    
30.      })
    
31.      try {
    
32.          future.channel().closeFuture().sync()
    
33.          logInfo(logger,"与服务端断开连接!")
    
34.      } catch (e: InterruptedException) {
    
35.          e.printStackTrace()
    
36.      }
    
37.  } 

其中,PacketCodecHandler 跟服务端使用的解析报文的 Handler 是一样的。

ClientIdleHandler:客户端实现心跳,每隔 30 秒发送一次心跳。

1.  class ClientIdleHandler : IdleStateHandler(0, 0, HEART_BEAT_TIME) {
    

3.      private val logger = LoggerFactory.getLogger(ClientIdleHandler::class.java)
    

5.      @Throws(Exception::class)
    
6.      override fun channelIdle(ctx: ChannelHandlerContext, evt: IdleStateEvent?) {
    
7.          logInfo(logger,"发送心跳....")
    
8.          ctx.writeAndFlush(HeartBeatPacket())
    
9.      }
    

11.      companion object {
    
12.          private const val HEART_BEAT_TIME = 30
    
13.      }
    
14.  } 

ClientLogin:登录服务端的 Handler。

1.  @ChannelHandler.Sharable
    
2.  class ClientLogin: ChannelInboundHandlerAdapter() {
    

4.      private val logger: Logger = LoggerFactory.getLogger(this.javaClass)
    

6.      @Throws(Exception::class)
    
7.      override fun channelActive(ctx: ChannelHandlerContext) {
    

9.          val packet: LoginPacket = LoginPacket()
    
10.          logInfo(logger,"packet = ${GsonUtils.toJson(packet)}")
    
11.          val byteBuf = PacketManager.encode(packet)
    
12.          ctx.channel().writeAndFlush(byteBuf)
    
13.      }
    
14.  } 

五. 总结

这次,我开发的桌面端程序其实逻辑并不复杂,只需接收 Web 后台的指令,然后跟各个设备进行交互。

接收到 Web 端的指令后,通过 Guava 的 EventBus 将指令通过 TCP 发送给各个设备,发送时需要转化成对应的 Packet。因此,核心的模块就是这个 TCP 自定义的协议。

现在都说互联网寒冬,其实只要自身技术能力够强,咱们就不怕!我这边专门针对Android开发工程师整理了一套【Android进阶学习视频】、【全套Android面试秘籍】、【Android知识点PDF】。如有需要获取资料文档的朋友,可以点击我的GitHub免费获取!

评论

暂无评论