5.实现简化版raft协议完成选举

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量55 收藏
点赞数
分类专栏： Java-分布式插件化任务执行框架 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010142228/article/details/135050232
版权

1.设计

前面已经完成了netty的集成，接下来就是借助netty完成选举就行了。

针对选举，我们用到了VotRequestMessage、VotRespMessage、当节点下线时NodeOfflineMessage、NodeOnlineMessage、NodeOnlineRespMessage

1.1 节点详细的交互

1.2 对所有消息的处理使用策略模式

由于我们是Spring的应用，我可以借助Spring的容器完成对消息类型的选择

1.2.1 创建 IMessageService 接口

所有消息的处理都实现此接口

public interface IMessageService {
    
    byte getMessageType();
    
    void execute(ChannelHandlerContext ctx, DttaskMessage message);
    
}

1.2.2 DttaskMessage

@Data
public class DttaskMessage {

    public static final byte COMMON_RESP = 0X00;
    public static final byte PING = 0X01;
    public static final byte PONG = 0X02;
    public static final byte VOTING = 0X03;
    public static final byte VOT_RESP = 0X04;
    public static final byte NODE_OFFLINE = 0X05;
    public static final byte NODE_ONLINE = 0X06;
    public static final byte NODE_ONLINE_RESP = 0X07;

    // 类型
    private byte type;
    // 消息实际信息
    private String info;
    
    public static DttaskMessage buildPingMessage(long serverId) {
        DttaskMessage dttaskMessage = new DttaskMessage();
        dttaskMessage.setType(PING);
        dttaskMessage.setInfo(JSON.toJSONString(new PingMessage(serverId)));
        return dttaskMessage;
    }

    public static DttaskMessage buildPongMessage(long serverId) {
        DttaskMessage dttaskMessage = new DttaskMessage();
        dttaskMessage.setType(PONG);
        dttaskMessage.setInfo(JSON.toJSONString(new PongMessage(serverId)));
        return dttaskMessage;
    }
    
    
    public static DttaskMessage buildCommonRespMessage(String message, boolean successFlag) {
        DttaskMessage dttaskMessage = new DttaskMessage();
        dttaskMessage.setType(COMMON_RESP);
        dttaskMessage.setInfo(JSON.toJSONString(new CommonRespMessage(message, successFlag)));
        return dttaskMessage;
    }

    public static DttaskMessage buildNodeOnlineRespMessage(long serverId) {
        DttaskMessage dttaskMessage = new DttaskMessage();
        dttaskMessage.setType(NODE_ONLINE_RESP);
        dttaskMessage.setInfo(JSON.toJSONString(new NodeOnlineRespMessage(serverId)));
        return dttaskMessage;
    }

    public static DttaskMessage buildNodeOnlineMessage(long serverId) {
        DttaskMessage dttaskMessage = new DttaskMessage();
        dttaskMessage.setType(NODE_ONLINE);
        dttaskMessage.setInfo(JSON.toJSONString(new NodeOnlineMessage(serverId)));
        return dttaskMessage;
    }

    public static DttaskMessage buildNodeOfflineMessage(long serverId) {
        DttaskMessage dttaskMessage = new DttaskMessage();
        dttaskMessage.setType(NODE_OFFLINE);
        dttaskMessage.setInfo(JSON.toJSONString(new VotRespMessage(serverId)));
        return dttaskMessage;
    }

    public static DttaskMessage buildVotRespMessage(long serverId) {
        DttaskMessage dttaskMessage = new DttaskMessage();
        dttaskMessage.setType(VOT_RESP);
        dttaskMessage.setInfo(JSON.toJSONString(new VotRespMessage(serverId)));
        return dttaskMessage;
    }

    public static DttaskMessage buildVotRequestMessage(Long lastControllerServerId, long fromServerId, long serverId, int version) {
        DttaskMessage dttaskMessage = new DttaskMessage();
        dttaskMessage.setType(VOTING);
        dttaskMessage.setInfo(JSON.toJSONString(new VotRequestMessage(lastControllerServerId, fromServerId, serverId, version)));
        return dttaskMessage;
    }
    
}

1.2.3 VotingMessageService

这里以VotingMessageService为例，它实现了IMessageService接口，完成投票信息的处理。其它的*MessageService也是同样的，这里就不一一举例了，可以在 com.swsm.dttask.server.service.message包下查看

@Slf4j
@Component
public class VotingMessageService implements IMessageService {

    @Override
    public byte getMessageType() {
        return DttaskMessage.VOTING;
    }

