AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

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

2022-05-11 859
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Kotlin + Netty 在 Android 上实现 Socket 的服务端

一. 背景


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


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


二. Netty 的使用


2.1 Netty 服务端


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


object NettyServer {
    private val TAG = "NettyServer"
    private var channel: Channel?=null
    private lateinit var listener: NettyServerListener<String>
    private lateinit var bossGroup: EventLoopGroup
    private lateinit var workerGroup: EventLoopGroup
    var port = 8888
        set(value)  {
            field = value
        }
    var webSocketPath = "/ws"
        set(value)  {
            field = value
        }
    var isServerStart: Boolean = false
        private set
    fun start() {
        object : Thread() {
            override fun run() {
                super.run()
                bossGroup = NioEventLoopGroup(1)
                workerGroup = NioEventLoopGroup()
                try {
                    val b = ServerBootstrap()
                    b.group(bossGroup, workerGroup)
                            .channel(NioServerSocketChannel::class.java)
                            .localAddress(InetSocketAddress(port))
                            .childOption(ChannelOption.SO_KEEPALIVE, true)
                            .childOption(ChannelOption.SO_REUSEADDR, true)
                            .childOption(ChannelOption.TCP_NODELAY, true)
                            .childHandler(NettyServerInitializer(listener,webSocketPath))
                    // Bind and start to accept incoming connections.
                    val f = b.bind().sync()
                    Log.i(TAG, NettyServer::class.java.name + " started and listen on " + f.channel().localAddress())
                    isServerStart = true
                    listener.onStartServer()
                    f.channel().closeFuture().sync()
                } catch (e: Exception) {
                    Log.e(TAG, e.localizedMessage)
                    e.printStackTrace()
                } finally {
                    isServerStart = false
                    listener.onStopServer()
                    disconnect()
                }
            }
        }.start()
    }
    fun disconnect() {
        workerGroup.shutdownGracefully()
        bossGroup.shutdownGracefully()
    }
    fun setListener(listener: NettyServerListener<String>) {
        this.listener = listener
    }
    // 异步发送TCP消息
    fun sendMsgToClient(data: String, listener: ChannelFutureListener) = channel?.run {
        val flag = this.isActive
        if (flag) {
            this.writeAndFlush(data + System.getProperty("line.separator")).addListener(listener)
        }
        flag
    } ?: false
    // 同步发送TCP消息
    fun sendMsgToClient(data: String) = channel?.run {
        if (this.isActive) {
            return this.writeAndFlush(data + System.getProperty("line.separator")).awaitUninterruptibly().isSuccess
        }
        false
    } ?: false
    // 异步发送WebSocket消息
    fun sendMsgToWS(data: String,listener: ChannelFutureListener) = channel?.run {
        val flag = this.isActive
        if (flag) {
            this.writeAndFlush(TextWebSocketFrame(data)).addListener(listener)
        }
        flag
    } ?: false
    // 同步发送TCP消息
    fun sendMsgToWS(data: String) = channel?.run {
        if (this.isActive) {
            return this.writeAndFlush(TextWebSocketFrame(data)).awaitUninterruptibly().isSuccess
        }
        false
    } ?: false
    /**
     * 切换通道
     * 设置服务端，与哪个客户端通信
     * @param channel
     */
    fun selectorChannel(channel: Channel?) {
        this.channel = channel
    }
}


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


class NettyServerInitializer(private val mListener: NettyServerListener<String>,private val webSocketPath:String) : ChannelInitializer<SocketChannel>() {
    @Throws(Exception::class)
    public override fun initChannel(ch: SocketChannel) {
        val pipeline = ch.pipeline()
        pipeline.addLast("active",ChannelActiveHandler(mListener))
        pipeline.addLast("socketChoose", SocketChooseHandler(webSocketPath))
        pipeline.addLast("string_encoder",StringEncoder(CharsetUtil.UTF_8))
        pipeline.addLast("linebased",LineBasedFrameDecoder(1024))
        pipeline.addLast("string_decoder",StringDecoder(CharsetUtil.UTF_8))
        pipeline.addLast("commonhandler", CustomerServerHandler(mListener))
    }
}


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


ChannelActiveHandler:


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


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


