Kotlin + Netty 在 Android 上实现 Socket 的服务端

最新推荐文章于 2025-11-10 00:18:11 发布
原创 最新推荐文章于 2025-11-10 00:18:11 发布 · 958 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了如何使用Kotlin和Netty在Android上构建一个Socket服务端，该服务端能同时监听TCP和WebSocket协议。通过NettyServer和NettyServerInitializer设置各种Handler来处理连接、协议选择、消息编码解码。服务端和客户端的启动、关闭及消息发送都有详细阐述，提供了一个简单的Demo实现，并提到了在实际生产中可能采用JSON作为消息格式的情况。

一. 背景

最近的一个项目：需要使用 Android App 作为 Socket 的服务端，并且一个端口能够同时监听 TCP/Web Socket 协议。

自然而然，项目决定采用 Netty 框架。Netty 服务端在收到客户端发来的消息后，能够做出相应的业务处理。在某些场景下，服务端也需要给客户端 App/网页发送消息。

二. Netty 的使用

2.1 Netty 服务端

首先，定义好 NettyServer，它使用 object声明表示是一个单例。用于 Netty 服务端的启动、关闭以及发送消息。

  1. object NettyServer {
  3.     private val TAG = "NettyServer"
  5.     private var channel: Channel?=null
  6.     private lateinit var listener: NettyServerListener<String>
  7.     private lateinit var bossGroup: EventLoopGroup
  8.     private lateinit var workerGroup: EventLoopGroup
  10.     var port = 8888
  11.         set(value)  {
  12.             field = value
  13.         }
  15.     var webSocketPath = "/ws"
  16.         set(value)  {
  17.             field = value
  18.         }
  20.     var isServerStart: Boolean = false
  21.         private set
  23.     fun start() {
  24.         object : Thread() {
  25.             override fun run() {
  26.                 super.run()
  27.                 bossGroup = NioEventLoopGroup(1)
  28.                 workerGroup = NioEventLoopGroup()
  29.                 try {
  30.                     val b = ServerBootstrap()
  31.                     b.group(bossGroup, workerGroup)
  32.                             .channel(NioServerSocketChannel::class.java)
  33.                             .localAddress(InetSocketAddress(port))
  34.                             .childOption(ChannelOption.SO_KEEPALIVE, true)
  35.                             .childOption(ChannelOption.SO_REUSEADDR, true)
  36.                             .childOption(ChannelOption.TCP_NODELAY, true)
  37.                             .childHandler(NettyServerInitializer(listener,webSocketPath))
  39.                     // Bind and start to accept incoming connections.
  40.                     val f = b.bind().sync()
  41.                     Log.i(TAG, NettyServer::class.java.name + " started and listen on " + f.channel().localAddress())
  43.                     isServerStart = true
  44.                     listener.onStartServer()
  45.                     f.channel().closeFuture().sync()
  46.                 } catch (e: Exception) {
  47.                     Log.e(TAG, e.localizedMessage)
  48.                     e.printStackTrace()
  49.                 } finally {
  50.                     isServerStart = false
  51.                     listener.onStopServer()
  53.                     disconnect()
  54.                 }
  55.             }
  56.         }.start()
  58.     }
  60.     fun disconnect() {
  61.         workerGroup.shutdownGracefully()
  62.         bossGroup.shutdownGracefully()
  63.     }
  65.     fun setListener(listener: NettyServerListener<String>) {
  66.         this.listener = listener
  67.     }
  69.     // 异步发送TCP消息
  70.     fun sendMsgToClient(data: String, listener: ChannelFutureListener) = channel?.run {
  72.         val flag = this.isActive
  74.         if (flag) {
  76.             this.writeAndFlush(data + System.getProperty("line.separator")).addListener(listener)
  77.         }
  79.         flag
  80.     } ?: false
  82.     // 同步发送TCP消息
  83.     fun sendMsgToClient(data: String) = channel?.run {
  85.         if (this.isActive) {
  87.             return this.writeAndFlush(data + System.getProperty("line.separator")).awaitUninterruptibly().isSuccess
  88.         }
  90.         false
  91.     } ?: false
  93.     // 异步发送WebSocket消息
  94.     fun sendMsgToWS(data: String,listener: ChannelFutureListener) = channel?.run {
  96.         val flag = this.isActive
  98.         if (flag) {
  100.             this.writeAndFlush(TextWebSocketFrame(data)).addListener(listener)
  101.         }
  103.         flag
  104.     } ?: false
  106.     // 同步发送TCP消息
  107.     fun sendMsgToWS(data: String) = channel?.run {
  109.         if (this.isActive) {
  111.             return this.writeAndFlush(TextWebSocketFrame(data)).awaitUninterruptibly().isSuccess
  112.         }
  114.         false
  115.     } ?: false
  117.     /**
  118.      * 切换通道
  119.      * 设置服务端，与哪个客户端通信
  120.      * @param channel
  121.      */
  122.     fun selectorChannel(channel: Channel?) {
  123.         this.channel = channel
  124.     }
  125. }