    @Override
    public void execute(ChannelHandlerContext ctx, DttaskMessage message) {
        Channel channel = ctx.channel();
        VotRequestMessage votRequestMessage = JSON.parseObject(message.getInfo(), VotRequestMessage.class);
        long fromServerId = votRequestMessage.getFromServerId();
        Long lastControllerServerId = votRequestMessage.getLastControllerServerId();
        ServerInfo.addOtherNode(fromServerId, channel);
        boolean addRes = ServerInfo.addVotResult(votRequestMessage.getVersion(), votRequestMessage.getServerId());
        if (!addRes) {
            log.info("丢弃以前版本的投票信息={}", votRequestMessage);
            return;
        }
        // 归票
        VotResult votResult = ServerInfo.getVotResult();
        Map<Long, Integer> votMap = votResult.getVotMap();
        for (Map.Entry<Long, Integer> entry : votMap.entrySet()) {
            long controllerServerId = entry.getKey();
            if (votMap.get(controllerServerId) >= ServerInfo.getVotMax()) {
                // 归票成功
                log.info("本节点={}是controller", controllerServerId);
                ServerInfo.setStatus(ServerStatus.RUNNING);
                Controller controller = ServerInfo.initController();
                for (Long otherServerId : ServerInfo.getOtherNodeIds()) {
                    Channel otherNodeChannel = ServerInfo.getChannelByServerId(otherServerId);
                    otherNodeChannel.writeAndFlush(DttaskMessage.buildVotRespMessage(controllerServerId));
                }
                return;
            }
        }
    }
}

1.2.4 MessageServiceManager

Spring托管的bean，里面会将所有实现了IMessageService接口的类都管理起来，并在消息到来时进行选择

@Slf4j
@Component
public class MessageServiceManager {
    
    @Autowired(required = false)
    private List<IMessageService> messageServices;
    
    private Map<Byte, IMessageService> messageServiceMap = new HashMap<>();
    
    @PostConstruct
    public void init() {
        if (messageServices != null) {
            for (IMessageService messageService : messageServices) {
                messageServiceMap.put(messageService.getMessageType(), messageService);
            }
        }
    }
    
    public IMessageService chooseMessageService(byte messageType) {
        if (messageServiceMap.containsKey(messageType)) {
            return messageServiceMap.get(messageType);
        }
        return messageServiceMap.get(Byte.MIN_VALUE);
    }
    
}

1.2.5 借助netty实现节点与节点直接的心跳

@Slf4j
public class HeartBeatServerHandler extends ChannelInboundHandlerAdapter {  
    
    @Override  
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {  
        if (evt instanceof IdleStateEvent) {  
            IdleStateEvent event = (IdleStateEvent) evt;  
            if (event.state() == IdleState.READER_IDLE) {  
                log.warn("读取空闲...");
            } else if (event.state() == IdleState.WRITER_IDLE) {
                log.warn("写入空闲...");
            } else if (event.state() == IdleState.ALL_IDLE) {
                Long serverId = ServerInfo.getServerIdByChannelId(ctx.channel().id());
                log.warn("serverId={}与server通信读取或写入空闲...", serverId);
                if (serverId != null) {
                    ctx.writeAndFlush(DttaskMessage.buildPingMessage(serverId));
                } else {
                    ctx.close();
                }
            }
        }  
    }  
}

1.2.6 ServerInfo类完成所有信息的管理

ServerInfo类完成所有信息的管理，它里面会存储很多系统运行需要的数据如：当前节点信息(myNodeInfo)、Channel和节点的关系(nodeChannelMap、nodeChannelServerIdMap)、系统状态(status)、其它节点信息(otherNodeInfoMap)；

ServerInfo还肩负着确定节点角色(Controller或Follower)以及初始化角色的任务

@Slf4j
public class ServerInfo {
    
    private ServerInfo() {}
    
    private static NioEventLoopGroup bossGroup;
    public static void setBossGroup(NioEventLoopGroup bg) {
        bossGroup = bg;
    }
    public static NioEventLoopGroup getBossGroup() {
        return bossGroup;
    }
    private static NioEventLoopGroup workerGroup;
    private static Channel serverChannel;
    private static Bootstrap connectOtherNodeBootStrap;
    private static ServerBootstrap bootstrapForClient;

    private static NodeInfo myNodeInfo;
        private static Map<Long, Channel> nodeChannelMap = new ConcurrentHashMap<>();
    private static Map<ChannelId, Long> nodeChannelServerIdMap = new ConcurrentHashMap<>();
    private static volatile ServerStatus status;
    private static Map<Long, NodeInfo> otherNodeInfoMap = new ConcurrentHashMap<>();
    private static VotResult votResult = new VotResult();

