AI 助理
备案控制台
开发者社区 数据库 文章 正文

netty案例，netty4.1中级拓展篇九《Netty集群部署实现跨服务端通信的落地方案》

2022-01-12 474
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
Redis 开源版，标准版 2GB
推荐场景：
搭建游戏排行榜
云数据库 Tair（兼容Redis），内存型 2GB
推荐场景：
通过缓存加速数据库访问
简介： netty案例，netty4.1中级拓展篇九《Netty集群部署实现跨服务端通信的落地方案》


15.jpg

16.jpg

前言介绍

Netty的性能非常好，在一些小型用户体量的socket服务内，仅部署单台机器就可以满足业务需求。但当遇到一些中大型用户体量的服务时，就需要考虑讲Netty按照集群方式部署，以更好的满足业务诉求。但Netty部署集群后都会遇到跨服务端怎么通信，也就是有集群服务X和Y，用户A链接服务X，用户B链接服务Y，那么他们都不在一个服务内怎么通信？本章节将介绍一种实现方式案例，以满足跨服务之间的用户通信。但实际场景中需要进行一些扩展性改造，案例仅将核心主干思路做以实现，只是一种思路指导，并不能直接使用于业务开发。

本章知识点

  • 跨服务之间案例采用redis的发布和订阅进行传递消息，如果你是大型服务可以使用zookeeper
  • 用户A在发送消息给用户B时候，需要传递B的channeId，以用于服务端进行查找channeId所属是否自己的服务内
  • 单台机器也可以启动多个Netty服务，程序内会自动寻找可用端口

环境准备

1、jdk1.8【jdk1.7以下只能部分支持netty】

2、Netty4.1.36.Final【netty3.x 4.x 5每次的变化较大，接口类名也随着变化】

3、NetAssist 网络调试助手，可以从网上下载也可以联系我，微信公众号：bugstack虫洞栈 | 关注回复你的邮箱

4、redis服务端，案例采用windows版本，按需从官网下载即可

代码示例

itstack-demo-rpc-2-09
└── src
    └── main
    │   ├── java
    │   │   └── org.itstack.demo.netty
    │   │        ├── domain
    │   │        │   ├── EasyResult.java
    │   │        │   ├── MsgAgreement.java
    │   │        │   ├── ServerInfo.java
    │   │        │   └── UserChannelInfo.java
    │   │        ├── redis
    │   │        │   ├── config
    │   │        │   │   ├── PublisherConfig.java
    │   │        │   │   └── ReceiverConfig.java
    │   │        │   ├── AbstractReceiver.java
    │   │        │   ├── MsgAgreementReceiver.java
    │   │        │   ├── Publisher.java
    │   │        │   └── RedisUtil.java
    │   │        ├── server
    │   │        │   ├── MyChannelInitializer.java
    │   │        │   ├── MyServerHandler.java
    │   │        │   └── NettyServer.java
    │   │        ├── service
    │   │        │   └── ExtServerService.java
    │   │        ├── util
    │   │        │   ├── CacheUtil.java
    │   │        │   ├── MsgUtil.java
    │   │        │   └── NetUtil.java
    │   │        ├── web
    │   │        │    └── NettyController.java
    │   │        └── Application.java
    │   ├── resources
    │   │   └── application.yml
    │   └── webapp
    │       ├── res
    │       └── WEB-INF
    │           └── index.jsp
    └── test
         └── java
             └── org.itstack.demo.test
                 └── ApiTest.java

演示讲解部分重点代码块，完整代码下载，关注公众号；bugstack虫洞栈 | 回复：netty案例源码

domain/MsgAgreement.java | 定义信息传输协议，这个看似简单但非常重要，每一个通信的根本就是定义传输协议信息

/**
 * 消息协议
 * 虫洞栈：https://bugstack.cn
 * 公众号：bugstack虫洞栈  ｛关注获取学习源码｝
 * 虫洞群：①群5398358 ②群5360692
 * Create by fuzhengwei on 2019
 */
