HarmonyOS 设计一个简单的群聊App，后端应该如何实现？原创

码农参上

发布于 2022-2-17 11:03

浏览

2收藏

先思考一个问题，如果让我们自己设计一个可以群聊的App，不使用各种即时通讯的IM框架，你会如何实现通信的过程呢？

这里先说下思路，我们可以选择高性能的网络传输框架Netty，它作为基础通信组件被各种RPC框架广泛使用，例如在Hadoop的Avro组件和Dubbo中在底层都使用了Netty。下面我们就看看如何基于Netty，实现一个群聊App，代码分别从服务端和客户端两方面介绍。

服务端代码

Server

在Netty的服务端，我们需要定义BossEventLoopGroup和WorkerEventLoopGroup两个EventLoopGroup进行工作，它们是一组EventLoop的抽象，可以从一组EventLoop里面按照一定规则获取其中一个EventLoop来处理任务。

在下面的代码中，启动服务端时创建两个EventLoopGroup事件循环线程组，bossGroup专门负责接收客户端的连接，workerGroup维护的Selector并对其后续的I/O事件进行处理，专门负责网络的读写。之后使用ServerBootstrap服务端启动引导类配置整个Netty程序，串联各个组件进行启动。

在创建Server端时，我们在ChannelPipeline中添加了Netty自带的String类型的编码器与解码器，最后添加我们的业务逻辑处理的handler。

public class GroupChatServer {
    private int port;
    public GroupChatServer(int port) {
        this.port = port;
    }
    public void run() {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast("decoder", new StringDecoder());
                            pipeline.addLast("encoder", new StringEncoder());
                            pipeline.addLast(new GroupChatServerHandler());
                        }
                    });
            System.out.println("NETTY SERVER IS READY");
            ChannelFuture channelFuture = bootstrap.bind(port).sync();
            channelFuture.channel().closeFuture().sync();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.

总结一下，在服务端启动时核心逻辑为：

获取管道pipeline
向pipeline中加入解码器和编码器
加入业务处理器handler

到这服务端我们就已经写完了，再开始写客户端。

Handler

接下来，我们要先创建一个服务端的handler，用于处理业务逻辑。具体的业务处理就在这里面进行定义，新建一个类继承SimpleChannelInboundHandler类，处理接收的消息：

public class GroupChatServerHandler extends SimpleChannelInboundHandler<String> {
    private static ChannelGroup channelGroup=new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
    ...
}
1.
2.
3.
4.

首先定义一个ChannelGroup 组，管理所有channel。GlobalEventExecutor.INSTANCE 表示是全局的事件执行器，是一个单例模式。

下面我们看一下需要重写的几个核心方法：

handlerAdded

handlerAdded 表示连接建立，一旦连接将被第一个被执行。在该方法中，将当前channel加入到channelGroup。并将该客户加入聊天的信息推送给其他在线的客户端，这里遍历channelGroup中所有channel，并发送消息。

@Override
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
    Channel channel = ctx.channel();
    channelGroup.writeAndFlush("[客户端]"+channel.remoteAddress()+"加入聊天"+sdf.format(new Date())+"\n");
    channelGroup.add(channel);
}
1.
2.
3.
4.
5.
6.

handlerRemoved

断开连接会触发handlerRemoved方法。在该方法中，将下线消息推送给当前在线的客户。

@Override
public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
    Channel channel = ctx.channel();
    channelGroup.writeAndFlush("[客户端]"+channel.remoteAddress()+"离开了\n");
    System.out.println("channelGroup size:"+channelGroup.size());
}
1.
2.
3.
4.
5.
6.

需要注意，执行了当前方法时就相当于已经执行了：

channelGroup.remove(channel);
1.

这里会自动执行remove方法，所以就不需要我们再额外手动调用remove方法了。

channelActive & channelInactive

channelActive方法和channelInactive方法表示channel处于活动状态或不活动状态，这里仅打印上下线信息即可。

@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
    System.out.println(ctx.channel().remoteAddress()+" 上线了");
}

@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
    System.out.println(ctx.channel().remoteAddress()+" 离线了");
}
1.
2.
3.
4.
5.
6.
7.
8.
9.

channelRead0

channelRead0()是读取数据方法，用于接收客户端发送的信息。

@Override
protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
    Channel channel = ctx.channel();
    channelGroup.forEach(ch->{
        if(channel!=ch){
            ch.writeAndFlush("[客户]"+channel.remoteAddress()+" 发送了消息:"+msg+"\n");
        }else{显示自己发送的信息
            ch.writeAndFlush("[自己]发送了消息:"+msg+"\n");
        }
    });
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

在该方法中，会遍历channelGroup，根据不同情况，我们需要发送不同的消息：

如果不是当前的channel，那么显示其他客户端发送了消息
如果是当前的channel，显示自己发送了信息

exceptionCaught

最后，在发生异常时执行exceptionCaught方法，只要关闭ChannelHandlerContext 就好了。

@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
    ctx.close();
}
1.
2.
3.
4.

客户端代码

Client

和服务端比起来，客户端的设计就简单多了，客户端不再需要两个EventLoopGroup，只需要一个就可以了。详细代码如下，其中获取管道、向管道加入编码解码器和设置业务处理器handler的过程与服务端基本相同。

public class GroupChatClient {
    private final String host;
    private final int port;
    public GroupChatClient(String host, int port) {
        this.host = host;
        this.port = port;
    }
    public void run(){
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
        try{
            Bootstrap bootstrap = new Bootstrap()
                    .group(eventLoopGroup)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast("decoder", new StringDecoder());
                            pipeline.addLast("encoder", new StringEncoder());
                            pipeline.addLast(new GroupChatClientHandler());
                        }
                    });
            System.out.println("NETTY CLIENT IS READY");
            ChannelFuture channelFuture = bootstrap.connect(host, port).sync();
            Channel channel = channelFuture.channel();
            System.out.println("----"+channel.localAddress()+"---");

            Scanner scanner=new Scanner(System.in);
            while (scanner.hasNext()){
                String msg = scanner.nextLine();
                channel.writeAndFlush(msg+"\r\n");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            eventLoopGroup.shutdownGracefully();
        }
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.

注意，客户端与服务端明显不同的是，客户端需要输入发送给别人的信息，因此创建一个扫描器，接收来自键盘的输入。

Handler

接下来定义一个客户端业务处理器，同样继承SimpleChannelInboundHandler：

public class GroupChatClientHandler extends SimpleChannelInboundHandler<String> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println(msg.trim());
    }
}
1.
2.
3.
4.
5.
6.