NettyServerInitializer 是服务端跟客户端连接之后使用的 childHandler：

  1. class NettyServerInitializer(private val mListener: NettyServerListener<String>,private val webSocketPath:String) : ChannelInitializer<SocketChannel>() {
  3.     @Throws(Exception::class)
  4.     public override fun initChannel(ch: SocketChannel) {
  6.         val pipeline = ch.pipeline()
  8.         pipeline.addLast("active",ChannelActiveHandler(mListener))
  9.         pipeline.addLast("socketChoose", SocketChooseHandler(webSocketPath))
  11.         pipeline.addLast("string_encoder",StringEncoder(CharsetUtil.UTF_8))
  12.         pipeline.addLast("linebased",LineBasedFrameDecoder(1024))
  13.         pipeline.addLast("string_decoder",StringDecoder(CharsetUtil.UTF_8))
  14.         pipeline.addLast("commonhandler", CustomerServerHandler(mListener))
  15.     }
  16. }

NettyServerInitializer 包含了多个 Handler：连接使用的ChannelActiveHandler，协议选择使用的 SocketChooseHandler，TCP 消息使用的 StringEncoder、LineBasedFrameDecoder、StringDecoder，以及最终处理消息的 CustomerServerHandler。

ChannelActiveHandler:

  1. @ChannelHandler.Sharable
  2. class ChannelActiveHandler(var mListener: NettyServerListener<String>) : ChannelInboundHandlerAdapter() {
  4.     @Throws(Exception::class)
  5.     override fun channelActive(ctx: ChannelHandlerContext) {
  7.         val insocket = ctx.channel().remoteAddress() as InetSocketAddress
  8.         val clientIP = insocket.address.hostAddress
  9.         val clientPort = insocket.port
  11.         Log.i("ChannelActiveHandler","新的连接：$clientIP : $clientPort")
  12.         mListener.onChannelConnect(ctx.channel())
  13.     }
  15. }

SocketChooseHandler 通过读取消息来区分是 WebSocket 还是 Socket。如果是 WebSocket 的话，去掉 Socket 使用的相关 Handler。

  1. class SocketChooseHandler(val webSocketPath:String) : ByteToMessageDecoder() {
  3.     @Throws(Exception::class)
  4.     override fun decode(ctx: ChannelHandlerContext, `in`: ByteBuf, out: List<Any>) {
  5.         val protocol = getBufStart(`in`)
  6.         if (protocol.startsWith(WEBSOCKET_PREFIX)) {
  7.             PipelineAdd.websocketAdd(ctx,webSocketPath)
  9.             ctx.pipeline().remove("string_encoder")
  10.             ctx.pipeline().remove("linebased")
  11.             ctx.pipeline().remove("string_decoder")
  12.         }
  13.         `in`.resetReaderIndex()
  14.         ctx.pipeline().remove(this.javaClass)
  15.     }
  17.     private fun getBufStart(`in`: ByteBuf): String {
  18.         var length = `in`.readableBytes()
  19.         if (length > MAX_LENGTH) {
  20.             length = MAX_LENGTH
  21.         }
  23.         // 标记读位置
  24.         `in`.markReaderIndex()
  25.         val content = ByteArray(length)
  26.         `in`.readBytes(content)
  27.         return String(content)
  28.     }
  30.     companion object {
  31.         /** 默认暗号长度为23  */
  32.         private val MAX_LENGTH = 23
  33.         /** WebSocket握手的协议前缀  */
  34.         private val WEBSOCKET_PREFIX = "GET /"
  35.     }
  36. }

StringEncoder、LineBasedFrameDecoder、StringDecoder 都是 Netty 内置的编、解码器。其中，LineBasedFrameDecoder 用于解决 TCP粘包/拆包的问题。