public class MsgAgreement {
    private String toChannelId; //发送给某人，某人channelId
    private String content;     //消息内容
    public MsgAgreement() {
    }
    public MsgAgreement(String toChannelId, String content) {
        this.toChannelId = toChannelId;
        this.content = content;
    }
    public String getToChannelId() {
        return toChannelId;
    }
    public void setToChannelId(String toChannelId) {
        this.toChannelId = toChannelId;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
}

redis/config/PublisherConfig.java | redis消息发布者，集成与SpringBoot的配置方式

/**
 * 发布者
 * 虫洞栈：https://bugstack.cn
 * 公众号：bugstack虫洞栈  ｛获取学习源码｝
 * 虫洞群：①群5398358 ②群5360692
 * Create by fuzhengwei on @2019
 */
@Configuration
public class PublisherConfig {
    @Bean
    public RedisTemplate<String, Object> redisMessageTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        template.setDefaultSerializer(new FastJsonRedisSerializer<>(Object.class));
        return template;
    }
}

redis/config/ReceiverConfig.java | redis消息的订阅者，集成与SpringBoot的配置方式。可以订阅多个主题，本章节只订阅一个。

/**
 * 订阅者
 * 虫洞栈：https://bugstack.cn
 * 公众号：bugstack虫洞栈  ｛获取学习源码｝
 * 虫洞群：①群5398358 ②群5360692
 * Create by fuzhengwei on @2019
 */
@Configuration
public class ReceiverConfig {
    @Bean
    public RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory, MessageListenerAdapter msgAgreementListenerAdapter) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.addMessageListener(msgAgreementListenerAdapter, new PatternTopic("itstack-demo-netty-push-msgAgreement"));
        return container;
    }
    @Bean
    public MessageListenerAdapter msgAgreementListenerAdapter(MsgAgreementReceiver receiver) {
        return new MessageListenerAdapter(receiver, "receiveMessage");
    }
}

redis/MsgAgreementReceiver.java | 实现抽象类用于接收订阅到的消息，接收消息后进行业务处理

/**
 * 虫洞栈：https://bugstack.cn
 * 公众号：bugstack虫洞栈  ｛获取学习源码｝
 * 虫洞群：①群5398358 ②群5360692
 * Create by fuzhengwei on @2019
 */
@Service
public class MsgAgreementReceiver extends AbstractReceiver {
    private Logger logger = LoggerFactory.getLogger(MsgAgreementReceiver.class);
    @Override
    public void receiveMessage(Object message) {
        logger.info("接收到PUSH消息：{}", message);
        MsgAgreement msgAgreement = JSON.parseObject(message.toString(), MsgAgreement.class);
        String toChannelId = msgAgreement.getToChannelId();
        Channel channel = CacheUtil.cacheChannel.get(toChannelId);
        if (null == channel) return;
        channel.writeAndFlush(MsgUtil.obj2Json(msgAgreement));
    }
}

redis/RedisUtil.java | redis操作工具类，帮助存储数据。以下是将链接到服务的用户信息存放到redis方便可以在每个服务端都能看到这份用户链接数据。

/**
 * 虫洞栈：https://bugstack.cn
 * 公众号：bugstack虫洞栈  ｛关注获取学习源码｝
 * Create by fuzhengwei on 2019
 */