    private static Controller controller;
    private static Follower follower;


    public static void init() {
        RedisUtil redisUtil = BeanUseHelper.redisUtil();
        DttaskServerConfig dttaskServerConfig = BeanUseHelper.dttaskServerConfig();
        long localServerId = dttaskServerConfig.getServerId();
        ServerInfo.setStatus(ServerStatus.STARTING);
        Long controllerServerId = redisUtil.getLongValue(Constant.RedisConstants.DTTASK_CONTROLLER);
        if (controllerServerId == null) {
            log.info("当前启动状态为：未确定controller");
            initNodeInfoByConfig();
            Long minServerId = ServerInfo.getMinNodeId();
            if (minServerId == localServerId) {
                log.info("就当前一个节点:{},此节点就是controller", localServerId);
                ServerInfo.setStatus(ServerStatus.RUNNING);
            } else {
                log.info("有多个节点，节点状态应为VOTING");
                ServerInfo.setStatus(ServerStatus.VOTING);
            }
        } else {
            log.info("当前启动状态为：已确定controller");
            ServerInfo.refreshNodeInfoByRedis();
            InetSocketAddress address = dttaskServerConfig.getServerInfoMap().get(localServerId);
            ServerInfo.setMyNodeInfo(localServerId, address.getHostString(), address.getPort(), null);
            ServerInfo.setStatus(ServerStatus.IDENTIFYING);
        }

    }

    private static void initNodeInfoByConfig() {
        DttaskServerConfig dttaskServerConfig = BeanUseHelper.dttaskServerConfig();
        long localServerId = dttaskServerConfig.getServerId();
        Map<Long, InetSocketAddress> serverInfoMap = dttaskServerConfig.getServerInfoMap();
        for (Map.Entry<Long, InetSocketAddress> entry : serverInfoMap.entrySet()) {
            long id = entry.getKey();
            InetSocketAddress address = serverInfoMap.get(id);
            if (localServerId != id) {
                ServerInfo.addOtherNode(id, address.getHostString(), address.getPort());
            } else {
                ServerInfo.setMyNodeInfo(localServerId, address.getHostString(), address.getPort(), null);
            }
        }
    }

    public static Controller initController() {
        long localServerId = ServerInfo.getServerId();
        RedisUtil redisUtil = BeanUseHelper.redisUtil();
        log.info("初始化本节点={}controller信息...", ServerInfo.getServerId());
        ServerInfo.setRole(ServerRole.CONTROLLER);
        redisUtil.setCacheObject(Constant.RedisConstants.DTTASK_CONTROLLER, localServerId);
        ServerInfo.setOtherNodeRole(localServerId);
        ServerInfo.refreshRedisNodeInfo();
        controller = Controller.getInstance();
        return controller;
    }

    public static Follower initFollower() {
        log.info("初始化本节点={}follower信息...", ServerInfo.getServerId());
        RedisUtil redisUtil = BeanUseHelper.redisUtil();
        Long controllerServerId = redisUtil.getLongValue(Constant.RedisConstants.DTTASK_CONTROLLER);
        if (controllerServerId == null) {
            log.error("init follower时，controller还没有确定...");
            throw new BusinessException("init follower时，controller还没有确定...");
        }
        ServerInfo.setRole(ServerRole.FOLLOWER);
        ServerInfo.setStatus(ServerStatus.RUNNING);
        ServerInfo.setOtherNodeRole(controllerServerId);
        follower = Follower.getInstance();
        return follower;
    }

    public static void setMyNodeInfo(long serverId, String ip, int port, ServerRole serverRole) {
        NodeInfo nodeInfo = new NodeInfo();
        nodeInfo.setServerId(serverId);
        nodeInfo.setIp(ip);
        nodeInfo.setPort(port);
        nodeInfo.setServerRole(serverRole);
        myNodeInfo = nodeInfo;
    }


    public static long getServerId() {
        return myNodeInfo.getServerId();
    }

    public static NodeInfo getMyNodeInfo() {
        return myNodeInfo;
    }

    public static Map<Long, NodeInfo> getOtherNodeInfoMap() {
        return otherNodeInfoMap;
    }

    public static int getVotMax() {
        return otherNodeInfoMap.size();
    }

    public static VotResult getVotResult() {
        return votResult;
    }