class SocketChooseHandler(val webSocketPath:String) : ByteToMessageDecoder() {
    @Throws(Exception::class)
    override fun decode(ctx: ChannelHandlerContext, `in`: ByteBuf, out: List<Any>) {
        val protocol = getBufStart(`in`)
        if (protocol.startsWith(WEBSOCKET_PREFIX)) {
            PipelineAdd.websocketAdd(ctx,webSocketPath)
            ctx.pipeline().remove("string_encoder")
            ctx.pipeline().remove("linebased")
            ctx.pipeline().remove("string_decoder")
        }
        `in`.resetReaderIndex()
        ctx.pipeline().remove(this.javaClass)
    }
    private fun getBufStart(`in`: ByteBuf): String {
        var length = `in`.readableBytes()
        if (length > MAX_LENGTH) {
            length = MAX_LENGTH
        }
        // 标记读位置
        `in`.markReaderIndex()
        val content = ByteArray(length)
        `in`.readBytes(content)
        return String(content)
    }
    companion object {
        /** 默认暗号长度为23  */
        private val MAX_LENGTH = 23
        /** WebSocket握手的协议前缀  */
        private val WEBSOCKET_PREFIX = "GET /"
    }
}


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


CustomerServerHandler:


@ChannelHandler.Sharable
class CustomerServerHandler(private val mListener: NettyServerListener<String>) : SimpleChannelInboundHandler<Any>() {
    @Throws(Exception::class)
    override fun channelReadComplete(ctx: ChannelHandlerContext) {
    }
    override fun exceptionCaught(ctx: ChannelHandlerContext,
                                 cause: Throwable) {
        cause.printStackTrace()
        ctx.close()
    }
    @Throws(Exception::class)
    override fun channelRead0(ctx: ChannelHandlerContext, msg: Any) {
        val buff = msg as ByteBuf
        val info = buff.toString(CharsetUtil.UTF_8)
        Log.d(TAG,"收到消息内容：$info")
    }
    @Throws(Exception::class)
    override fun channelRead(ctx: ChannelHandlerContext, msg: Any) {
        if (msg is WebSocketFrame) {  // 处理 WebSocket 消息
            val webSocketInfo = (msg as TextWebSocketFrame).text().trim { it <= ' ' }
            Log.d(TAG, "收到WebSocketSocket消息：$webSocketInfo")
            mListener.onMessageResponseServer(webSocketInfo , ctx.channel().id().asShortText())
        } else if (msg is String){   // 处理 Socket 消息
            Log.d(TAG, "收到socket消息：$msg")
            mListener.onMessageResponseServer(msg, ctx.channel().id().asShortText())
        }
    }
    // 断开连接
    @Throws(Exception::class)
    override fun channelInactive(ctx: ChannelHandlerContext) {
        super.channelInactive(ctx)
        Log.d(TAG, "channelInactive")
        val reAddr = ctx.channel().remoteAddress() as InetSocketAddress
        val clientIP = reAddr.address.hostAddress
        val clientPort = reAddr.port
        Log.d(TAG,"连接断开：$clientIP : $clientPort")
        mListener.onChannelDisConnect(ctx.channel())
    }
    companion object {
        private val TAG = "CustomerServerHandler"
    }
}


2.2 Netty 客户端


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