CustomerServerHandler:

  1. @ChannelHandler.Sharable
  2. class CustomerServerHandler(private val mListener: NettyServerListener<String>) : SimpleChannelInboundHandler<Any>() {
  4.     @Throws(Exception::class)
  5.     override fun channelReadComplete(ctx: ChannelHandlerContext) {
  6.     }
  8.     override fun exceptionCaught(ctx: ChannelHandlerContext,
  9.                                  cause: Throwable) {
  10.         cause.printStackTrace()
  11.         ctx.close()
  12.     }
  14.     @Throws(Exception::class)
  15.     override fun channelRead0(ctx: ChannelHandlerContext, msg: Any) {
  17.         val buff = msg as ByteBuf
  18.         val info = buff.toString(CharsetUtil.UTF_8)
  19.         Log.d(TAG,"收到消息内容：$info")
  20.     }
  22.     @Throws(Exception::class)
  23.     override fun channelRead(ctx: ChannelHandlerContext, msg: Any) {
  25.         if (msg is WebSocketFrame) {  // 处理 WebSocket 消息
  27.             val webSocketInfo = (msg as TextWebSocketFrame).text().trim { it <= ' ' }
  29.             Log.d(TAG, "收到WebSocketSocket消息：$webSocketInfo")
  31.             mListener.onMessageResponseServer(webSocketInfo , ctx.channel().id().asShortText())
  32.         } else if (msg is String){   // 处理 Socket 消息
  34.             Log.d(TAG, "收到socket消息：$msg")
  36.             mListener.onMessageResponseServer(msg, ctx.channel().id().asShortText())
  37.         }
  38.     }
  40.     // 断开连接
  41.     @Throws(Exception::class)
  42.     override fun channelInactive(ctx: ChannelHandlerContext) {
  43.         super.channelInactive(ctx)
  44.         Log.d(TAG, "channelInactive")
  46.         val reAddr = ctx.channel().remoteAddress() as InetSocketAddress
  47.         val clientIP = reAddr.address.hostAddress
  48.         val clientPort = reAddr.port
  50.         Log.d(TAG,"连接断开：$clientIP : $clientPort")
  52.         mListener.onChannelDisConnect(ctx.channel())
  53.     }
  55.     companion object {
  57.         private val TAG = "CustomerServerHandler"
  58.     }
  59. }

2.2 Netty 客户端