    public static synchronized void cacheChannelAnsServerIdRel(long serverId, Channel channel) {
        nodeChannelMap.put(serverId, channel);
        nodeChannelServerIdMap.put(channel.id(), serverId);

    }

    public static Channel getChannelByServerId(Long serverId) {
        return nodeChannelMap.get(serverId);
    }

    public static synchronized void removeChannel(ChannelId channelId) {
        Long serverId = nodeChannelServerIdMap.get(channelId);
        if (serverId != null) {
            log.info("删除和节点id={}的连接", serverId);
            nodeChannelServerIdMap.remove(channelId);
            nodeChannelMap.remove(serverId);
            otherNodeInfoMap.remove(serverId);
        }
    }

    public static synchronized void refreshRedisNodeInfo() {
        if (myNodeInfo != null && getRole() != null && getRole().isController()) {
            RedisUtil redisUtil = BeanUseHelper.redisUtil();
            Map<Long, NodeInfo> otherNodeInfoMap = ServerInfo.getOtherNodeInfoMap();
            List<NodeInfo> nodeInfoList = new ArrayList<>();
            nodeInfoList.addAll(otherNodeInfoMap.values());
            nodeInfoList.add(ServerInfo.getMyNodeInfo());
            log.info("controller刷新节点信息到redis:{}", nodeInfoList);
            redisUtil.setCacheObject(Constant.RedisConstants.DTTASK_NODE_INFO, JSON.toJSONString(nodeInfoList));
        }
    }



    public static Long getServerIdByChannelId(ChannelId channelId) {
        return nodeChannelServerIdMap.get(channelId);
    }

    public static synchronized boolean addVotResult(int version, long chooseServerId) {
        Integer curVersion = votResult.getVersion();
        if (version < votResult.getVersion()) {
            log.info("版本={}已失效,当前的为:{}", version, curVersion);
            return false;
        }
        votResult.setVersion(version);
        if (votResult.getVotMap().containsKey(chooseServerId)) {
            votResult.getVotMap().put(chooseServerId, votResult.getVotMap().get(chooseServerId) + 1);
        } else {
            votResult.getVotMap().put(chooseServerId, 1);
        }
        return true;
    }

    public static void addOtherNode(long serverId, String ip, int port) {
        NodeInfo nodeInfo = new NodeInfo();
        nodeInfo.setServerId(serverId);
        nodeInfo.setIp(ip);
        nodeInfo.setPort(port);
        otherNodeInfoMap.put(serverId, nodeInfo);
    }
    public static void addOtherNode(long serverId, Channel channel) {
        addOtherNode(serverId, channel, null);
    }

    public static void addOtherNode(long serverId, Channel channel, ServerRole serverRole) {
        InetSocketAddress address = BeanUseHelper.dttaskServerConfig().getServerInfoMap().get(serverId);
        if (address == null) {
            throw new BusinessException(CharSequenceUtil.format("id={}的没有配置在文件中", serverId));
        }
        if (channel != null && ServerInfo.getServerIdByChannelId(channel.id()) == null) {
            ServerInfo.cacheChannelAnsServerIdRel(serverId, channel);
        }
        NodeInfo nodeInfo = new NodeInfo();
        nodeInfo.setServerId(serverId);
        nodeInfo.setIp(address.getHostString());
        nodeInfo.setPort(address.getPort());
        nodeInfo.setServerRole(serverRole);
        otherNodeInfoMap.put(serverId, nodeInfo);
    }

    public static NodeInfo getNodeInfo(long serverId) {
        return otherNodeInfoMap.get(serverId);
    }

    public static Set<Long> getOtherNodeIds() {
        return otherNodeInfoMap.keySet();
    }

    public static long getMinNodeId() {
        if (getOtherNodeIds().isEmpty()) {
            return ServerInfo.getServerId();
        }
        return Collections.min(getOtherNodeIds());
    }

    public static void setOtherNodeRole(long controllerServerId) {
        for (Map.Entry<Long, NodeInfo> entry : otherNodeInfoMap.entrySet()) {
            long serverId = entry.getKey();
            if (serverId == controllerServerId) {
                otherNodeInfoMap.get(serverId).setServerRole(ServerRole.CONTROLLER);
            } else {
                otherNodeInfoMap.get(serverId).setServerRole(ServerRole.FOLLOWER);
            }
        }
    }

    public static ServerRole getRole() {
        return myNodeInfo.getServerRole();
    }

    public static void setStatus(ServerStatus s) {
        status = s;
    }

    public static void setRole(ServerRole r) {
        myNodeInfo.setServerRole(r);
    }