class NettyTcpClient private constructor(val host: String, val tcp_port: Int, val index: Int) {
    private lateinit var group: EventLoopGroup
    private lateinit var listener: NettyClientListener<String>
    private var channel: Channel? = null
    /**
     * 获取TCP连接状态
     *
     * @return  获取TCP连接状态
     */
    var connectStatus = false
    /**
     * 最大重连次数
     */
    var maxConnectTimes = Integer.MAX_VALUE
        private set
    private var reconnectNum = maxConnectTimes
    private var isNeedReconnect = true
    var isConnecting = false
        private set
    var reconnectIntervalTime: Long = 5000
        private set
    /**
     * 心跳间隔时间
     */
    var heartBeatInterval: Long = 5
        private set//单位秒
    /**
     * 是否发送心跳
     */
    var isSendheartBeat = false
        private set
    /**
     * 心跳数据，可以是String类型，也可以是byte[].
     */
    private var heartBeatData: Any? = null
    fun connect() {
        if (isConnecting) {
            return
        }
        val clientThread = object : Thread("Netty-Client") {
            override fun run() {
                super.run()
                isNeedReconnect = true
                reconnectNum = maxConnectTimes
                connectServer()
            }
        }
        clientThread.start()
    }
    private fun connectServer() {
        synchronized(this@NettyTcpClient) {
            var channelFuture: ChannelFuture?=null
            if (!connectStatus) {
                isConnecting = true
                group = NioEventLoopGroup()
                val bootstrap = Bootstrap().group(group)
                        .option(ChannelOption.TCP_NODELAY, true)//屏蔽Nagle算法试图
                        .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)
                        .channel(NioSocketChannel::class.java as Class<out Channel>?)
                        .handler(object : ChannelInitializer<SocketChannel>() {
                            @Throws(Exception::class)
                            public override fun initChannel(ch: SocketChannel) {
                                if (isSendheartBeat) {
                                    ch.pipeline().addLast("ping", IdleStateHandler(0, heartBeatInterval, 0, TimeUnit.SECONDS)) //5s未发送数据，回调userEventTriggered
                                }
                                ch.pipeline().addLast(StringEncoder(CharsetUtil.UTF_8))
                                ch.pipeline().addLast(StringDecoder(CharsetUtil.UTF_8))
                                ch.pipeline().addLast(LineBasedFrameDecoder(1024))//黏包处理,需要客户端、服务端配合
                                ch.pipeline().addLast(NettyClientHandler(listener, index, isSendheartBeat, heartBeatData))
                            }
                        })
                try {
                    channelFuture = bootstrap.connect(host, tcp_port).addListener {
                        if (it.isSuccess) {
                            Log.d(TAG, "连接成功")
                            reconnectNum = maxConnectTimes
                            connectStatus = true
                            channel = channelFuture?.channel()
                        } else {
                            Log.d(TAG, "连接失败")
                            connectStatus = false
                        }
                        isConnecting = false
                    }.sync()
                    // Wait until the connection is closed.
                    channelFuture.channel().closeFuture().sync()
                    Log.d(TAG, " 断开连接")
                } catch (e: Exception) {
                    e.printStackTrace()
                } finally {
                    connectStatus = false
                    listener.onClientStatusConnectChanged(ConnectState.STATUS_CONNECT_CLOSED, index)
                    if (channelFuture != null) {
                        if (channelFuture.channel() != null && channelFuture.channel().isOpen) {
                            channelFuture.channel().close()
                        }
                    }
                    group.shutdownGracefully()
                    reconnect()
                }
            }
        }
    }
    fun disconnect() {
        Log.d(TAG, "disconnect")
        isNeedReconnect = false
        group.shutdownGracefully()
    }
    fun reconnect() {
        Log.d(TAG, "reconnect")
        if (isNeedReconnect && reconnectNum > 0 && !connectStatus) {
            reconnectNum--
            SystemClock.sleep(reconnectIntervalTime)
            if (isNeedReconnect && reconnectNum > 0 && !connectStatus) {
                Log.e(TAG, "重新连接")
                connectServer()
            }
        }
    }
    /**
     * 异步发送
     *
     * @param data 要发送的数据
     * @param listener 发送结果回调
     * @return 方法执行结果
     */
    fun sendMsgToServer(data: String, listener: MessageStateListener) = channel?.run {
        val flag = this != null && connectStatus
        if (flag) {
            this.writeAndFlush(data + System.getProperty("line.separator")).addListener { channelFuture -> listener.isSendSuccss(channelFuture.isSuccess) }
        }
        flag
    } ?: false
    /**
     * 同步发送
     *
     * @param data 要发送的数据
     * @return 方法执行结果
     */
    fun sendMsgToServer(data: String) = channel?.run {
        val flag = this != null && connectStatus
        if (flag) {
            val channelFuture = this.writeAndFlush(data + System.getProperty("line.separator")).awaitUninterruptibly()
            return channelFuture.isSuccess
        }
        false
    }?:false
    fun setListener(listener: NettyClientListener<String>) {
        this.listener = listener
    }
    /**
     * Builder 模式创建NettyTcpClient
     */
    class Builder {
        /**
         * 最大重连次数
         */
        private var MAX_CONNECT_TIMES = Integer.MAX_VALUE
        /**
         * 重连间隔
         */
        private var reconnectIntervalTime: Long = 5000
        /**
         * 服务器地址
         */
        private var host: String? = null
        /**
         * 服务器端口
         */
        private var tcp_port: Int = 0
        /**
         * 客户端标识，(因为可能存在多个连接)
         */
        private var mIndex: Int = 0
        /**
         * 是否发送心跳
         */
        private var isSendheartBeat: Boolean = false
        /**
         * 心跳时间间隔
         */
        private var heartBeatInterval: Long = 5
        /**
         * 心跳数据，可以是String类型，也可以是byte[].
         */
        private var heartBeatData: Any? = null
        fun setMaxReconnectTimes(reConnectTimes: Int): Builder {
            this.MAX_CONNECT_TIMES = reConnectTimes
            return this
        }
        fun setReconnectIntervalTime(reconnectIntervalTime: Long): Builder {
            this.reconnectIntervalTime = reconnectIntervalTime
            return this
        }
        fun setHost(host: String): Builder {
            this.host = host
            return this
        }
        fun setTcpPort(tcp_port: Int): Builder {
            this.tcp_port = tcp_port
            return this
        }
        fun setIndex(mIndex: Int): Builder {
            this.mIndex = mIndex
            return this
        }
        fun setHeartBeatInterval(intervalTime: Long): Builder {
            this.heartBeatInterval = intervalTime
            return this
        }
        fun setSendheartBeat(isSendheartBeat: Boolean): Builder {
            this.isSendheartBeat = isSendheartBeat
            return this
        }
        fun setHeartBeatData(heartBeatData: Any): Builder {
            this.heartBeatData = heartBeatData
            return this
        }
        fun build(): NettyTcpClient {
            val nettyTcpClient = NettyTcpClient(host!!, tcp_port, mIndex)
            nettyTcpClient.maxConnectTimes = this.MAX_CONNECT_TIMES
            nettyTcpClient.reconnectIntervalTime = this.reconnectIntervalTime
            nettyTcpClient.heartBeatInterval = this.heartBeatInterval
            nettyTcpClient.isSendheartBeat = this.isSendheartBeat
            nettyTcpClient.heartBeatData = this.heartBeatData
            return nettyTcpClient
        }
    }
    companion object {
        private val TAG = "NettyTcpClient"
        private val CONNECT_TIMEOUT_MILLIS = 5000
    }
}


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