客户端也需要一个启动、关闭、发送消息的 NettyTcpClient，并且 NettyTcpClient 的创建采用 Builder 模式。

  1. class NettyTcpClient private constructor(val host: String, val tcp_port: Int, val index: Int) {
  3.     private lateinit var group: EventLoopGroup
  5.     private lateinit var listener: NettyClientListener<String>
  7.     private var channel: Channel? = null
  9.     /**
  10.      * 获取TCP连接状态
  11.      *
  12.      * @return  获取TCP连接状态
  13.      */
  14.     var connectStatus = false
  16.     /**
  17.      * 最大重连次数
  18.      */
  19.     var maxConnectTimes = Integer.MAX_VALUE
  20.         private set
  22.     private var reconnectNum = maxConnectTimes
  24.     private var isNeedReconnect = true
  26.     var isConnecting = false
  27.         private set
  29.     var reconnectIntervalTime: Long = 5000
  30.         private set
  32.     /**
  33.      * 心跳间隔时间
  34.      */
  35.     var heartBeatInterval: Long = 5
  36.         private set//单位秒
  38.     /**
  39.      * 是否发送心跳
  40.      */
  41.     var isSendheartBeat = false
  42.         private set
  44.     /**
  45.      * 心跳数据，可以是String类型，也可以是byte[].
  46.      */
  47.     private var heartBeatData: Any? = null
  49.     fun connect() {
  50.         if (isConnecting) {
  51.             return
  52.         }
  54.         val clientThread = object : Thread("Netty-Client") {
  55.             override fun run() {
  56.                 super.run()
  57.                 isNeedReconnect = true
  58.                 reconnectNum = maxConnectTimes
  59.                 connectServer()
  60.             }
  61.         }
  62.         clientThread.start()
  63.     }
  66.     private fun connectServer() {
  68.         synchronized(this@NettyTcpClient) {
  70.             var channelFuture: ChannelFuture?=null
  72.             if (!connectStatus) {
  73.                 isConnecting = true
  74.                 group = NioEventLoopGroup()
  75.                 val bootstrap = Bootstrap().group(group)
  76.                         .option(ChannelOption.TCP_NODELAY, true)//屏蔽Nagle算法试图
  77.                         .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)
  78.                         .channel(NioSocketChannel::class.java as Class<out Channel>?)
  79.                         .handler(object : ChannelInitializer<SocketChannel>() {
  81.                             @Throws(Exception::class)
  82.                             public override fun initChannel(ch: SocketChannel) {
  84.                                 if (isSendheartBeat) {
  85.                                     ch.pipeline().addLast("ping", IdleStateHandler(0, heartBeatInterval, 0, TimeUnit.SECONDS)) //5s未发送数据，回调userEventTriggered
  86.                                 }
  88.                                 ch.pipeline().addLast(StringEncoder(CharsetUtil.UTF_8))
  89.                                 ch.pipeline().addLast(StringDecoder(CharsetUtil.UTF_8))
  90.                                 ch.pipeline().addLast(LineBasedFrameDecoder(1024))//黏包处理,需要客户端、服务端配合
  91.                                 ch.pipeline().addLast(NettyClientHandler(listener, index, isSendheartBeat, heartBeatData))
  92.                             }
  93.                         })
  95.                 try {
  96.                     channelFuture = bootstrap.connect(host, tcp_port).addListener {
  97.                         if (it.isSuccess) {
  98.                             Log.d(TAG, "连接成功")
  99.                             reconnectNum = maxConnectTimes
  100.                             connectStatus = true
  101.                             channel = channelFuture?.channel()
  102.                         } else {
  103.                             Log.d(TAG, "连接失败")
  104.                             connectStatus = false
  105.                         }
  106.                         isConnecting = false
  107.                     }.sync()
  109.                     // Wait until the connection is closed.
  110.                     channelFuture.channel().closeFuture().sync()
  111.                     Log.d(TAG, " 断开连接")
  112.                 } catch (e: Exception) {
  113.                     e.printStackTrace()
  114.                 } finally {
  115.                     connectStatus = false
  116.                     listener.onClientStatusConnectChanged(ConnectState.STATUS_CONNECT_CLOSED, index)
  118.                     if (channelFuture != null) {
  119.                         if (channelFuture.channel() != null && channelFuture.channel().isOpen) {
  120.                             channelFuture.channel().close()
  121.                         }
  122.                     }
  123.                     group.shutdownGracefully()
  124.                     reconnect()
  125.                 }
  126.             }
  127.         }
  128.     }
  131.     fun disconnect() {
  132.         Log.d(TAG, "disconnect")
  133.         isNeedReconnect = false
  134.         group.shutdownGracefully()
  135.     }
  137.     fun reconnect() {
  138.         Log.d(TAG, "reconnect")
  139.         if (isNeedReconnect && reconnectNum > 0 && !connectStatus) {
  140.             reconnectNum--
  141.             SystemClock.sleep(reconnectIntervalTime)
  142.             if (isNeedReconnect && reconnectNum > 0 && !connectStatus) {
  143.                 Log.e(TAG, "重新连接")
  144.                 connectServer()
  145.             }
  146.         }
  147.     }
  149.     /**
  150.      * 异步发送
  151.      *
  152.      * @param data 要发送的数据
  153.      * @param listener 发送结果回调
  154.      * @return 方法执行结果
  155.      */
  156.     fun sendMsgToServer(data: String, listener: MessageStateListener) = channel?.run {
  158.         val flag = this != null && connectStatus
  160.         if (flag) {
  162.             this.writeAndFlush(data + System.getProperty("line.separator")).addListener { channelFuture -> listener.isSendSuccss(channelFuture.isSuccess) }
  163.         }
  165.         flag
  167.     } ?: false
  169.     /**
  170.      * 同步发送
  171.      *
  172.      * @param data 要发送的数据
  173.      * @return 方法执行结果
  174.      */
  175.     fun sendMsgToServer(data: String) = channel?.run {
  177.         val flag = this != null && connectStatus
  179.         if (flag) {
  181.             val channelFuture = this.writeAndFlush(data + System.getProperty("line.separator")).awaitUninterruptibly()
  182.             return channelFuture.isSuccess
  183.         }
  185.         false
  187.     }?:false
  189.     fun setListener(listener: NettyClientListener<String>) {
  190.         this.listener = listener
  191.     }
  193.     /**
  194.      * Builder 模式创建NettyTcpClient
  195.      */
  196.     class Builder {
  198.         /**
  199.          * 最大重连次数
  200.          */
  201.         private var MAX_CONNECT_TIMES = Integer.MAX_VALUE
  203.         /**
  204.          * 重连间隔
  205.          */
  206.         private var reconnectIntervalTime: Long = 5000
  207.         /**
  208.          * 服务器地址
  209.          */
  210.         private var host: String? = null
  211.         /**
  212.          * 服务器端口
  213.          */
  214.         private var tcp_port: Int = 0
  215.         /**
  216.          * 客户端标识，(因为可能存在多个连接)
  217.          */
  218.         private var mIndex: Int = 0
  220.         /**
  221.          * 是否发送心跳
  222.          */
  223.         private var isSendheartBeat: Boolean = false
  224.         /**
  225.          * 心跳时间间隔
  226.          */
  227.         private var heartBeatInterval: Long = 5
  229.         /**
  230.          * 心跳数据，可以是String类型，也可以是byte[].
  231.          */
  232.         private var heartBeatData: Any? = null
  235.         fun setMaxReconnectTimes(reConnectTimes: Int): Builder {
  236.             this.MAX_CONNECT_TIMES = reConnectTimes
  237.             return this
  238.         }
  241.         fun setReconnectIntervalTime(reconnectIntervalTime: Long): Builder {
  242.             this.reconnectIntervalTime = reconnectIntervalTime
  243.             return this
  244.         }
  247.         fun setHost(host: String): Builder {
  248.             this.host = host
  249.             return this
  250.         }
  252.         fun setTcpPort(tcp_port: Int): Builder {
  253.             this.tcp_port = tcp_port
  254.             return this
  255.         }
  257.         fun setIndex(mIndex: Int): Builder {
  258.             this.mIndex = mIndex
  259.             return this
  260.         }
  262.         fun setHeartBeatInterval(intervalTime: Long): Builder {
  263.             this.heartBeatInterval = intervalTime
  264.             return this
  265.         }
  267.         fun setSendheartBeat(isSendheartBeat: Boolean): Builder {
  268.             this.isSendheartBeat = isSendheartBeat
  269.             return this
  270.         }
  272.         fun setHeartBeatData(heartBeatData: Any): Builder {
  273.             this.heartBeatData = heartBeatData
  274.             return this
  275.         }
  277.         fun build(): NettyTcpClient {
  278.             val nettyTcpClient = NettyTcpClient(host!!, tcp_port, mIndex)
  279.             nettyTcpClient.maxConnectTimes = this.MAX_CONNECT_TIMES
  280.             nettyTcpClient.reconnectIntervalTime = this.reconnectIntervalTime
  281.             nettyTcpClient.heartBeatInterval = this.heartBeatInterval
  282.             nettyTcpClient.isSendheartBeat = this.isSendheartBeat
  283.             nettyTcpClient.heartBeatData = this.heartBeatData
  284.             return nettyTcpClient
  285.         }
  286.     }
  288.     companion object {
  289.         private val TAG = "NettyTcpClient"
  290.         private val CONNECT_TIMEOUT_MILLIS = 5000
  291.     }
  292. }

