在netty中使用CompletableFuture配合ScheduledExecutorService实现服务端主动给客户端发消息

最新推荐文章于 2025-03-18 16:05:16 发布

朴朴爱吃肉肉

最新推荐文章于 2025-03-18 16:05:16 发布

阅读量1.5k

点赞数 1

文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/weixin_57730366/article/details/131121989

版权

netty

Netty 是由 JBOSS 提供的一个 Java 开源框架。Netty 提供异步的、基于事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络 IO 程序,是目前最流行的 NIO 框架，Netty 在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，知名的 Elasticsearch 、Dubbo 框架内部都采用了 Netty。

CompletableFuture

CompletableFuture字面翻译过来，就是“可完成的Future”。同传统的Future相比较，CompletableFuture能够主动设置计算的结果值（主动终结计算过程，即completable），从而在某些场景下主动结束阻塞等待。而Future由于不能主动设置计算结果值，一旦调用get()进行阻塞等待，要么当计算结果产生，要么超时，才会返回。

ScheduledExecutorService

ScheduledExecutorService有线程池的特性，也可以实现任务循环执行，可以看作是一个简单地定时任务组件，因为有线程池特性，所以任务之间可以多线程并发执行，互不影响，当任务来的时候，才会真正创建线程去执行。我们在做一些普通定时循环任务时可以用它，比如定时刷新字典常量，只需要不断重复执行即可

创建netty客户端

@Slf4j
@Component
public class NettyServer {

    @Value("${netty.server.port}") // 从配置文件中读取服务器端口号
    private int serverPort;

    private EventLoopGroup bossGroup;
    private EventLoopGroup workerGroup;
    private Channel serverChannel;

    @PostConstruct
    public void start() throws Exception {
        bossGroup = new NioEventLoopGroup();
        workerGroup = new NioEventLoopGroup();

        ServerBootstrap serverBootstrap = new ServerBootstrap();
        serverBootstrap.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<Channel>() {
                    @Override
                    protected void initChannel(Channel ch) {
                        log.info("连接成功");
                        ch.pipeline().addLast(new ServerHandler());
                    }
                })
                .option(ChannelOption.SO_BACKLOG, 128)
                .childOption(ChannelOption.SO_KEEPALIVE, true);

        ChannelFuture channelFuture = serverBootstrap.bind(serverPort).sync();
        serverChannel = channelFuture.channel();

        System.out.println("Netty server started and listening on port " + serverPort);
    }

    @PreDestroy
    public void stop() throws Exception {
        serverChannel.close();
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}

创建发消息方法

String requestId = "111";
        CompletableFuture<String> future = new CompletableFuture<>();

        requestMap.put(requestId, future);

        //获取远程地址渠道
        String next = cache.getIfPresent("4567");
        Channel cloudChannel = clientChannels. get(next);
        if (cloudChannel == null) {
            ByteBuf buffer = Unpooled.copiedBuffer("发送失败".getBytes());
            cloudChannel.writeAndFlush(buffer);
        } else {
            cloudChannel.writeAndFlush(message);
            // 设置超时处理逻辑
            ScheduledExecutorService scheduledExecutor = Executors.newSingleThreadScheduledExecutor();
            scheduledExecutor.schedule(() -> {
                CompletableFuture<String> pendingFuture = requestMap.remove(requestId);
                if (pendingFuture != null && !pendingFuture.isDone()) {
                    pendingFuture.complete("操作成功");
                }
            }, 2000, TimeUnit.MILLISECONDS);
            scheduledExecutor.shutdown();
        }

此处调用的CompletableFuture会临时存储到map中，知道发送的客户端回复消息后，netty的server端再从回消息的方法中获得这个消息返回CompletableFuture，而这个new CompletableFuture就会获得回复的消息，通过get获取，为防止异步阻塞，采用ScheduledExecutorService实现异步超时处理，如果2秒内未收到回复消息，则出超时处理

在出发消息等待的时候由于netty框架是基于nio的位阻塞管道，防止异步发消息和收消息的对象不同，可在发消息的方法上加锁。

public void channelRead0(ChannelHandlerContext ctx, Object msg) {
        String requestId = "111";
        // 读取客户端发送的消息
        ByteBuf byteBuf = (ByteBuf) msg;
        byte[] bytes = new byte[byteBuf.readableBytes()];
        byteBuf.readBytes(bytes);
        String message = new String(bytes);
        String encode = CodeUtils.encode(bytes);

        String enumMessage = NettyEnum.getMessageByCmd(encode);
        if (enumMessage != null) {
//            String message = getMessage(byteBuf);
            CompletableFuture<String> future = requestMap.get(requestId);
            if (future != null) {
                future.complete(enumMessage);
                requestMap.remove(requestId);
            }
        }
        if (encode != null){
            CompletableFuture<String> future = requestMap.get(requestId);
            if (future != null) {
                future.complete(encode);
                requestMap.remove(requestId);
            }
        }



    }

接下来是netty做消息处理的完整代码