NettyClientHandler：


class NettyClientHandler(private val listener: NettyClientListener<String>, private val index: Int, private val isSendheartBeat: Boolean, private val heartBeatData: Any?) : SimpleChannelInboundHandler<String>() {
    /**
     *
     * 设定IdleStateHandler心跳检测每x秒进行一次读检测，
     * 如果x秒内ChannelRead()方法未被调用则触发一次userEventTrigger()方法
     *
     * @param ctx ChannelHandlerContext
     * @param evt IdleStateEvent
     */
    override fun userEventTriggered(ctx: ChannelHandlerContext, evt: Any) {
        if (evt is IdleStateEvent) {
            if (evt.state() == IdleState.WRITER_IDLE) {   //发送心跳
                if (isSendheartBeat) {
                    if (heartBeatData == null) {
                        ctx.channel().writeAndFlush("Heartbeat" + System.getProperty("line.separator")!!)
                    } else {
                        if (heartBeatData is String) {
                            Log.d(TAG, "userEventTriggered: String")
                            ctx.channel().writeAndFlush(heartBeatData + System.getProperty("line.separator")!!)
                        } else if (heartBeatData is ByteArray) {
                            Log.d(TAG, "userEventTriggered: byte")
                            val buf = Unpooled.copiedBuffer((heartBeatData as ByteArray?)!!)
                            ctx.channel().writeAndFlush(buf)
                        } else {
                            Log.d(TAG, "userEventTriggered: heartBeatData type error")
                        }
                    }
                } else {
                    Log.d(TAG, "不发送心跳")
                }
            }
        }
    }
    /**
     *
     * 客户端上线
     *
     * @param ctx ChannelHandlerContext
     */
    override fun channelActive(ctx: ChannelHandlerContext) {
        Log.d(TAG, "channelActive")
        listener.onClientStatusConnectChanged(ConnectState.STATUS_CONNECT_SUCCESS, index)
    }
    /**
     *
     * 客户端下线
     *
     * @param ctx ChannelHandlerContext
     */
    override fun channelInactive(ctx: ChannelHandlerContext) {
        Log.d(TAG, "channelInactive")
    }
    /**
     * 客户端收到消息
     *
     * @param channelHandlerContext ChannelHandlerContext
     * @param msg                   消息
     */
    override fun channelRead0(channelHandlerContext: ChannelHandlerContext, msg: String) {
        Log.d(TAG, "channelRead0:")
        listener.onMessageResponseClient(msg, index)
    }
    /**
     * @param ctx   ChannelHandlerContext
     * @param cause 异常
     */
    override fun exceptionCaught(ctx: ChannelHandlerContext, cause: Throwable) {
        Log.e(TAG, "exceptionCaught")
        listener.onClientStatusConnectChanged(ConnectState.STATUS_CONNECT_ERROR, index)
        cause.printStackTrace()
        ctx.close()
    }
    companion object {
        private val TAG = "NettyClientHandler"
    }
}