Android 的客户端相对而言比较简单，需要的 Handler 包括：支持心跳的 IdleStateHandler， TCP 消息需要使用的 Handler (跟服务端一样分别是StringEncoder、StringDecoder、LineBasedFrameDecoder)，以及对收到 TCP 消息进行处理的 NettyClientHandler。

NettyClientHandler：

  1. class NettyClientHandler(private val listener: NettyClientListener<String>, private val index: Int, private val isSendheartBeat: Boolean, private val heartBeatData: Any?) : SimpleChannelInboundHandler<String>() {
  3.     /**
  4.      *
  5.      * 设定IdleStateHandler心跳检测每x秒进行一次读检测，
  6.      * 如果x秒内ChannelRead()方法未被调用则触发一次userEventTrigger()方法
  7.      *
  8.      * @param ctx ChannelHandlerContext
  9.      * @param evt IdleStateEvent
  10.      */
  11.     override fun userEventTriggered(ctx: ChannelHandlerContext, evt: Any) {
  13.         if (evt is IdleStateEvent) {
  14.             if (evt.state() == IdleState.WRITER_IDLE) {   //发送心跳
  16.                 if (isSendheartBeat) {
  17.                     if (heartBeatData == null) {
  19.                         ctx.channel().writeAndFlush("Heartbeat" + System.getProperty("line.separator")!!)
  20.                     } else {
  22.                         if (heartBeatData is String) {
  23.                             Log.d(TAG, "userEventTriggered: String")
  24.                             ctx.channel().writeAndFlush(heartBeatData + System.getProperty("line.separator")!!)
  25.                         } else if (heartBeatData is ByteArray) {
  26.                             Log.d(TAG, "userEventTriggered: byte")
  27.                             val buf = Unpooled.copiedBuffer((heartBeatData as ByteArray?)!!)
  28.                             ctx.channel().writeAndFlush(buf)
  29.                         } else {
  31.                             Log.d(TAG, "userEventTriggered: heartBeatData type error")
  32.                         }
  33.                     }
  34.                 } else {
  35.                     Log.d(TAG, "不发送心跳")
  36.                 }
  37.             }
  38.         }
  39.     }
  41.     /**
  42.      *
  43.      * 客户端上线
  44.      *
  45.      * @param ctx ChannelHandlerContext
  46.      */
  47.     override fun channelActive(ctx: ChannelHandlerContext) {
  49.         Log.d(TAG, "channelActive")
  50.         listener.onClientStatusConnectChanged(ConnectState.STATUS_CONNECT_SUCCESS, index)
  51.     }
  53.     /**
  54.      *
  55.      * 客户端下线
  56.      *
  57.      * @param ctx ChannelHandlerContext
  58.      */
  59.     override fun channelInactive(ctx: ChannelHandlerContext) {
  61.         Log.d(TAG, "channelInactive")
  62.     }
  64.     /**
  65.      * 客户端收到消息
  66.      *
  67.      * @param channelHandlerContext ChannelHandlerContext
  68.      * @param msg                   消息
  69.      */
  70.     override fun channelRead0(channelHandlerContext: ChannelHandlerContext, msg: String) {
  72.         Log.d(TAG, "channelRead0:")
  73.         listener.onMessageResponseClient(msg, index)
  74.     }
  76.     /**
  77.      * @param ctx   ChannelHandlerContext
  78.      * @param cause 异常
  79.      */
  80.     override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
  82.         Log.e(TAG, "exceptionCaught")
  83.         listener.onClientStatusConnectChanged(ConnectState.STATUS_CONNECT_ERROR, index)
  84.         cause.printStackTrace()
  85.         ctx.close()
  86.     }
  88.     companion object {
  90.         private val TAG = "NettyClientHandler"
  91.     }
  92. }