@Service("redisUtil")
public class RedisUtil {
    @Autowired
    private StringRedisTemplate redisTemplate;
    public void pushObj(UserChannelInfo userChannelInfo) {
        redisTemplate.opsForHash().put("itstack-demo-netty-2-09-user", userChannelInfo.getChannelId(), JSON.toJSONString(userChannelInfo));
    }
    public List<UserChannelInfo> popList() {
        List<Object> values = redisTemplate.opsForHash().values("itstack-demo-netty-2-09-user");
        if (null == values) return new ArrayList<>();
        List<UserChannelInfo> userChannelInfoList = new ArrayList<>();
        for (Object strJson : values) {
            userChannelInfoList.add(JSON.parseObject(strJson.toString(), UserChannelInfo.class));
        }
        return userChannelInfoList;
    }
    public void remove(String channelId) {
        redisTemplate.opsForHash().delete("itstack-demo-netty-2-09-user",channelId);
    }
    public void clear(){
        redisTemplate.delete("itstack-demo-netty-2-09-user");
    }
}

server/MyServerHandler.java | 处理接收到的信息，尤其在channelRead中，将接受者不是本服务端的用户，进行全局push

/**
 * 虫洞栈：https://bugstack.cn
 * 公众号：bugstack虫洞栈  ｛关注获取学习源码｝
 * Create by fuzhengwei on 2019
 */
