假如 Redis Cluster 模式用在 T-io 上
前言
前几天在学习Redis Cluster 模式的时候，突然想到如果把它的集群模式应用在T-io上也是挺有意思的一件事情。
Redis 集群简介
Redis Cluster 中有 N 台实例，每个实例负责部分 Slot，总共有 16384 个Slot，然后客户端连接的时候，需要根据操作的Key计算出所在的Slot和服务实例地址，然后直接执行或者返回MOVE命令等。实例之间的元数据更新使用Gossip协议。简单一张图了解一下：
Tio集群
我设计的很简单，就是一个多实例集群，没有主从关系，集群之间通过 伪Gossip(因为我也不知道咋实现，┭┮﹏┭┮)协议通讯。我的设计思路是这样的。
从图中可以看出，每个实例会和集群中的其他的某几个实例相连，通过信息扩散的方式达到最终集群的完整性。比如A只知道B的存在，但是它最终会根据B知道C的存在。或者C 根据B知道A的存在。
实现原理
每个实例在启动之后会加载集群的其他某几个节点。然后上线之后通过 ClientChannelContext 与另外的集群节点进行通讯。模仿Redis设计了如下几个命令：
MEET
在一个实例上线之后，会发送 MEET 命令给其他已知实例。其他实例收到命令之后回复PONG命令。
PING
实例会定期在实例列表中选择若干实例发送PING命令，对方实例回复PONG命令，交换信息
PONG
在接收到 MEET,PING命令之后回复PONG命令
FAIL
在创建 ClientChannelContext对象之后,可以通过ClientAioListener获取连接回调，如果连接失败，那么实例将向其他在线实例发送FAIL命令，当本节点收到的FAILE命令数大于节点总数的一半时，认为该节点确实已经宕掉了，那么在执行UNAVAILABLE命令
UNAVAILABLE
如果说FAIL命令是病危通知书，那么 UNAVAILABLE 就是 确认死亡。
代码设计实现
TioClusterServer
继承自 TioServer，新增start方法，增加其他集群业务，例如初始化集群上下文信息
ClusterServerTioConfig
继承自 ServerTioConfig，为了约束客户端传参类型。
TioClusterNode
集群节点，包含 IP，Port,创建时间，状态 等信息，同时负责创建自己的ClientChannelContext
TioClusterContext
集群上下文，负责集群节点的创建，集群数据更新工作，同时负责调度各个节点的事件处理。
ClusterCommandExecutor
集群命令发送执行器，负责将各个命令发送出去
ClusterAioHandler，ClusterAioListener，ClusterServerAioHandler，ClusterServerAioListener
这几个类大家就很熟悉了，就是用于编解码的处理类。
集群启动流程
使用Gossip协议有个缺点，集群上线之后，可能会有很大的延迟发现。实例越多，延迟越大。更何况我自己实现的伪 Gossip 协议，暂且不提。
代码解析
在集群上下文中，维护了一个节点的集合，节点的增删改查都是通过它来实现。
/**
* 当前集群的所有节点
*/
private ConcurrentHashMap<String, TioClusterNode> clusterNodes = new ConcurrentHashMap<>(10);
初始化集群
单例，集群实例中只有一个大管家就是它，全局可用。
/**
* 初始化集群
*/
public TioClusterContext(ClusterCommandExecutor clusterCommandExecutor) {
if (tioClusterContext == null) {
synchronized (this) {
if (tioClusterContext == null) {
this.startTime = SystemTimer.currentTimeMillis();
this.clusterCommandExecutor = clusterCommandExecutor;
this.clusterProperty = TioClusterProperty.getClusterProperty();
initCurrentNode();
initClusterNodes();
tioClusterContext = this;
}
}
}
}
通知节点选择
根据配置文件选择要发送消息的N个节点，原则如下，距离上次更新时间超过配置文件中的超时时间的节点优先。然后轮询选择下一个节点，防止某个节点可能较长时间未被选中（也可以通过时上次更新时间排序解决），达到配置文件的节点数，停止。
public List<TioClusterNode> selectNotifyNodes(boolean containsCurrent,boolean containsUnavailable) {
List<TioClusterNode> nodes = new LinkedList<>();
TioClusterNode[] nodesInArray = getClusterNodesInArray(containsCurrent);
//根据时间间隔查找下一个节点
for (TioClusterNode node : nodesInArray) {
if ((SystemTimer.currentTimeMillis() - node.getUpdateTime()) >= clusterProperty.getNotifyTimeInterval()
&& nodes.size() < clusterProperty.getNotifyNodesMaxCount()
&& (containsCurrent || !isCurrentNode(node))
&& !nodes.contains(node)
&& (containsUnavailable || !node.isUnAvailable())) {
nodes.add(node);
}
}
int maxCount = nodesInArray.length;
int lastCount = (clusterProperty.getNotifyNodesMaxCount() > maxCount ? maxCount : clusterProperty.getNotifyNodesMaxCount()) - nodes.size();
int tryMaxCount = lastCount;
int tryCount = 0;
//很容易出现死循环，做好边界
while (lastCount > 0 && tryCount < tryMaxCount) {
TioClusterNode nextNode = RoundRibbonNodeSelector.nextPingNode(nodesInArray);
if (nextNode != null && !nodes.contains(nextNode)) {
if (containsUnavailable || !nextNode.isUnAvailable()) {
nodes.add(nextNode);
}
lastCount--;
}
tryCount++;
}
return nodes;
}
命令发送
发送命令很简单，就是调用 Tio 的Send方法。
private void send(TioClusterNode node, Consumer<ChannelContext> consumer){
ClientChannelContext channelContext = node.getClientChannelContext();
if (node.connectionActivated()) {
consumer.accept(channelContext);
}
}
@Override
public void meet(TioClusterNode other) {
send(other, channelContext -> Tio.send(channelContext, ClusterPacketBuilder.buildMeetPacket()));
}
命令编码
由于格式固定，所以命令的内容就不直接用 JSON 格式传输，根据命令的传输内容不同，分别组装不同的命令。
public ByteBuffer build( final ClusterPacket clusterPacket) {
this.clusterPacket = clusterPacket;
byte[] body = body();
ByteBuffer buffer = ByteBuffer.allocate(bufferLength());
//command
buffer.put(clusterPacket.command().getType());
//fromServerLength
buffer.putShort(fromServerLength());
//bodyLength
buffer.putInt(body.length);
//fromServer
buffer.put(fromServerBytes);
buffer.put(body);
return buffer;
}
//此方法由具体的命令类实现，每个命令所传输的内容不同，格式也不同
protected abstract byte[] body();
AioHandler 解耦
由于我们在内部处理集群消息的时候需要用到AioHandler，所以这个是避免不了的，但是用户又有自己的消息要处理，所以，我又增加了一层，将ClusterServerAioHandler作为抽象类，增加若干抽象方法，然后具体的用户消息的处理放到新增的抽象方法里，其他类同理，不在阐述。
public abstract class ClusterServerAioHandler implements ServerAioHandler {
private static final Logger logger = LoggerFactory.getLogger(ClusterServerAioHandler.class);
/**
* 用户自定义解码
*/
public abstract Packet clusterDecode(ByteBuffer buffer, int limit, int position, int readableLength, ChannelContext channelContext) throws AioDecodeException;
/**
* 用户自定义编码
*/
public abstract ByteBuffer clusterEncode(Packet packet, TioConfig tioConfig, ChannelContext channelContext);
/**
* 用户自定义消息处理
*/
public abstract void clusterHandler(Packet packet, String packetJsonString, ChannelContext channelContext) throws Exception;
/**
* 处理集群消息解码
* */
@Override
public final Packet decode(ByteBuffer buffer, int limit, int position, int readableLength, ChannelContext channelContext) throws AioDecodeException {
Packet clusterPacket = ClusterPacketDecoder.decode(buffer, limit, position, readableLength, channelContext);
if (clusterPacket != null) {
return clusterPacket;
}
//reset buffer because cluster has already read a byte for cluster command
buffer.position(position);
return clusterDecode(buffer, limit, position, readableLength, channelContext);
}
/**
* 处理集群消息编码
* */
@Override
public final ByteBuffer encode(Packet packet, TioConfig tioConfig, ChannelContext channelContext) {
ByteBuffer buffer = ClusterPacketEncoder.encode(packet, tioConfig, channelContext);
if (buffer != null) {
return buffer;
}
//当集群解析的Buffer为NULL时候，说明是非集群内部消息，交给用户自定义处理
return clusterEncode(packet, tioConfig, channelContext);
}
/**
*
* 处理集群消息*/
@Override
public final void handler(Packet packet, ChannelContext channelContext) throws Exception {
//这里留空，后边讲解
}
}
集群消息的转发
暂时还没有将 slot 的概念派上用场，先用了普通的取模方式。此方法是根据业务主键获取所在节点的方法。比如 ID为1 的用户连接的服务节点可能为 127.0.0.1:7002,ID为2的用户连接的服务节点为127.0.0.1:7001.至于细节可以屏蔽，比如通过NGINX让用户无感知到底连接了哪台服务器。
/**
* 根据 hashCode 获取该值所绑定的节点，如果集群机器增加或者删除可能会导致节点错误，发消息失败（暂不考虑）
* */
public static TioClusterNode getClusterServerNode(Object object) {
int hashCode = object.hashCode();
//获取集群活跃节点
List<TioClusterNode> nodes = TioClusterContext.currentContext().getActivateNodes();
int length = nodes.size();
//取模
int index = hashCode % length;
return nodes.get(index);
}
发送消息
private static boolean sendToUserInternal(TioConfig tioConfig,String userId, Packet packet) {
TioClusterNode node = getClusterServerNode(userId);
//如果是本机，直接发送到本机即可
if (TioClusterContext.currentContext().currentServer().equals(node) && tioConfig != null) {
return Tio.sendToUser(tioConfig, userId, packet);
} else {
//这里需要包装成为ClusterPacket,因为集群内部的消息是通过ClusterPacket实现的
ClusterPacket userPacket = ClusterPacketBuilder.buildUserPacket(packet);
return Tio.send(node.getClientChannelContext(), userPacket);
}
}
上文中的代码很简单，如果获取到的节点是本机节点，那么很幸运，直接执行发送即可。否则，需要将Packet包装到ClusterPacket中，因为集群内部的消息都是通过它来流通的。新增 USER 命令。它的包编码很简单，转JSON。
@Override
protected byte[] body() {
Packet userPacket = ((ClusterUserPacket) clusterPacket).getPacketBody().getUserPacket();
String json = Json.toJson(userPacket);
return SafeStringEncoder.stringToBytes(json);
}
在上文中留空的地方代码如下：
@Override
public final void handler(Packet packet, ChannelContext channelContext) throws Exception {
//第一种情况，内部消息转发
if (packet instanceof ClusterPacket) {
ClusterPacket clusterPacket = (ClusterPacket) packet;
logger.info("[{}] RECEIVED [{}] FROM [{}] ", TioClusterContext.currentContext().currentServer().serverName(),clusterPacket.command().getCmd() ,clusterPacket.getPacketBody().getFromNode().serverName());
//当命令为USER时，说明此消息是从其他节点过来的用户消息
if (clusterPacket.command() == ClusterCommand.USER) {
ClusterUserPacket clusterUserPacket = (ClusterUserPacket) packet;
//由于框架并不知道用户使用了具体的Packet类型，所以，这里提供了 JSON 和 对象的两种传递方式，在这里 getuserPakcet 是为NULL的。
clusterHandler(clusterUserPacket.getPacketBody().getUserPacket(), clusterUserPacket.getPacketBody().getUserPacketString(), channelContext);
} else {
ClusterObjectFactory.getPacketHandler(clusterPacket.command()).handle(clusterPacket, channelContext);
}
} else {
//第二种情况，直接走用户消息处理
clusterHandler(packet, null, channelContext);
}
}
测试环节
- 1 编写 ServerAioHandler，ServerAioListener，正如上文所讲，需要继承ClusterServerAioHandler
public class MyClusterServerAioHandler extends ClusterServerAioHandler {}
public class MyClusterServerAioListener extends ClusterServerAioListener{}
- 2 编写starter
public static void main(String[] args) throws IOException {
start();
}
private static void start() throws IOException {
//这里要实例化 ClusterSververTioConfig
tioConfig = new ClusterServerTioConfig(new MyClusterServerAioHandler(), new MyClusterServerAioListener());
TioClusterServer tioServer = new TioClusterServer(tioConfig);
tioServer.start();
}
- 3 编写配置文件
tio.server.ip=127.0.0.1
tio.server.port=7001
tio.cluster.server.nodes=127.0.0.1:7002
tio.cluster.server.notify.max.count=4
tio.cluster.server.notify.interval=20000
tio.cluster.server.notify.retry.count=1
tio.cluster.server.notify.timeout=20000
tio.server.ip=127.0.0.1
tio.server.port=7002
tio.cluster.server.nodes=127.0.0.1:7001
tio.cluster.server.notify.max.count=4
tio.cluster.server.notify.interval=20000
tio.cluster.server.notify.retry.count=1
tio.cluster.server.notify.timeout=20000
-
4 启动服务，查看日志
日志中可以看出，刚开始一个节点是连不通的，但是该节点上线之后发送了MEET命令。
现在两个节点都上线了，集群目前正常。 -
5 启动两个客户端，一个用户1，一个用户2 ，用户1 连接 7002，用户2 连接 7001
public static void main(String[] args) throws Exception {
String name = System.getenv("TIO-CLUSTER-FILE-NAME");
Prop prop = new Prop(name + ".properties");
ClientTioConfig config = new ClientTioConfig(new MyClientAioHandler(), new MyClientAioListener(), null);
config.setHeartbeatTimeout(0);
config.setName("testClient");
TioClient tioClient = new TioClient(config);
ClientChannelContext channelContext = tioClient.connect(new Node(prop.get("tio.server.ip"), prop.getInt("tio.server.port")), 20000);
String userId = prop.get("tio.userid");
Tio.send(channelContext, MyPacket.handshakePacket(userId));
while (true) {
Thread.sleep(5000);
Tio.send(channelContext, MyPacket.helloPacket(prop.get("tio.touserid"), "hello there ,I'm user " + userId + ",I come from " + prop.get("tio.server.port")));
}
}
总结
本文通过参考Redis集群模式实现了一个简单的集群功能。开发过程中遇到的问题：
- 集群节点的发现功能，Gossip协议的实现，需要优化，优化节点算法
- 细节的处理，写着写着可能发现隐藏着死循环！！！
- 并发的处理，在这方面由于能力原因处理较少，应该还有优化空间
- 消息类的解耦和封装，还有很多优化空间
此集群实现可能出现的问题：
-
集群节点过多的时候，一个实例可能维护多个 client ，再加上各种命令的发送，会比较浪费系统资源。可以通过合理的设置超时时间，通知节点的个数等来优化，我觉得也可以采用 RocketMQ的NameServer的方式去实现
-
思路虽然不算错误，但是个人感觉，依赖第三方组件也是一种稳妥的做法，Redis发布订阅他不香吗？，Zookeeper管理集群节点不好吗？
-
其实这都不是问题，最主要的是享受思考和开发的过程，通常会几个小时最后发现是自己犯了一个小错误导致的。不过还好，结局还是在接受范围内。
最后本文也花费了我接近两个小时的时间，分享出我的想法和开发历程。希望能给各位带来收获，另外也希望各位大牛提出更好的意见和方案。谢谢大家，回家喽~~