三. Demo 的实现

3.1 Socket 服务端

启动 NettyServer：

  1.     private fun startServer() {
  3.         if (!NettyServer.isServerStart) {
  4.             NettyServer.setListener(this@MainActivity)
  5.             NettyServer.port = port
  6.             NettyServer.webSocketPath = webSocketPath
  7.             NettyServer.start()
  8.         } else {
  9.             NettyServer.disconnect()
  10.         }
  11.     }

NettyServer 异步发送 TCP 消息：

  1. NettyServer.sendMsgToClient(msg, ChannelFutureListener { channelFuture ->
  3.         if (channelFuture.isSuccess) {
  5.             msgSend(msg)
  6.       } 
  7. })

NettyServer 异步发送 WebSocket 消息：

  1. NettyServer.sendMsgToWS(msg, ChannelFutureListener { channelFuture ->
  3.         if (channelFuture.isSuccess) {
  5.               msgSend(msg)
  6.       } 
  7.  })

Demo 可以通过 startServer 来启动 Socket 服务端，也可以在启动之前点击 configServer 来修改服务端的端口以及 WebSocket 的 Endpoint。

3.2 Socket 客户端

NettyTcpClient 通过 Builder 模式创建：

  1.             mNettyTcpClient = NettyTcpClient.Builder()
  2.                     .setHost(ip)                    //设置服务端地址
  3.                     .setTcpPort(port)               //设置服务端端口号
  4.                     .setMaxReconnectTimes(5)        //设置最大重连次数
  5.                     .setReconnectIntervalTime(5)    //设置重连间隔时间。单位：秒
  6.                     .setSendheartBeat(false)        //设置发送心跳
  7.                     .setHeartBeatInterval(5)        //设置心跳间隔时间。单位：秒
  8.                     .setHeartBeatData("I'm is HeartBeatData") //设置心跳数据，可以是String类型，也可以是byte[]，以后设置的为准
  9.                     .setIndex(0)                    //设置客户端标识.(因为可能存在多个tcp连接)
  10.                     .build()
  12.             mNettyTcpClient.setListener(this@MainActivity) //设置TCP监听

启动、关闭客户端连接：

  1.     private fun connect() {
  2.         Log.d(TAG, "connect")
  3.         if (!mNettyTcpClient.connectStatus) {
  4.             mNettyTcpClient.connect()//连接服务器
  5.         } else {
  6.             mNettyTcpClient.disconnect()
  7.         }
  8.     }

