android netty 实例

原创

mob64ca12e5502a 2024-10-21 08:03:18 ©著作权

©著作权归作者所有：来自51CTO博客作者mob64ca12e5502a的原创作品，请联系作者获取转载授权，否则将追究法律责任

使用 Netty 实现 Android 网络通信实例

Netty 是一个用于快速开发可维护、高性能 Java 网络应用程序的异步事件驱动网络应用程序框架。在 Android 开发中，使用 Netty 作为网络通信框架可以简化网络请求的处理。本文将带你了解如何在 Android 中使用 Netty，并通过一个实例演示整个流程。

流程概览

我们将通过以下几步来完成 Android 中 Netty 实例的实现：

步骤	描述
1	添加依赖和配置项目
2	创建 Netty 服务端
3	创建 Netty 客户端
4	启动服务端和客户端
5	实现数据的发送与接收

1. 添加依赖和配置项目

在你的 build.gradle 文件中添加 Netty 依赖：

implementation 'io.netty:netty-all:4.1.68.Final'

说明：这一行代码添加了 Netty 的所有必要依赖。

2. 创建 Netty 服务端

接下来，我们将创建一个简单的 Netty 服务端来接收客户端发送的数据。

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class NettyServer {
    private final int port;

    public NettyServer(int port) {
        this.port = port;
    }

    public void run() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new StringDecoder());
                        ch.pipeline().addLast(new StringEncoder());
                        ch.pipeline().addLast(new ServerHandler()); // 自定义处理器
                    }
                });

            ChannelFuture f = b.bind(port).sync();
            f.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

说明：上述代码实现了一个简单的非阻塞 Netty 服务端，基本流程如下：

创建两个事件循环组：bossGroup 和 workerGroup。
设置服务端的通道。
添加字符串的编码和解码 Handler。
自定义处理器 ServerHandler 将会处理具体的业务逻辑。

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class ServerHandler extends SimpleChannelInboundHandler<String> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println("Received message: " + msg);
        ctx.writeAndFlush("Message received"); // 回复客户端
    }
}

说明：这个 ServerHandler 处理接收到的消息并向客户端返回确认信息。

3. 创建 Netty 客户端

下面，我们将创建一个简单的 Netty 客户端来向服务端发送数据。

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class NettyClient {
    private final String host;
    private final int port;

    public NettyClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void run() throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new StringDecoder());
                        ch.pipeline().addLast(new StringEncoder());
                        ch.pipeline().addLast(new ClientHandler()); // 自定义处理器
                    }
                });

            ChannelFuture f = b.connect(host, port).sync();
            f.channel().writeAndFlush("Hello from client!"); // 发送消息
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }
}

说明：客户端的实现逻辑与服务端类似，主要步骤包括：

创建一个 Bootstrap。
添加必要的编解码器。
发送一条消息到服务端。

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class ClientHandler extends SimpleChannelInboundHandler<String> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println("Server reply: " + msg); // 输出服务端回复信息
    }
}

4. 启动服务端和客户端

最后，我们需要在 Android 应用的主线程或子线程中启动服务端和客户端。

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        new Thread(() -> {
            try {
                new NettyServer(8080).run(); // 启动服务端
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                Thread.sleep(1000); // 确保服务端启动后再启动客户端
                new NettyClient("localhost", 8080).run(); // 启动客户端
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
    }
}

说明：在这个示例中，我们在主活动中使用独立线程来启动服务端和客户端。注意客户端启动时要确保服务端已完全启动。

5. 实现数据的发送与接收

现在，用户可以在客户端发送消息，服务端会处理并返回确认。

stateDiagram
    [*] --> NettyServer
    NettyServer --> ChannelOpen
    ChannelOpen --> channelRead0
    channelRead0 --> [*]
    NettyClient --> ChannelOpen
    ChannelOpen --> sendMsg
    sendMsg --> channelRead0

说明：状态图展示了 netty 服务端与客户端之间的状态转移。