三. Demo 的实现


3.1 Socket 服务端


启动 NettyServer：


private fun startServer() {
        if (!NettyServer.isServerStart) {
            NettyServer.setListener(this@MainActivity)
            NettyServer.port = port
            NettyServer.webSocketPath = webSocketPath
            NettyServer.start()
        } else {
            NettyServer.disconnect()
        }
    }


NettyServer 异步发送 TCP 消息：


NettyServer.sendMsgToClient(msg, ChannelFutureListener { channelFuture ->
        if (channelFuture.isSuccess) {
            msgSend(msg)
      } 
})


NettyServer 异步发送 WebSocket 消息：


NettyServer.sendMsgToWS(msg, ChannelFutureListener { channelFuture ->
        if (channelFuture.isSuccess) {
              msgSend(msg)
      } 
 })


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


image.png

NettyServer1.png


3.2 Socket 客户端


NettyTcpClient 通过 Builder 模式创建：


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


启动、关闭客户端连接：


private fun connect() {
        Log.d(TAG, "connect")
        if (!mNettyTcpClient.connectStatus) {
            mNettyTcpClient.connect()//连接服务器
        } else {
            mNettyTcpClient.disconnect()
        }
    }


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


mNettyTcpClient.sendMsgToServer(msg, object : MessageStateListener {
         override fun isSendSuccss(isSuccess: Boolean) {
                if (isSuccess) {
                   msgSend(msg)
               } 
         }
})


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

image.png

NettyTcpClientpng.png


image.png

NettyServer2.png


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


Netty Server 端跟网页通信：


image.png

NettyServer3.png


WebSocket在线测试：


image.png

websocket_test.png


四. 总结


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

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


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