    public static Set<Channel> getOtherNodeChannel(Long serverId) {
        Set<Channel> res = new HashSet<>();
        for (Map.Entry<Long, Channel> entry : nodeChannelMap.entrySet()) {
            long id = entry.getKey();
            if (!Objects.equals(serverId, id)) {
                res.add(nodeChannelMap.get(id));
            }
        }
        return res;
    }

    /**
     * 这个方法针对，本节点并没有和要断开节点有连接的
     * @param offlineServerId 掉线的节点id
     */
    public static void removeNode(long offlineServerId) {
        log.info("删除掉线节点id={}", offlineServerId);
        otherNodeInfoMap.remove(offlineServerId);
    }

    public static void refreshNodeInfoByRedis() {
        RedisUtil redisUtil = BeanUseHelper.redisUtil();
        Object obj = redisUtil.getCacheObject(Constant.RedisConstants.DTTASK_NODE_INFO);
        if (obj != null) {
            List<NodeInfo> nodeInfoList = JSON.parseObject(obj.toString(),
                    new TypeReference<List<NodeInfo>>() {}.getType());
            for (NodeInfo nodeInfo : nodeInfoList) {
                otherNodeInfoMap.put(nodeInfo.getServerId(), nodeInfo);
            }
        }
    }

    public static boolean isIdentifying() {
        return status.isIdentifying();
    }

    public static boolean isVoting() {
        return status.isVoting();
    }

    public static boolean isRunning() {
        return status.isRunning();
    }

    
    
    public static void setWorkerGroup(NioEventLoopGroup bg) {
        workerGroup = bg;
    }
    public static NioEventLoopGroup getWorkerGroup() {
        return workerGroup;
    }

    public static void setServerChannel(Channel ch) {
        serverChannel = ch;
    }
    public static Channel getServerChannel() {
        return serverChannel;
    }
    public static void setConnectOtherNodeBootStrap(Bootstrap bs) {
        connectOtherNodeBootStrap = bs;
    }
    public static Bootstrap getConnectOtherNodeBootStrap() {
        return connectOtherNodeBootStrap;
    }

    public static void setBootstrapForClient(ServerBootstrap sbs) {
        bootstrapForClient = sbs;
    }
    public static ServerBootstrap getBootstrapForClient() {
        return bootstrapForClient;
    }

}

1.2.7 SpringInitRunner -- 增加选举的逻辑

SpringInitRunner前面只启动了netty等待连接，这里将完成选举，以及当就自己一个节点则就认为自己是controller

@Component
@Slf4j
public class SpringInitRunner implements CommandLineRunner {

    @Autowired
    private DttaskServerConfig dttaskServerConfig;
    @Autowired
    private NetworkService networkService;
    @Autowired
    private MessageServiceManager messageServiceManager;
    @Autowired
    private RedisUtil redisUtil;

    @PostConstruct
    public void init() {
        initServerBootStrap();
        initConnectOtherNodeBootStrap();
    }