public class MyServerHandler extends ChannelInboundHandlerAdapter {
    private Logger logger = LoggerFactory.getLogger(MyServerHandler.class);
    private ExtServerService extServerService;
    public MyServerHandler(ExtServerService extServerService) {
        this.extServerService = extServerService;
    }
    /**
     * 当客户端主动链接服务端的链接后，这个通道就是活跃的了。也就是客户端与服务端建立了通信通道并且可以传输数据
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        SocketChannel channel = (SocketChannel) ctx.channel();
        System.out.println("链接报告开始");
        System.out.println("链接报告信息：有一客户端链接到本服务端。channelId：" + channel.id());
        System.out.println("链接报告IP:" + channel.localAddress().getHostString());
        System.out.println("链接报告Port:" + channel.localAddress().getPort());
        System.out.println("链接报告完毕");
        //保存用户信息
        UserChannelInfo userChannelInfo = new UserChannelInfo(channel.localAddress().getHostString(), channel.localAddress().getPort(), channel.id().toString(), new Date());
        extServerService.getRedisUtil().pushObj(userChannelInfo);
        CacheUtil.cacheChannel.put(channel.id().toString(), channel);
        //通知客户端链接建立成功
        String str = "通知客户端链接建立成功" + " " + new Date() + " " + channel.localAddress().getHostString() + "\r\n";
        ctx.writeAndFlush(MsgUtil.buildMsg(channel.id().toString(), str));
    }
    /**
     * 当客户端主动断开服务端的链接后，这个通道就是不活跃的。也就是说客户端与服务端的关闭了通信通道并且不可以传输数据
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("客户端断开链接" + ctx.channel().localAddress().toString());
        extServerService.getRedisUtil().remove(ctx.channel().id().toString());
        CacheUtil.cacheChannel.remove(ctx.channel().id().toString(), ctx.channel());
    }
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object objMsgJsonStr) throws Exception {
        //接收msg消息{与上一章节相比，此处已经不需要自己进行解码}
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + " 接收到消息内容：" + objMsgJsonStr);
        MsgAgreement msgAgreement = MsgUtil.json2Obj(objMsgJsonStr.toString());
        String toChannelId = msgAgreement.getToChannelId();
        //判断接收消息用户是否在本服务端
        Channel channel = CacheUtil.cacheChannel.get(toChannelId);
        if (null != channel) {
            channel.writeAndFlush(MsgUtil.obj2Json(msgAgreement));
            return;
        }
        //如果为NULL则接收消息的用户不在本服务端，需要push消息给全局
        logger.info("接收消息的用户不在本服务端，PUSH！");
        extServerService.push(msgAgreement);
    }
    /**
     * 抓住异常，当发生异常的时候，可以做一些相应的处理，比如打印日志、关闭链接
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
        extServerService.getRedisUtil().remove(ctx.channel().id().toString());
        CacheUtil.cacheChannel.remove(ctx.channel().id().toString(), ctx.channel());
        System.out.println("异常信息：\r\n" + cause.getMessage());
    }
}

util/CacheUtil.java | 缓存必要信息，用于业务流程处理

/**
 * 虫洞栈：https://bugstack.cn
 * 公众号：bugstack虫洞栈  ｛关注获取学习源码｝
 * 虫洞群：①群5398358 ②群5360692
 * Create by fuzhengwei on 2019
 */
public class CacheUtil {
    // 缓存channel
    public static Map<String, Channel> cacheChannel = Collections.synchronizedMap(new HashMap<String, Channel>());
    // 缓存服务信息
    public static Map<Integer, ServerInfo> serverInfoMap = Collections.synchronizedMap(new HashMap<Integer, ServerInfo>());
    // 缓存服务端
    public static Map<Integer, NettyServer> serverMap = Collections.synchronizedMap(new HashMap<Integer, NettyServer>());
}

web/NettyController.java | 接口处理控制类，方便我们操作服务端方法，包括启动Netty服务、获取用户信息等

/**
 * 虫洞栈：https://bugstack.cn
 * 公众号：bugstack虫洞栈  ｛获取学习源码｝
 * 虫洞群：①群5398358 ②群5360692
 * Create by fuzhengwei on @2019
 */
@Controller
public class NettyController {
    private Logger logger = LoggerFactory.getLogger(NettyController.class);
    //默认线程池
    private static ExecutorService executorService = Executors.newFixedThreadPool(2);
    @Value("${server.port}")
    private int serverPort;
    @Autowired
    private ExtServerService extServerService;
    @Resource
    private RedisUtil redisUtil;
    //Netty服务端
    private NettyServer nettyServer;
    @RequestMapping("/index")
    public String index(Model model) {
        model.addAttribute("serverPort", serverPort);
        return "index";
    }
    @RequestMapping("/openNettyServer")
    @ResponseBody
    public EasyResult openNettyServer() {
        try {
            int port = NetUtil.getPort();
            logger.info("启动Netty服务，获取可用端口：{}", port);
            nettyServer = new NettyServer(new InetSocketAddress(port), extServerService);
            Future<Channel> future = executorService.submit(nettyServer);
            Channel channel = future.get();
            if (null == channel) {
                throw new RuntimeException("netty server open error channel is null");
            }
            while (!channel.isActive()) {
                logger.info("启动Netty服务，循环等待启动...");
                Thread.sleep(500);
            }
            CacheUtil.serverInfoMap.put(port, new ServerInfo(NetUtil.getHost(), port, new Date()));
            CacheUtil.serverMap.put(port, nettyServer);
            logger.info("启动Netty服务，完成：{}", channel.localAddress());
            return EasyResult.buildSuccessResult();
        } catch (Exception e) {
            logger.error("启动Netty服务失败", e);
            return EasyResult.buildErrResult(e);
        }
    }
    @RequestMapping("/closeNettyServer")
    @ResponseBody
    public EasyResult closeNettyServer(int port) {
        try {
            logger.info("关闭Netty服务开始，端口：{}", port);
            NettyServer nettyServer = CacheUtil.serverMap.get(port);
            if (null == nettyServer) {
                CacheUtil.serverMap.remove(port);
                return EasyResult.buildSuccessResult();
            }
            nettyServer.destroy();
            CacheUtil.serverMap.remove(port);
            CacheUtil.serverInfoMap.remove(port);
            logger.info("关闭Netty服务完成，端口：{}", port);
            return EasyResult.buildSuccessResult();
        } catch (Exception e) {
            logger.error("关闭Netty服务失败，端口：{}", port, e);
            return EasyResult.buildErrResult(e);
        }
    }
    @RequestMapping("/queryNettyServerList")
    @ResponseBody
    public Collection<ServerInfo> queryNettyServerList() {
        try {
            Collection<ServerInfo> serverInfos = CacheUtil.serverInfoMap.values();
            logger.info("查询服务端列表。{}", JSON.toJSONString(serverInfos));
            return serverInfos;
        } catch (Exception e) {
            logger.info("查询服务端列表失败。", e);
            return null;
        }
    }
    @RequestMapping("/queryUserChannelInfoList")
    @ResponseBody
    public List<UserChannelInfo> queryUserChannelInfoList() {
        try {
            logger.info("查询用户列表信息开始");
            List<UserChannelInfo> userChannelInfoList = redisUtil.popList();
            logger.info("查询用户列表信息完成。list：{}", JSON.toJSONString(userChannelInfoList));
            return userChannelInfoList;
        } catch (Exception e) {
            logger.error("查询用户列表信息失败", e);
            return null;
        }
    }
}

resources/application.yml | 基础配置，在我们启动服务端的时候，如果只有一台机器模拟，那么需要改变server.port端口｛8080、8081｝

server:
  port: 8080
spring:
  mvc:
    view:
      prefix: /WEB-INF/
      suffix: .jsp
  redis:
    host: 127.0.0.1
    port: 6379

index.jap | 页面操作，控制和展示的一些内容

<%--
  虫洞栈：https://bugstack.cn
  公众号：bugstack虫洞栈  ｛获取学习源码｝
  Create by fuzhengwei on 2019
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<title>关注公众号：bugstack虫洞栈 | 专题案例开发，关注取源码 | bugstack.cn 付政委</title>
<meta charset="UTF-8">
<link rel="stylesheet" type="text/css" href="res/js/themes/default/easyui.css">
<link rel="stylesheet" type="text/css" href="res/js/themes/icon.css">
<script type="text/javascript" src="res/js/jquery.min.js"></script>
<script type="text/javascript" src="res/js/jquery.easyui.min.js"></script>
<style></style>
<script>
util = {
  formatDate: function (value, row, index) {
      if (null == value) return "";
      var date = new Date();
      date.setTime(value);
      return date.format('yyyy-MM-dd HH:mm:ss');
  }
};
</script>
</head>
<body>
    <div style="margin:20px 0;"></div>
    <table class="easyui-datagrid" title="localhost:${serverPort} | Netty服务端" style="width:700px;height:250px"
            data-options="rownumbers:true,singleSelect:true,url:'/queryNettyServerList',method:'get',toolbar:toolbar">
        <thead>
            <tr>
                <th data-options="field:'ip'">IP</th>
                <th data-options="field:'port'">端口</th>
                <th data-options="field:'openDate'">启动时间</th>
            </tr>
        </thead>
    </table>
    <script type="text/javascript">
        var toolbar = [{
            text:'启动',
            iconCls:'icon-open',
            handler:function(){
                $.post('/openNettyServer',{}, function (res) {
                               if (res.success) {
                                  $.messager.show({
                                        title: '消息提示',
                                        msg: '启动成功，请稍后刷新页面！'
                                  });
                                   $('#easyui-datagrid').datagrid('reload');
                               } else {
                                   $.messager.show({
                                       title: 'Error',
                                       msg: res.msg
                                   });
                               }
                            }, 'json');
            }
        },'-',{
            text:'关闭',
            iconCls:'icon-close',
            handler:function(){
                 //可以自己添加实现
            }
        }];
    </script>
    <hr/>
    <!-- server-user -->
    <table class="easyui-datagrid" title="localhost:${serverPort} | 用户链接信息" style="width:700px;height:250px"
                data-options="rownumbers:true,singleSelect:true,url:'/queryUserChannelInfoList',method:'get'">
            <thead>
                <tr>
                    <th data-options="field:'ip'">IP</th>
                    <th data-options="field:'port'">端口</th>
                    <th data-options="field:'channelId'">用户ID</th>
                    <th data-options="field:'linkDate'">链接时间</th>
                </tr>
            </thead>
    </table>
</body>
</html>

测试结果

启动Redis服务 | 案例中使用windwos版本

17.jpg

启动2次SpringBoot，模拟Netty集群[不同端口8080、8081] | Plugins/spring-boot/run 双击启动

2019-09-01 12:59:29.649  INFO 8952 --- [nio-8081-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring FrameworkServlet 'dispatcherServlet'
2019-09-01 12:59:29.649  INFO 8952 --- [nio-8081-exec-1] o.s.web.servlet.DispatcherServlet        : FrameworkServlet 'dispatcherServlet': initialization started
2019-09-01 12:59:29.681  INFO 8952 --- [nio-8081-exec-1] o.s.web.servlet.DispatcherServlet        : FrameworkServlet 'dispatcherServlet': initialization completed in 32 ms
2019-09-01 12:59:31.350  INFO 8952 --- [nio-8081-exec-2] o.i.demo.netty.web.NettyController       : 查询服务端列表。[]
2019-09-01 12:59:31.371  INFO 8952 --- [nio-8081-exec-3] o.i.demo.netty.web.NettyController       : 查询用户列表信息开始
2019-09-01 12:59:31.380  INFO 8952 --- [nio-8081-exec-3] o.i.demo.netty.web.NettyController       : 查询用户列表信息完成。list：[]
2019-09-01 13:04:22.864  INFO 8952 --- [nio-8081-exec-6] o.i.demo.netty.web.NettyController       : 启动Netty服务，获取可用端口：7398
2019-09-01 13:04:22.879  INFO 8952 --- [pool-1-thread-1] o.itstack.demo.netty.server.NettyServer  : itstack-demo-netty server start done. {关注公众号：bugstack虫洞栈，获取源码}
2019-09-01 13:04:22.880  INFO 8952 --- [nio-8081-exec-6] o.i.demo.netty.web.NettyController       : 启动Netty服务，完成：/0:0:0:0:0:0:0:0:7398
2019-09-01 13:04:23.612  INFO 8952 --- [nio-8081-exec-9] o.i.demo.netty.web.NettyController       : 查询服务端列表。[{"ip":"10.13.28.13","openDate":1567314262880,"port":7398}]
2019-09-01 13:04:23.634  INFO 8952 --- [io-8081-exec-10] o.i.demo.netty.web.NettyController       : 查询用户列表信息开始
2019-09-01 13:04:23.636  INFO 8952 --- [io-8081-exec-10] o.i.demo.netty.web.NettyController       : 查询用户列表信息完成。list：[]
链接报告开始
链接报告信息：有一客户端链接到本服务端。channelId：3a2d5cee
链接报告IP:10.13.28.13
链接报告Port:7398
链接报告完毕
2019-09-01 13:04:42.704  INFO 8952 --- [nio-8081-exec-2] o.i.demo.netty.web.NettyController       : 查询服务端列表。[{"ip":"10.13.28.13","openDate":1567314262880,"port":7398}]
2019-09-01 13:04:42.738  INFO 8952 --- [nio-8081-exec-3] o.i.demo.netty.web.NettyController       : 查询用户列表信息开始
2019-09-01 13:04:42.755  INFO 8952 --- [nio-8081-exec-3] o.i.demo.netty.web.NettyController       : 查询用户列表信息完成。list：[{"channelId":"39d45ff7","ip":"10.13.28.13","linkDate":1567314278944,"port":7397},{"channelId":"3a2d5cee","ip":"10.13.28.13","linkDate":1567314280442,"port":7398}]
2019-09-01 13:05:25.545  INFO 8952 --- [    container-2] o.i.d.netty.redis.MsgAgreementReceiver   : 接收到PUSH消息：{"content":"hi! I'm 微信公众号：bugstack虫洞栈 | 欢迎关注&获取源码。* 来自A服务端里用户向B服务端里用户发送信息。[结尾换行，用于处理半包粘包]","toChannelId":"3a2d5cee"}
2019-09-01 13:05:26.107  INFO 8952 --- [    container-3] o.i.d.netty.redis.MsgAgreementReceiver   : 接收到PUSH消息：{"content":"hi! I'm 微信公众号：bugstack虫洞栈 | 欢迎关注&获取源码。* 来自A服务端里用户向B服务端里用户发送信息。[结尾换行，用于处理半包粘包]","toChannelId":"3a2d5cee"}
2019-09-01 13:05:27.025  INFO 8952 --- [    container-4] o.i.d.netty.redis.MsgAgreementReceiver   : 接收到PUSH消息：{"content":"hi! I'm 微信公众号：bugstack虫洞栈 | 欢迎关注&获取源码。* 来自A服务端里用户向B服务端里用户发送信息。[结尾换行，用于处理半包粘包]","toChannelId":"3a2d5cee"}
2019-09-01 13:05:27.545  INFO 8952 --- [    container-5] o.i.d.netty.redis.MsgAgreementReceiver   : 接收到PUSH消息：{"content":"hi! I'm 微信公众号：bugstack虫洞栈 | 欢迎关注&获取源码。* 来自A服务端里用户向B服务端里用户发送信息。[结尾换行，用于处理半包粘包]","toChannelId":"3a2d5cee"}
2019-09-01 13:05:28.559  INFO 8952 --- [    container-6] o.i.d.netty.redis.MsgAgreementReceiver   : 接收到PUSH消息：{"content":"hi! I'm 微信公众号：bugstack虫洞栈 | 欢迎关注&获取源码。* 来自A服务端里用户向B服务端里用户发送信息。[结尾换行，用于处理半包粘包]","toChannelId":"3a2d5cee"}

启动2个以上的NetAssist分别链接到不同的服务端，以模拟测试跨服务通信，最后在客户端发送消息传递给另外一个不在本服务端的客户端。

{"content":"hi! I'm 微信公众号：bugstack虫洞栈 | 欢迎关注&获取源码。* 来自A服务端里用户向B服务端里用户发送信息。[结尾换行，用于处理半包粘包]","toChannelId":"3a2d5cee"}

最终运行效果

18.jpg

文章标签：
云数据库 Tair（兼容 Redis）
Java
NoSQL
Windows
Redis
缓存
存储
关键词：
Netty服务端
Netty通信
Netty案例
Netty方案
Netty netty4.1
相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务，基于高可靠双机热备架构及可无缝扩展的集群架构，满足高读写性能场景及容量需弹性变配的业务需求。 产品详情：https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验：数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引，您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接，领取免费ECS&amp;RDS资源，30分钟完成数据库上云实战！https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
小傅哥
目录
相关文章
Sunny_yiyi
|
6月前
|
网络协议 Java Maven
基于Netty实现TCP通信
基于Netty实现TCP通信
Sunny_yiyi
99 0
爱吃糖的范同学
|
6月前
|
网络协议
【Netty 网络通信】Socket 通信原理
【1月更文挑战第9天】【Netty 网络通信】Socket 通信原理
爱吃糖的范同学
83 0
爱吃糖的范同学
|
6月前
|
Java Maven
【Netty 网络通信】启动通信服务端
【1月更文挑战第9天】【Netty 网络通信】启动通信服务端
爱吃糖的范同学
73 0
nanshaws
|
1月前
|
网络协议 前端开发
netty的TCP服务端和客户端实现
本文介绍了使用Netty框架实现TCP服务端和客户端的步骤，包括添加Netty依赖、编写服务端和客户端的代码，涉及NioEventLoopGroup、ServerBootstrap、Bootstrap、ChannelInitializer等核心组件，以及如何启动服务端监听和客户端连接。
nanshaws
134 4
1176112968452250
|
2月前
|
存储 机器人 Linux
Netty(二)-服务端网络编程常见网络IO模型讲解
Netty(二)-服务端网络编程常见网络IO模型讲解
1176112968452250
23 2
土木林森
|
3月前
|
前端开发 网络协议
Netty实战巅峰：从零构建高性能IM即时通讯系统，解锁并发通信新境界
【8月更文挑战第3天】Netty是一款高性能、异步事件驱动的网络框架，适用于开发高并发网络应用，如即时通讯(IM)系统。本文将指导你利用Netty从零构建高性能IM程序，介绍Netty基础及服务器/客户端设计。服务器端使用`ServerBootstrap`启动，客户端通过`Bootstrap`连接服务器。示例展示了简单的服务器启动过程。通过深入学习，可进一步实现用户认证等功能，打造出更完善的IM系统。
土木林森
141 1
海风极客
|
6月前
|
网络协议
Netty实现TCP通信
Netty实现TCP通信
海风极客
98 0
一只牛博
|
6月前
|
网络协议 Java 物联网
Spring Boot与Netty打造TCP服务端(解决粘包问题)
Spring Boot与Netty打造TCP服务端(解决粘包问题)
一只牛博
1010 2
一只牛博
|
6月前
|
移动开发 网络协议 Java
通信密码学：探秘Netty中解码器的神奇力量
通信密码学：探秘Netty中解码器的神奇力量
一只牛博
196 0
一只牛博
|
6月前
|
前端开发 API 开发者
通信的枢纽：探秘Netty中神奇的Channel
通信的枢纽：探秘Netty中神奇的Channel
一只牛博
106 0

热门文章

最新文章

  • 1
    Netty实战二-实现UDP的单播和广播
  • 2
    Netty实战，Springboot + netty +websocket 实现推送消息（附源码）
  • 3
    Netty应用篇
  • 4
    Netty(一) SpringBoot 整合长连接心跳机制（上）
  • 5
    Netty 超时机制及心跳程序实现
  • 6
    Netty网络编程（六）：搭建websocket服务器
  • 7
    bbossgroups 1.0rc版本的rpc框架增加jboss netty 协议
  • 8
    基于cglib 反射 netty http1.0
  • 9
    Netty基础篇：NIO中缓冲区设置太小
  • 10
    Netty（三）Netty线程模型源码剖析
  • 1
    基于Netty的自研流系统缓存实现挑战: 内存碎片与OOM困境
    53
  • 2
    使用Netty构建高性能的网络应用
    54
  • 3
    使用Netty构建高性能的网络应用
    59
  • 4
    网络安全-----Redis12的Java客户端----客户端对比12，Jedis介绍，使用简单安全性不足，lettuce（官方默认）是基于Netty，支持同步，异步和响应式，并且线程是安全的，支持R
    70
  • 5
    蓝易云 - 【redis问题】Caused by: io.netty.channel
    65
  • 6
    netty粘包问题分析
    41
  • 7
    探秘Netty：打造高性能网络通信利器
    120
  • 8
    技术笔记：Netty专题(六)
    39
  • 9
    netty查看ByteBuf工具
    37
  • 10
    Netty传输object并解决粘包拆包问题
    49

    • 相关课程

    更多
  • 微服务实战-RocketMQ Binder
  • 基于Zookeeper、Dubbo构建互联网分布式基础架构
  • 分布式消息系统 Kafka 快速入门
  • 消息队列RocketMQ 5.0 云原生架构升级课程
  • 消息队列 RocketMQ 全类型业务消息学习课程
  • Dubbo分布式服务治理实战

    • 相关电子书

    更多
  • 基于RocketMQ Connect 构建全新数据流转处理平
  • Dubbo 如何成为连接各种异构微服务体系的服务开发框架
  • Apache RocketMQ 云原生统一消息引擎

    • 相关实验场景

    更多
  • 消息队列RocketMQ版：基础消息收发功能体验
  • 快速上手使用Dubbo进行远程调用
  • RocketMQ的常规运维实践应用
  • RocketMQ中使用Java客户端发送消息和消费的应用
    • 下一篇
    阿里云OSS设置跨域访问