基于redis的选主功能设计
需求背景
在JAVA应用开发过程中，越来越多的项目采用了微服务架构，而采用微服务架构最直接作用是可以实现业务层解耦，有利于研发团队可以从业务层面进行划分，比如某几个人的小团队负责某几个微服务，总之，从业务角度来讲的话，让专业的人做专业的事。而同时由于部署了微服务后，经常需要保证业务的高可用，就有了同一服务多机部署的概念，而有的服务在任务处理的时候，可能需要保证任务处理的顺序性，在同一服务多机的时候，保证任务的顺序性其实是一个比较复杂的问题，比如说经常会用的邮件通知服务，邮件通知时，如果不按照业务的顺序进行通知的话，可能会造成一定错误。（比如一个告警邮件：第一个邮件：告警，第二个邮件解除告警，在这种情况下，如果顺序错乱会导致业务上造成误会甚至错误）
现实案例
某某产品中的邮件服务，需要多机部署，而同时需要保证邮件发送的顺序性。
目前架构中邮件服务的实现基本原理：各个服务根据需要，将需要发送的邮件内容，提交到redis队列，再由邮件服务进行轮询获取发送。
难点分析
但目前没有进行多机部署，无法保证服务的高可用，需要对其进行多机部署改造。而多机部署后，又涉及到邮件的实际发送顺序问题，所以在高可用的同时，仍需要保证业务的单一顺序性。对此在多机的同时，为其增加主备的功能，在多机的情况下，通过选主的方式选出主节点即实际工作节点，当主节点发生宕机的时候，再进行一次选主，选出另外一个工作节点。对于这种业务需要保证单一顺序的服务模块，通过主备的方式进行实现。
主备设计
由于目前系统中没有引入zookpeer分布式协调工具，所以对于选主目前通过redis来进行实现。
- 对于每一个JVM进程为其分配唯一的NODE_ID，启动后通过heartbeat机制定时(间隔20S)地在redis设值（key:jvm_process_NODE_ID_heartbeat value:NODE_ID ttl:30S）
- 系统启动后，主动地定时地去争取master lock，并获取其master状态；
- 当前进程如果争取master lock成功，则将自身的NODE_ID，设为value，并将过期时间设为30S；
- 如果master lock已被占有，根据其NODE_ID进行判断 ，如果是自身，则延长key存活时间，如果不是自身，则获取其value，判断value所指的NODE_ID的节点是否还存活（通过心跳去检查另外的节点），如果不存活，直接通过cas操作将其改为当前进程的NODE_ID，cas操作成功则抢主成功，反之则失败。
- 当获取节点状态（要么master 要么slave）后，则触发master-slave事件。
pom文件
这里需要用到redis，引入以下依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.11.4</version>
</dependency>
心跳机制
通过java进程定时地去设值redis key的方式去维持进程的心跳，这里为了方便redis的操作，使用了redisson client工具类。
为了方便地使用通过单例的方式进行获取使用，同时将引入到spring 中，交由spring管理并初始化
public class JVMProcessHeartbeat {
private static final Logger log = LoggerFactory.getLogger(JVMProcessHeartbeat.class);
/**
* 进程唯一id
*/
private static final String NODE_ID = SystemConstant.NODE_ID;
/**
* 维护心跳的key值格式
*/
private static final String FORMAT = "jvm_process_%s_heartbeat";
/**
* 根据NODE_ID生成当前进程的key
*/
private static final String HEARTBEAT_KEY = String.format(FORMAT, NODE_ID);
/**
* redis操作工具
*/
private RedissonClient redissonClient;
/**
* 定时维持心跳的线程池
*/
private ScheduledExecutorService scheduledExecutorService;
/**
* 单例模式设计心跳
*/
private static JVMProcessHeartbeat jvmProcessHeartbeat;
/**
* DCL单例实现
*
* @param redissonClient
* @return
*/
public static JVMProcessHeartbeat getInstance(RedissonClient redissonClient) {
if (jvmProcessHeartbeat == null) {
synchronized (JVMProcessHeartbeat.class) {
if (jvmProcessHeartbeat == null) {
jvmProcessHeartbeat = new JVMProcessHeartbeat(redissonClient);
}
}
}
return jvmProcessHeartbeat;
}
private JVMProcessHeartbeat(RedissonClient redissonClient) {
this.redissonClient = redissonClient;
init();
}
/**
* 初始化心跳维护线程
*/
private void init() {
BasicThreadFactory basicThreadFactory = new BasicThreadFactory.Builder().namingPattern("heartbeat").build();
scheduledExecutorService = new ScheduledThreadPoolExecutor(1, basicThreadFactory);
scheduledExecutorService.scheduleAtFixedRate(() -> {
RBucket<String> bucket = redissonClient.getBucket(HEARTBEAT_KEY);
bucket.set(NODE_ID, 30, TimeUnit.SECONDS);
log.debug("keep heart by redis,node id = [{}]",NODE_ID);
}, 1, 15, TimeUnit.SECONDS);
Runtime.getRuntime().addShutdownHook(new Thread(this::stopHeartbeat));
log.info("JVMProcessHeartbeat init successful");
}
/**
* 停止心跳，关闭线程池
*/
private void stopHeartbeat() {
if (this.scheduledExecutorService != null) {
this.scheduledExecutorService.shutdown();
}
log.info("JVMProcessHeartbeat stop!");
}
/**
* 检查指定的节点是否在线
*
* @param nodeId
* @return
*/
public boolean checkOnline(final String nodeId) {
String key = String.format(FORMAT, nodeId);
RBucket<String> bucket = redissonClient.getBucket(key);
if (bucket != null && bucket.isExists()) {
return true;
}
return false;
}
}
支持主从切换的Bean
对于需要进行主从切换的bean，将其生命周期划分为以下几个阶段
- 初始化（init)
- turnMaster（切换为主）
- turnSlave（切换为从）
public interface MasterSlaveSwitchBean {
/**
* 初始伦
*/
default void init() {
}
/**
* 切换为master为的触发事件
*/
default void turnMaster() {
}
/**
* 切换为slave后的触发事件
*/
default void turnSlave() {
}
/**
* 通过静态方法的方式将其进行注册
*
* @param applicationContext
* @param masterSlaveSwitchBean
*/
static void supportMasterSlave(ApplicationContext applicationContext, MasterSlaveSwitchBean masterSlaveSwitchBean) {
ProcessMasterSelector masterSelector = null;
MasterSlaveNamespace masterSlaveNamespace = masterSlaveSwitchBean.getClass().getAnnotation(MasterSlaveNamespace.class);
String namespace = Optional.ofNullable(masterSlaveNamespace).map(MasterSlaveNamespace::value).orElse(SystemConstant.DEFAULT_MASTER_SLAVE_NAMESPACE);
try {
masterSelector = applicationContext.getBean(namespace, ProcessMasterSelector.class);
} catch (Exception e) {
}
if (masterSelector == null) {
//如果是非集群状态下，则先init初始化，再运行turnMaster
masterSlaveSwitchBean.init();
masterSlaveSwitchBean.turnMaster();
} else {
//将其注册上去
masterSelector.register(new MasterSlaveSwitchBeanDecorator(masterSlaveSwitchBean));
}
}
}
为了更方便、更准确地控制支持主从切换bean的生命周期，为其添加一个包装类MasterSlaveSwitchBeanDecorator，重点关注其内部的boolean类型的属性 init 和 start
init方法在整个进程运行期间，只会被调用一次，而turnMaster 和 turnSlave则会根据切换可能被多次调用，这里有到了装饰者模式，实现如下 ：
public class MasterSlaveSwitchBeanDecorator implements MasterSlaveSwitchBean {
/**
* 初始化标识
*/
@Getter
private boolean inited = false;
/**
* 是否已经运行
*/
@Getter
private boolean started = false;
/**
* 具体的clusterBootstrapBean
*/
@Getter
private MasterSlaveSwitchBean masterSlaveSwitchBean;
public MasterSlaveSwitchBeanDecorator(MasterSlaveSwitchBean masterSlaveSwitchBean) {
this.masterSlaveSwitchBean = masterSlaveSwitchBean;
}
@Override
public void init() {
long startTime = System.currentTimeMillis();
log.info("start handle [{}] init method", masterSlaveSwitchBean.getClass().getSimpleName());
masterSlaveSwitchBean.init();
inited = true;
log.info("end handle [{}] init method,cost time [{}] seconds", masterSlaveSwitchBean.getClass().getSimpleName(), (System.currentTimeMillis() - startTime) / 1000);
}
@Override
public void turnMaster() {
if (started) {
return;
}
log.info("start handle [{}] turn master method", masterSlaveSwitchBean.getClass().getSimpleName());
masterSlaveSwitchBean.turnMaster();
started = true;
}
@Override
public void turnSlave() {
if (!started) {
return;
}
log.info("start handle [{}] turn slave method", masterSlaveSwitchBean.getClass().getSimpleName());
masterSlaveSwitchBean.turnSlave();
started = false;
}
}
为了更方便地在代码中使用masterSlaveSwitchBean，为其添加一个抽象类，bean只需要继承这个抽象类，就能够被master selector动态地控制进行事件的触发。
实现者只需要继承该类即可
public abstract class AbstractMasterSlaveSwitchBean implements ApplicationContextAware, MasterSlaveSwitchBean {
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
MasterSlaveSwitchBean.supportMasterSlave(applicationContext, this);
}
}
选主器（MasterSelector)
选主流程
- 系统启动后，定时地去维护一个选主的key，如果这个key的value值是自己的话，则自身就是master节点
- 当完成一次状态维护后，触发事件（根据当前注册上来的bean状态信息去执行具体的业务逻辑（三个方法 init turnMaster turnSlave））
具体实现代码相对较多，已放至github，欢迎大家对不足之处进行指正。
github地址：https://github.com/873098424/redisMasterSelctor.git