    private void initConnectOtherNodeBootStrap() {
        ServerInfo.setConnectOtherNodeBootStrap(new Bootstrap());
        ServerInfo.getConnectOtherNodeBootStrap().group(new NioEventLoopGroup(4))
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) {
                        socketChannel.pipeline().addLast(
                                new DttaskMessageDecoder(MESSAGE_MAX_SIZE, MESSAGE_LENGTH_FILED_OFFSET, MESSAGE_LENGTH_FILED_LENGTH));
                        socketChannel.pipeline().addLast(
                                new IdleStateHandler(dttaskServerConfig.getReadIdleSecondTime(),
                                        dttaskServerConfig.getWriteIdleSecondTime(),
                                        dttaskServerConfig.getAllIdleSecondTime()));
                        socketChannel.pipeline().addLast(new DttaskMessageEncoder());
                        socketChannel.pipeline().addLast(
                                new ServerClientChannelHandler(networkService, redisUtil, messageServiceManager));
                    }
                });
    }

    private void initServerBootStrap() {
        ServerInfo.setBossGroup(new NioEventLoopGroup(4));
        ServerInfo.setWorkerGroup(new NioEventLoopGroup(8));
        ServerInfo.setBootstrapForClient(new ServerBootstrap());
        ServerInfo.getBootstrapForClient().group(ServerInfo.getBossGroup(), ServerInfo.getWorkerGroup())
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) {
                        socketChannel.pipeline().addLast(
                                new DttaskMessageDecoder(MESSAGE_MAX_SIZE, MESSAGE_LENGTH_FILED_OFFSET, MESSAGE_LENGTH_FILED_LENGTH));
                        socketChannel.pipeline().addLast(new DttaskMessageEncoder());
                        IdleStateHandler idleStateHandler = new IdleStateHandler(dttaskServerConfig.getReadIdleSecondTime(), dttaskServerConfig.getWriteIdleSecondTime(), dttaskServerConfig.getAllIdleSecondTime());
                        socketChannel.pipeline().addLast(idleStateHandler);
                        socketChannel.pipeline().addLast(new HeartBeatServerHandler());
                        socketChannel.pipeline().addLast(
                                new ServerClientChannelHandler(networkService, redisUtil, messageServiceManager));
                    }
                });
    }

    @Override
    public void run(String... args) {
        log.info("spring启动完成，接下来启动 netty");
        ServerInfo.init();
        try {
            log.info("启动监听其它节点端请求的服务端...");
            ServerInfo.setServerChannel(ServerInfo.getBootstrapForClient().bind(dttaskServerConfig.listenerPort()).sync().channel());
        } catch (Exception e) {
            log.error("启动 监听其它节点请求的服务端出现异常", e);
            System.exit(-1);
        }
        try {
            log.info("连接controller或开始vote...");
            if (ServerInfo.isIdentifying()) {
                log.info("连接controller...");
                RedisUtil redisUtil = BeanUseHelper.redisUtil();
                long controllerServerId = redisUtil.getLongValue(Constant.RedisConstants.DTTASK_CONTROLLER);
                networkService.connectController(controllerServerId);
            } else if (ServerInfo.isVoting()){
                log.info("开始vote...");
                long minNodeId = ServerInfo.getMinNodeId();
                networkService.startVote(null, minNodeId);
            } else if (ServerInfo.isRunning()) {
                log.info("已确认本节点={}就是controller...", ServerInfo.getServerId());
                Controller controller = ServerInfo.initController();
            }
        }  catch (Exception e) {
            log.error("连接controller或开始vote出现异常", e);
            System.exit(-1);
        }
        log.info("netty 启动成功...");
    }

    @PreDestroy
    public void shutdown() {
        if (ServerInfo.getOtherNodeIds().isEmpty()) {
            redisUtil.setCacheObject(Constant.RedisConstants.DTTASK_CONTROLLER, null);
            redisUtil.setCacheObject(Constant.RedisConstants.DTTASK_NODE_INFO, null);
        }
        try {
            ServerInfo.getServerChannel().close().sync();
        } catch (InterruptedException e) {
            log.error("dttask-server netty shutdown 出现异常", e);
            Thread.currentThread().interrupt();
        } finally {
            ServerInfo.getWorkerGroup().shutdownGracefully();
            ServerInfo.getBossGroup().shutdownGracefully();
        }
    }
}

1.2.8 ServerClientChannelHandler -- 完成投票等消息处理

前面ServerClientChannelHandler只是完成了基本框架，代码较少，现在要在这里添加处理每个消息的逻辑，放心，代码也不多，因为我们已经对消息处理进行了拆分，只要加入一个策略选择就可以。

这里不得不感叹一下：策略模式的功能，否则这里将会有一大堆if else。

当节点与节点的通信断开时，会触发channelInactive和exceptionCaught方法，我们需要在这里处理断开的业务逻辑，注意断开的业务逻辑需要判断断开的是Controller还是Follower，这里的处理逻辑不同。

@Slf4j
public class ServerClientChannelHandler extends SimpleChannelInboundHandler<DttaskMessage> {


    private NetworkService networkService;
    private MessageServiceManager messageServiceManager;
    private RedisUtil redisUtil;

    public ServerClientChannelHandler(NetworkService networkService, RedisUtil redisUtil, MessageServiceManager messageServiceManager) {
        super();
        this.networkService = networkService;
        this.redisUtil = redisUtil;
        this.messageServiceManager = messageServiceManager;
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        log.info("channelActive={}", ctx.channel().id());
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, DttaskMessage message) throws Exception {
        log.info("收到客户端的请求:{}", message);
        messageServiceManager.chooseMessageService(message.getType()).execute(ctx, message);
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        log.warn("channelInactive...");
        stopChannel(ctx, null);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        log.warn("exceptionCaught...", cause);
        stopChannel(ctx, cause);
    }