NettyTcpClient 异步发送 TCP 消息到服务端：

  1. mNettyTcpClient.sendMsgToServer(msg, object : MessageStateListener {
  2.          override fun isSendSuccss(isSuccess: Boolean) {
  3.                 if (isSuccess) {
  5.                    msgSend(msg)
  6.                } 
  7.          }
  8. })

Demo 的客户端 App 也可以在启动之前点击 configClient 来修改要连接的服务端 IP 、端口。

WebSocket 的测试可以通过：http://www.websocket-test.com/

Netty Server 端跟网页通信：

WebSocket在线测试：

四. 总结

借助 Kotlin 的特性以及 Netty 框架，我们在 Android 上也实现了一个 Socket 服务端。

本文 demo github 地址：https://github.com/fengzhizi715/Netty4Android

本文的例子很简单，只是发送简单的消息。在实际生产环境中，我们采用的消息格式可能是 json ，因为 json 更加灵活，通过解析 json 获取消息的内容。

参考资料：

  1. https://github.com/aLittleGreens/NettyDemo

  2. Netty 实现 一个端口同时接收 socket 和 webSocket 连接(https://blog.youkuaiyun.com/NRlovestudy/article/details/93325965)

关注【Java与Android技术栈】

更多精彩内容请关注扫码：

Netty WebSocket 客户端和服务端
原名又逢乱世。不要放下学习的脚步，毕竟比天天打牌、钓鱼、打游戏更能从内在充实自己。
05-16 2055
WebSocketServerProtocolHandler 服务端 WebSocketClientProtocolHandler服务端收发消息
springboot+netty实现基于JT808协议的注册、鉴权
热门推荐
todoitbo的博客
12-17 2万+
springboot+netty实现基于JT808协议的注册、鉴权
基于Netty构建Websocket服务端
雨后是冰雹
12-22 2102
除了构建TCP和UDP服务器和客户端，Netty还可以用于构建WebSocket服务器。WebSocket是一种基于TCP协议的双向通信协议，可以在Web浏览器和Web服务器之间建立实时通信通道。下面是一个简单的示例，演示如何使用Netty构建一个WebSocket服务器。
突破跨平台壁垒：Kotlin/Native高性能网络编程实战指南
最新发布
gitblog_00945的博客
11-10 718
在移动开发与物联网领域，开发者常面临一个棘手问题：如何用一套代码库实现跨平台网络通信，同时保证原生级性能？Kotlin/Native（KN）通过将Kotlin代码编译为机器码，为解决这一痛点提供了全新可能。本文将系统讲解如何在KN环境下实现Socket（套接字）通信与HTTP客户端开发，帮助开发者避开JVM依赖限制，构建真正跨平台的高性能网络应用。 ## 技术选型：为何选择Kotlin/Nati
【Android】使用Netty库来实现Socket接收
资深全栈开发工程师
12-08 1282
在Android中使用Netty来实现Socket接收是可行的。Netty是一个高性能的网络通信框架，支持多种协议，包括原生的Socket通信。希望以上示例能帮助你在Android中使用Netty实现Socket接收。请注意适当处理网络通信的异常和关闭操作，以确保代码的稳定性和安全性。请注意，为了避免在主线程中执行耗时的操作，建议在后台线程中执行。是一个自定义的处理程序，用于处理接收到的数据。在上述示例中，我们创建了一个Netty的。接下来，在合适的时机创建Netty的。首先，在你的Android项目的。
Kotlin + Netty 在 Android 上实现 Socket 的服务端(续篇)
Java与Android技术栈
09-01 592
一. 对原先 NettyServer 的改造上一篇文章《Kotlin + Netty 在 Android 上实现 Socket 的服务端》 ，曾经介绍的 NettySer...
[Netty] 使用Netty实现webSocket服务端
GxDong_的博客
01-07 412
使用Netty实现WebSocket的服务端部分 服务端代码 import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelPipeline; import io.netty.channel.EventLoopGroup; import io.netty.c
Kotlin进程通信------Socket
双斧狂暴战专栏
07-13 5235
Socket作为进程通信的一种方式，在日常的进程通信中使用的不频繁，它更常用的是即时通讯、跨设备的一对多场景等。android进程间通信中使用socket，一般是一对一的场景，是常用Socket方式的降级、简单化的使用方式。 Socket的使用，需要了解、注意的是它的握手、挥手机制。 简洁明了的，可以参考： 为什么不能用两次握手进行连接？ 为什么socket是三次握手挥手却是四次？ 详细解释的，可以参考：HTTP、HTTPS、TCP/IP、Socket通信、三次握手四次挥手过程？ 回到andro
学习 Android（六）Netty通信实战
m0_56334538的博客
04-30 1379
在 Android 开发中，Netty 是一个基于 Java NIO 的高性能、异步事件驱动的网络应用框架，主要用于构建需要高效网络通信的客户端或服务端。尽管 Android 开发中常见的 HTTP 请求通常使用 OkHttp 或 Retrofit，但在某些复杂场景下，Netty 能提供更底层的控制和更高的性能。接下来跟着文章一起学习一下 Netty 。异步非阻塞模型协议高度可定制零拷贝优化高拓展性上述大致介绍了一下 Netty 的相关知识，为了对其有进一步的了解，本文将实现一个简单的实时通信功能来进一步的
Android与服务端基于TCP的Socket通信实现
因此，在实现Socket通信时，开发者常采用多线程、HandlerThread、AsyncTask（尽管已废弃）或现代的协程（Kotlin Coroutines）与线程池结合的方式，来保证UI线程不被阻塞。例如，可以在子线程中启动Socket连接并持续...
基于Netty与Socket.IO的Android视频控制播放器
在本项目中，Socket.IO 极有可能被用于实现客户端与服务端之间的双向实时通信——例如，服务端可以向多个 Android 客户端发送播放/暂停、跳转时间点、音量调节等控制命令，而客户端也可以反馈当前播放状态、缓冲进度...
android-netty:适用于 Android 的 Netty 客户端
06-18
适用于 Android 的 Netty 客户端库 介绍 该库基于 Netty( ) Project v3.8。 Original 项目中无法使用的 API 太多了，因为 Android 不是 Java SE 环境。 如果您正在开发 TCP 客户端，或者如果服务器使用 Netty 库，请尝试使用该库。 这个库比原来的库小很多（大约279 KB，经过Proguard优化后会缩小到50-100 KB左右）。 该库是适用于 Android 的 Netty ( ) 项目 v3.8 的轻量级版本。 我们从 Netty 内部的代码中删除并清理了 Android 不必要的内容，而没有添加单独的源代码。 版权和许可证与 Netty 项目相同。 因为Android Framework不是基于Java SE，所以有很多API是基于SE编写的Netty java库无法使用的。 我们删除了这些代码并满
socket长连接,netty服务器与android源码
01-26
里面有android前端和java服务器源码,主要演示socket长连接netty框架的简单使用,想学习socket的同学可以下来看看,
Android-netty和socket通信的demo
08-13
Netty是基于Java NIO client-server的网络应用框架，使用Netty可以快速开发网络应用
Android端聊天室服务端实现及源码分析
今天要讨论的是一个基于Android平台实现的聊天室服务端，它涉及到的技术点不仅包括Android后端开发，还包括网络通信、服务器架构等方面的知识。 首先，我们需要了解Android平台上的网络编程基础。在Android应用中，...
Android使用Netty网络框架实践（客户端、服务端）
yan_chenglong的博客
02-26 3225
*** 接收到数据* *//*** 服务端异常* *//*** 服务启动成功* *//*** 服务启动失败* *//*** 服务端被客户端连接成功* *//*** 服务端断开连接成功* *//*** 服务端关闭成功* *//*** 客户端异常* *//*** 客户端连接服务成功* *//*** 客户端连接断服务失败* *//*** 客户端断开连接成功* *//*** 客户端关闭成功* */
android webservice 后台服务,Android 调用 Webservice的实现过程
weixin_30467625的博客
05-25 743
之前帮朋友做了一个服务端是Webservice的项目，把实现过程中的一下流程简单记录一下1、开启Webservice服务一般后台会开启一个服务给你或者为了直接方便调试的话，也可以自己用androidStudio 打开这个Webservice项目，如下图所示：image.pngimage.pngimage.png2、打开wsdl查看接口信息image.pngimage.pngimage.png---...
socket客户端与服务端的通信
cuterabbitbaby的博客
10-14 285
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintWriter; import java.net.Server
android netty导入_Android实现服务端与客户端netty交互（windows）包括部分问题及解决方案...
weixin_39635084的博客
12-21 526
---------------2020-3-14初次记录初入Netty，了解参考：跳转服务端使用eclipse,客户端使用android studio3.5.2：代码参考：跳转包括(环境搭建)服务端客户端均在eclipse，代码参考：跳转后期待修补(android studio测试可运行，但是我的netty版本以及as的SDK版本及真机测试API版本有问题，待修补)。---------------...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值