package com.rui.online.netty;

import cn.hutool.core.lang.UUID;
import com.rui.online.service.ICommandService;
import com.rui.online.utils.CodeUtils;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import lombok.Synchronized;
import lombok.extern.slf4j.Slf4j;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Map;
import java.util.concurrent.*;
import java.util.concurrent.locks.ReentrantLock;


@Slf4j
@Service
public class ServerHandler extends SimpleChannelInboundHandler {

    private static Cache<String, String> cache;
    private static Map<String, Channel> clientChannels = new ConcurrentHashMap<>();
    private static Map<String, CompletableFuture<String>> requestMap = new ConcurrentHashMap<>();
    private static ReentrantLock lock = new ReentrantLock();

    static {
        cache = Caffeine.newBuilder()
//                .expireAfterWrite(5000, TimeUnit.MINUTES)  // 设置缓存过期时间为5分钟
                .maximumSize(100)  // 设置最大缓存条目数
                .build();
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        Channel clientChannel = ctx.channel();
        String remoteAddress = clientChannel.remoteAddress().toString();
        String substring = remoteAddress.substring(0,remoteAddress.lastIndexOf(":"));
        if (substring.equals("/10.168.1.105")){
            cache.put("4567", remoteAddress);
            clientChannels.put(remoteAddress, clientChannel);
        }
        cache.put("1234", remoteAddress);
        clientChannels.put(remoteAddress, clientChannel);

    }


    @Override
    public void channelRead0(ChannelHandlerContext ctx, Object msg) {
        String requestId = "111";
        // 读取客户端发送的消息
        ByteBuf byteBuf = (ByteBuf) msg;
        byte[] bytes = new byte[byteBuf.readableBytes()];
        byteBuf.readBytes(bytes);
        String message = new String(bytes);
        String encode = CodeUtils.encode(bytes);

        String enumMessage = NettyEnum.getMessageByCmd(encode);
        if (enumMessage != null) {
//            String message = getMessage(byteBuf);
            CompletableFuture<String> future = requestMap.get(requestId);
            if (future != null) {
                future.complete(enumMessage);
                requestMap.remove(requestId);
            }
        }
        if (encode != null){
            CompletableFuture<String> future = requestMap.get(requestId);
            if (future != null) {
                future.complete(encode);
                requestMap.remove(requestId);
            }
        }



    }

    /**
     * 给云端发信息
     *
     * @param
     */
    public CompletableFuture<String> sentMessage(ByteBuf message) {

        lock.lock();


        String requestId = "111";
        CompletableFuture<String> future = new CompletableFuture<>();

        requestMap.put(requestId, future);

        //获取远程地址渠道
        String next = cache.getIfPresent("4567");
        Channel cloudChannel = clientChannels. get(next);
        if (cloudChannel == null) {
            ByteBuf buffer = Unpooled.copiedBuffer("发送失败".getBytes());
            cloudChannel.writeAndFlush(buffer);
        } else {
            cloudChannel.writeAndFlush(message);
            // 设置超时处理逻辑
            ScheduledExecutorService scheduledExecutor = Executors.newSingleThreadScheduledExecutor();
            scheduledExecutor.schedule(() -> {
                CompletableFuture<String> pendingFuture = requestMap.remove(requestId);
                if (pendingFuture != null && !pendingFuture.isDone()) {
                    pendingFuture.complete("操作成功");
                }
            }, 2000, TimeUnit.MILLISECONDS);
            scheduledExecutor.shutdown();
        }

        lock.unlock();

        return future;
    }

    /**
     * 读取客户端和云端发送的消息
     *
     * @param byteBuf
     * @return
     */
    private String getMessage(ByteBuf byteBuf) {
        byte[] bytes = new byte[byteBuf.readableBytes()];
        byteBuf.readBytes(bytes);
        String message = new String(bytes);
        String encode = CodeUtils.encode(bytes);
        byte[] decode = CodeUtils.decode(encode);
        //输出接收到的数据
        log.info("十六制：" + encode);
        log.info("十进制：" + decode);
        log.info("ASCII：" + message);
        return message;
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
        ctx.flush(); // 刷新缓冲区，确保所有响应都被发送
    }

    /**
     * netty正常关闭时执行方法
     *
     * @param ctx
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        Channel clientChannel = ctx.channel();
        clientChannels.remove(clientChannel.remoteAddress().toString());
    }

    /**
     * netty异常时执行
     *
     * @param ctx
     * @param cause
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}

在services中调用发消息方法并获取回复消息

        CompletableFuture<String> future = serverHandler.sentMessage(byteBuf);
        try {
            String replyMessage = future.get();
            // 处理回复消息
            if (!replyMessage.equals(null)) {
                log.info("Received reply message: " + replyMessage);
                return Response.ok("成功", replyMessage);
            } else {
                return Response.ok("成功", "操作成功");
            }
        } catch (InterruptedException | ExecutionException e) {
            // 处理异常情况
            e.printStackTrace();
            return Response.fail("失败");
        }