    private void stopChannel(ChannelHandlerContext ctx, Throwable cause) {
        Channel channel = ctx.channel();
        long localServerId = ServerInfo.getServerId();
        Long serverId = ServerInfo.getServerIdByChannelId(ctx.channel().id());
        if (serverId == null) {
            return;
        }
        if (cause != null) {
            log.error("nodeId={}与本节点id={}通信出现异常", serverId, localServerId, cause);
        } else {
            log.error("nodeId={}与本节点id={}通信失效", serverId, localServerId);
        }
        if (channel.isActive()) {
            channel.close();
        }
        // 判断下线的是follower 还是 controller
        NodeInfo nodeInfo = ServerInfo.getNodeInfo(serverId);
        if (!nodeInfo.getServerRole().isController()) {
            log.info("下线的是follower,id={}", serverId);
            Set<Channel> otherNodeChannels = ServerInfo.getOtherNodeChannel(serverId);
            for (Channel otherNodeChannel : otherNodeChannels) {
                otherNodeChannel.writeAndFlush(DttaskMessage.buildNodeOfflineMessage(serverId));
            }
            ServerInfo.removeChannel(channel.id());
            ServerInfo.refreshRedisNodeInfo();
        } else {
            log.info("下线的是controller,id={}", serverId);
            redisUtil.setCacheObject(Constant.RedisConstants.DTTASK_CONTROLLER, null);
            ServerInfo.removeChannel(channel.id());
            long minNodeId = ServerInfo.getMinNodeId();
            if (minNodeId != localServerId) {
                // 重新选举
                networkService.startVote(serverId, minNodeId);
            } else {
                // 当前就只剩自己一个节点
                ServerInfo.setStatus(ServerStatus.RUNNING);
                Controller controller = ServerInfo.initController();
            }
            ServerInfo.refreshRedisNodeInfo();
        }

    }
}

2. 验证

2.1 建立3个节点的配置

注意：Server.port需要是不一样的

注意：节点的serverId也要和serverInfo匹配

2.2 idea建立针对3个配置的启动Service

2.3 依次启动验证

可以按照本文最起那面的 节点详细交互图的 步骤进行测试。

  • 确保redis，mysql都已ok
  • 依次启动3个节点，可以看到1为controller，2 3为follower，redis的key --- 完成选举

  • 下线3号节点

  • 下线1号节点

2号节点称为Controller

  • 上线1号节点、3号节点

所有节点启动完成，这时2是C、1 3是F

  • 停止2号节点

至此完成了所有验证