文章标签：
云数据库 ClickHouse
Android开发
网络协议
数据格式
JSON
Kotlin
关键词：
Android Kotlin
Netty服务端
Kotlin Android
Android服务端
socket服务端
fengzhizi715
目录
相关文章
nanshaws
|
4月前
|
网络协议 前端开发
netty的TCP服务端和客户端实现
本文介绍了使用Netty框架实现TCP服务端和客户端的步骤，包括添加Netty依赖、编写服务端和客户端的代码，涉及NioEventLoopGroup、ServerBootstrap、Bootstrap、ChannelInitializer等核心组件，以及如何启动服务端监听和客户端连接。
nanshaws
331 4
1176112968452250
|
5月前
|
存储 机器人 Linux
Netty(二)-服务端网络编程常见网络IO模型讲解
Netty(二)-服务端网络编程常见网络IO模型讲解
1176112968452250
53 2
土木林森
|
5月前
|
Android开发 开发者 Kotlin
告别AsyncTask：一招教你用Kotlin协程重构Android应用，流畅度飙升的秘密武器
【9月更文挑战第13天】随着Android应用复杂度的增加，有效管理异步任务成为关键。Kotlin协程提供了一种优雅的并发操作处理方式，使异步编程更简单直观。本文通过具体示例介绍如何使用Kotlin协程优化Android应用性能，包括网络数据加载和UI更新。首先需在`build.gradle`中添加coroutines依赖。接着，通过定义挂起函数执行网络请求，并在`ViewModel`中使用`viewModelScope`启动协程，结合`Dispatchers.Main`更新UI，避免内存泄漏。使用协程不仅简化代码，还提升了程序健壮性。
土木林森
179 1
东方睿赢
|
6月前
|
调度 Android开发 开发者
【颠覆传统！】Kotlin协程魔法：解锁Android应用极速体验，带你领略多线程优化的无限魅力！
【8月更文挑战第12天】多线程对现代Android应用至关重要，能显著提升性能与体验。本文探讨Kotlin中的高效多线程实践。首先，理解主线程（UI线程）的角色，避免阻塞它。Kotlin协程作为轻量级线程，简化异步编程。示例展示了如何使用`kotlinx.coroutines`库创建协程，执行后台任务而不影响UI。此外，通过协程与Retrofit结合，实现了网络数据的异步加载，并安全地更新UI。协程不仅提高代码可读性，还能确保程序高效运行，不阻塞主线程，是构建高性能Android应用的关键。
东方睿赢
86 4
Ant.Dream
|
7月前
|
安全 Android开发 Kotlin
Android经典面试题之Kotlin中常见作用域函数
**Kotlin作用域函数概览**: `let`, `run`, `with`, `apply`, `also`. `let`安全调用并返回结果; `run`在上下文中执行代码并返回结果; `with`执行代码块,返回结果; `apply`配置对象后返回自身; `also`附加操作后返回自身
Ant.Dream
75 8
请看我回答~
|
7月前
|
安全 Java Android开发
探索Android应用开发中的Kotlin语言
【7月更文挑战第19天】在移动应用开发的浩瀚宇宙中，Kotlin这颗新星以其简洁、安全与现代化的特性，正迅速在Android开发者之间获得青睐。从基本的语法结构到高级的编程技巧，本文将引导读者穿梭于Kotlin的世界，揭示其如何优化Android应用的开发流程并提升代码的可读性与维护性。我们将一起探究Kotlin的核心概念，包括它的数据类型、类和接口、可见性修饰符以及高阶函数等特性，并了解这些特性是如何在实际项目中得以应用的。无论你是刚入门的新手还是寻求进阶的开发者，这篇文章都将为你提供有价值的见解和实践指导。
请看我回答~
102 6
Ant.Dream
|
7月前
|
存储 前端开发 测试技术
Android Kotlin中使用 LiveData、ViewModel快速实现MVVM模式
使用Kotlin实现MVVM模式是Android开发的现代实践。该模式分离UI和业务逻辑，借助LiveData、ViewModel和DataBinding增强代码可维护性。步骤包括创建Model层处理数据，ViewModel层作为数据桥梁，以及View层展示UI。添加相关依赖后，Model类存储数据，ViewModel类通过LiveData管理变化，而View层使用DataBinding实时更新UI。这种架构提升代码可测试性和模块化。
Ant.Dream
250 2
Ant.Dream
|
7月前
|
SQL 安全 Java
Android经典面试题之Kotlin中object关键字实现的是什么类型的单例模式？原理是什么？怎么实现双重检验锁单例模式？
Kotlin 单例模式概览 在 Kotlin 中，`object` 关键字轻松实现单例，提供线程安全的“饿汉式”单例。例如： 要延迟初始化，可使用 `companion object` 和 `lazy` 委托： 对于参数化的线程安全单例，结合 `@Volatile` 和 `synchronized`
Ant.Dream
85 6
Ant.Dream
|
7月前
|
Android开发 Kotlin
Android经典面试题之Kotlin中Lambda表达式有哪些用法
Kotlin的Lambda表达式是匿名函数的简洁形式，常用于集合操作和高阶函数。基本语法是`{参数 -&gt; 表达式}`。例如，`{a, b -&gt; a + b}`是一个加法lambda。它们可在`map`、`filter`等函数中使用，也可作为参数传递。单参数时可使用`it`关键字，如`list.map { it * 2 }`。类型推断简化了类型声明。
Ant.Dream
52 0
Ant.Dream
|
7月前
|
Android开发 Kotlin
Android经典面试题之Kotlin中Lambda表达式和匿名函数的区别
**Kotlin中的匿名函数与Lambda表达式概述：** 匿名函数（`fun`关键字，明确返回类型，支持非局部返回）适合复杂逻辑，而Lambda（简洁语法，类型推断）常用于内联操作和高阶函数参数。两者在语法、返回类型和使用场景上有所区别，但都提供无名函数的能力。
Ant.Dream
51 0