lswsmj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
MIT 6.824 Lab2 Raft实现
Tsunaou的试验场
03-04 1336
1. 综述 在本次实验中，我使用Go语言在给定框架上实现了简单的Raft协议，通过实现包括节点选举、心跳机制、日志追加和持久化等内容，完成了Part1，Part2和Part3。项目托管在github上，地址为NJU-DisSys-2020。当实验DDL过了后我将开源。 2. 相关定义 根据Raft的原始论文以及扩展版论文，我定义了如下常量和数据结构。 2.1 常量定义 2.1.1 状态常量 首先是定义Raft中Sever的三种状态，分别是 领导者（Leader） 跟随者（Follower） 候选者（Can
Raft协议分析
qq_27749613的博客
07-10 872
分布式系统作为一致性协议较为常用的有两种:raft协议和paxos 协议。两种协议实现的复杂度不同，paxos相对于raft的复杂难度要高出好几个级别，而目前只有zookeeper实现了paxos的简化版本；而使用raft协议的中间件则相对多很多，例如：etcd和consul。...
4.raft协议及简化版raft协议
lswsmj的专栏
12-17 40
有很多的任务，可能数量达到10万，100万，且还可能不断增加，每个任务的执行可支持自定义也可以选择内置的方式。系统必须足够稳定，尽量减少对外部的依赖。
Raft共识算法领导者选举流程揭秘
我是一名热爱编程和分享知识的技术作者，在金融和教育领域有多年的研发管理经验，感谢您访问我的博客，一定会为您带来不一样的收货！
02-23 1022
Raft算法是现代分布式系统开发首选的共识算法，Raft算法属于Multi-Paxos算法，是在兰伯特Multi-Paxos思想的基础上，做了一些简化和限制。Raft算法的应用非常广泛掌握这个算法，可以得心应手的处理大部分场景的容错和一致性需求。关于 Raft 算法分三期讲解，分别介绍领导者选举、日志复制、成员变更，这篇文章首先讲解领导者选举。
深度解析 Raft 协议与KRaft实战演示
匠人精神，持之以恒！
03-10 793
Raft 协议是一种分布式一致性算法，它用于在分布式系统中的多个节点之间达成一致性。Raft 协议的目标是提供一种相对简单、易于理解和实现的方法，以确保在网络分区、节点故障等情况下，系统仍然能够保持一致性和可用性。
科普: 中间件底层实现的分布式协议之Raft
dayformyjob
12-16 420
正式介绍 Raft 协议之前，我们先来举一个例子????进行展开。 方式一： 在一个技术团队内假设角色都是均等的，会导致什么情况呢？产品提出一个需求，就可以随便去找团队中的任意一个人去发起需求。如果这个人因为请假走了，但是他没有把需求及时同步给团队其他人，因此会导致该需求存在很大的延迟。 方式二： 在技术团队中选举一个Leader 角色，产品提出的需求必须优先提给 Leader，找 Lead...
快速理清Paxos、Zab、Raft协议
程序猿的樊笼
09-18 2455
在raft之前，paxos使用的比较多。基本的paxos，对于一次数据更新请求，集群各个节点可能要进行多轮消息交换，而raft因为必须要选择一个leader，通过leader只需要一轮消息交换。raft论文描述了一个基于raft复制状态机的完整方案，paxos论文只给了一个一致性算法。目前业内使用比较广泛的是raft。zab协议是为zookeeper专门设计的支持崩溃恢复的原子广播协议，目前主要了解到的也是在zookeeper上的应用和实现。
Etcd 理解Raft协议 图文并茂
小楼一夜听春雨，深巷明朝卖杏花
07-02 1053
etcd是raft协议的一个实现。如果你使用过zookeeper这样的分布式键值对，你应该知道有个叫paxos的协议，paxos协议是挺复杂的，raft协议是paxos协议的简化版本。大多数同意原则：一群人怎么达成原则，往往是通过投票，当多数人同意的时候就按照多数人投票的结果去执行。在服务端一般是多个成员组成了一个集群，针对客户端任何的变更，这个变更首先会发到服务端，服务端在处理变更请求的时候，它会有一个一致性的模块，这个一致性模块会将这个变更请求发给其他所有的peer，请求经过一致性模块之后，请求就会转发
日志一致性协议Raft
懒猫的脚印
07-04 966
前言        数据一致性是分布式服务的一大难题。假设我们能无成本的保证数据一致性，在分布式环境中就可以使用无限扩容来分发流量。那么数据一致性，何为数据 ？往往日志log是一应用的可靠性的保障，例如 mysql的binlog,redis 的aof日志。通过分析日志从机子可以达到和本机子相同的状态。因此数据一致性的问题，化简为日志一致性问题。Raft则是一个用于管理日志一致性的协议。 Raft简介 Raft又称 木筏协议，一种共识算法，
Hyperledger Fabric RAFT共识协议探究
01-20
然而，Raft协议的出现旨在提供一个更直观、更易于实现的Paxos变体，它简化了Paxos的复杂性，提高了其实用性。 在Raft中，选举过程中记录了每个任期(term)的信息，确保了即使在领导者恢复时也能正确处理状态转换。...
Raft论文中文翻译版
08-13
本文主要关注的是Raft算法，一个相对较新的共识协议，旨在解决Paxos的可理解性问题并提供额外的安全性与特性。 ### 1. Paxos简介 Paxos是由Leslie Lamport提出的一种分布式一致性算法，它允许一组节点在不完全可靠...
.NETCore微服务之基于Consul实现服务治理
01-27
Consul支持多数据中心，每个中心的集群会选举出一个Leader，通过Raft协议确保数据的一致性。当 Leader宕机或失联时，会自动重新选举。 为了使用Consul实现服务治理，首先需要搭建Consul集群。这个过程包括环境准备...
redis-raft.tar.gz
04-15
它将领导者选举、日志复制和安全性这三个核心概念简化，使得开发者更容易理解和实现。在Redis-raft项目中，可能是对Redis进行了改造，使其支持Raft算法，从而能够在分布式环境中保证数据的一致性。 数据库是存储和...
snail-jraft：筏协议java实现
02-15
总结，snail-jraft项目为Java开发者提供了一个raft协议的实现，它简化了raft的理解和应用，同时也具备高性能和易用性。通过对源码的学习和实践，开发者可以更深入地理解分布式一致性算法，提高系统设计能力。
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 990
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java内存模型
weixin_44267758的博客
07-19 755
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 736
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1285
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
RAFT 协议选举流程
03-06
RAF协议选举流程是指在分布式系统中，如何选举出一个可靠的领导者来管理整个系统。具体流程是：每个节点都会向其他节点发送心跳包，如果一个节点在一段时间内没有收到其他节点的心跳包，那么它就会开始选举领导者。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lswsmj

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值