热门文章

最新文章

  • 1
    如何修复 Android 和 Windows 不支持视频编解码器的问题？
  • 2
    Android历史版本与APK文件结构
  • 3
    【08】flutter完成屏幕适配-重建Android,增加GetX路由,屏幕适配,基础导航栏-多版本SDK以及gradle造成的关于fvm的使用（flutter version manage）-卓伊凡换人优雅草Alex-开发完整的社交APP-前端客户端开发+数据联调|以优雅草商业项目为例做开发-flutter开发-全流程-商业应用级实战开发-优雅草Alex
  • 4
    【04】flutter补打包流程的签名过程-APP安卓调试配置-结构化项目目录-完善注册相关页面-开发完整的社交APP-前端客户端开发+数据联调|以优雅草商业项目为例做开发-flutter开发-全流程
  • 5
    当flutter react native 等混开框架-并且用vscode-idea等编译器无法打包apk，打包安卓不成功怎么办-直接用android studio如何打包安卓apk -重要-优雅草卓伊凡
  • 6
    APP-国内主流安卓商店-应用市场-鸿蒙商店上架之必备前提·全国公安安全信息评估报告如何申请-需要安全评估报告的资料是哪些-优雅草卓伊凡全程操作
  • 7
    【09】flutter首页进行了完善-采用android studio 进行真机调试开发-增加了直播间列表和短视频人物列表-增加了用户中心-卓伊凡换人优雅草Alex-开发完整的社交APP-前端客户端开发+数据联调|以优雅草商业项目为例做开发-flutter开发-全流程-商业应用级实战开发-优雅草Alex
  • 8
    【03】仿站技术之python技术，看完学会再也不用去购买收费工具了-修改整体页面做好安卓下载发给客户-并且开始提交网站公安备案-作为APP下载落地页文娱产品一定要备案-包括安卓android下载（简单）-ios苹果plist下载（稍微麻烦一丢丢）-优雅草卓伊凡
  • 9
    【02】仿站技术之python技术，看完学会再也不用去购买收费工具了-本次找了小影-感觉页面很好看-本次是爬取vue需要用到Puppeteer库用node.js扒一个app下载落地页-包括安卓android下载（简单）-ios苹果plist下载（稍微麻烦一丢丢）-优雅草卓伊凡
  • 10
    Cellebrite UFED 4PC 7.71 (Windows) - Android 和 iOS 移动设备取证软件
  • 1
    Nettyの网络聊天室&扩展序列化算法
    50
  • 2
    Netty从入门到精通：高性能网络编程的进阶之路
    355
  • 3
    java nio，netty，kafka 中经常提到“零拷贝”到底是什么？
    92
  • 4
    Spring Boot结合Netty和WebSocket，实现后台向前端实时推送信息
    1055
  • 5
    Netty Pipeline详解！
    143
  • 6
    netty的TCP服务端和客户端实现
    331
  • 7
    使用Netty实现文件传输的HTTP服务器和客户端
    122
  • 8
    netty整合websocket（完美教程）
    464
  • 9
    redis的基本命令，并用netty操作redis（不使用springboot或者spring框架）就单纯的用netty搞。
    106
  • 10
    Netty 与硬件设备交互，下行命令时（服务对设备），如何等待设备响应，再进行业务操作解决方案
    150

    • 相关课程

    更多
  • 开源Android容器化框架Atlas开发者指南

    • 相关电子书

    更多
  • Android组件化实现
  • 蚂蚁聚宝Android秒级编译—— Freeline
  • Android插件化：从入门到放弃
    • 下一篇
    阿里云oss简介和如何对接使用