基于 SOFAJRaft 实现注册中心

本文主要是介绍基于 SOFAJRaft 实现注册中心，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1.前言

通过本文的学习可以帮助大家了解 SOFAJRaft 的使用方式和集成步骤；参考本文的实现步骤，可以来完成自己工作中相关产品的一致性协议 raft 集成，从而实现应用的高可用。
学习本文的前提

• 需要了解 Raft 一致性协议
• 对 SOFAJRaft 框架有一定的了解
• 可以参考：SOFAJRaft 日志复制共识算法 https://blog.csdn.net/xiewenfeng520/article/details/133775751

本文主要讨论的内容如下

• 注册中心的实现
• 如何集成 Raft 协议来实现注册中心高可用

2.git 示例地址

本文完整代码地址：https://github.com/huajiexiewenfeng/eval-discovery

3.官网示例分析

截图中的报错，是对官网示例做了一定的改造，不影响，忽略即可；大家也可以自己来扩展官方的代码来加深对 JRaft 的理解。

代码分为以下几个部分

• CounterClient 客户端
• CounterServer 服务端
• CounterStateMachine 状态机
• CounterClosure 回调
• CounterOperation 操作
  • GET
  • INCREMENT
  • 扩展 …
• Processor 操作对应的处理类
  • IncrementAndGetRequestProcessor -> INCREMENT
  • GetValueRequestProcessor -> GET
• CounterSnapshotFile 快照存储
• CounterService 计数服务接口
  • CounterServiceImpl 计数服务实现

具体的实现细节可参考，我们这里就不做赘述了

• https://www.sofastack.tech/projects/sofa-jraft/counter-example/

3.SOFAJRAFT 注册中心实现（服务端）

3.1 核心功能

• 服务注册（Service Registration）
• 服务订阅（Service Subscription）
• 数据同步（Replicas Sync）
  • SOFAJRAFT 内建支持

3.2 模块设计

按照官网 counter 示例，注册中心模块设计如下：

• ServiceDiscoveryClient 客户端
• ServiceDiscoveryServer 服务端
• ServiceDiscoveryStateMachine 状态机
• ServiceDiscoveryClosure 回调
• ServiceDiscoveryOperation 操作
  • REGISTRATION 注册
  • DEREGISTRATION 注销
  • GET_SERVICE_INSTANCES 获取服务实例
  • BEAT 心跳
• Processor 操作对应的处理类
  • RegistrationRpcProcessor -> REGISTRATION
  • GetServiceInstancesRequestRpcProcessor -> GET_SERVICE_INSTANCES
  • HeartBeatRpcProcessor -> BEAT
• 注册中心一般采用内存型存储即可
• ServiceDiscovery 服务发现注册接口
  • JRaftServiceDiscovery 基于 JRaft 服务发现注册实现

3.3 请求消息数据结构设计

3.3.1 Registration 注册消息

reversed 用于区分该消息是注册还是注销，true 表示注销，false 表示注册。

message Registration {string id = 1;string serviceName = 2;string host = 3;int32 port = 4;map<string, string> metadata = 5;optional bool reversed = 6;
}

3.3.2 GetServiceInstancesRequest 获取服务实例请求

通过 serviceName 获取服务实例集合

message GetServiceInstancesRequest {string serviceName = 1;
}

3.3.3 GetServiceInstancesResponse 获取服务实例返回对象

返回服务实例集合

message GetServiceInstancesResponse {repeated Registration value = 1;
}

3.3.4 Response 返回对象

message Response {int32 code = 1;optional string message = 2;
}

3.3.5 HeartBeat 心跳

message HeartBeat {string id = 1;string serviceName = 2;string host = 3;int32 port = 4;
}

4.实现步骤

我们按照上面的设计的模块，将类都创建好，然后将官网示例中对应的代码 copy 到类中，慢慢再根据我们的需求来进行改造。

4.1 ServiceDiscoveryOuter 自动生成 proto 类

1.proto 文件

syntax = "proto3";package service.discovery;option java_package = "com.csdn.eval.discovery.jraft.proto";
option java_outer_classname = "ServiceDiscoveryOuter";message Registration {string id = 1;string serviceName = 2;string host = 3;int32 port = 4;map<string, string> metadata = 5;
}message HeartBeat {string id = 1;string serviceName = 2;string host = 3;int32 port = 4;
}message Response {int32 code = 1;string message = 2;
}message GetServiceInstancesRequest {string serviceName = 1;
}message GetServiceInstancesResponse {repeated Registration value = 1;
}

2.生成 proto 对应的 java 类
pom 中新增 proto 插件和依赖

  <properties><jraft.version>1.3.12</jraft.version><protobuf-java.version>3.22.4</protobuf-java.version></properties><dependencies><!-- SOFA JRAFT --><dependency><groupId>com.alipay.sofa</groupId><artifactId>jraft-core</artifactId><version>${jraft.version}</version></dependency><dependency><groupId>com.alipay.sofa</groupId><artifactId>jraft-rheakv-core</artifactId><version>${jraft.version}</version></dependency><dependency><groupId>com.google.protobuf</groupId><artifactId>protobuf-java</artifactId><version>${protobuf-java.version}</version></dependency></dependencies><build><extensions><extension><groupId>kr.motd.maven</groupId><artifactId>os-maven-plugin</artifactId><version>1.7.1</version></extension></extensions><plugins><plugin><groupId>org.xolstice.maven.plugins</groupId><artifactId>protobuf-maven-plugin</artifactId><version>0.6.1</version><configuration><protoSourceRoot>src/main/resources/proto</protoSourceRoot><protocArtifact>com.google.protobuf:protoc:3.21.7:exe:${os.detected.classifier}</protocArtifact><pluginId>grpc-java</pluginId><pluginArtifact>io.grpc:protoc-gen-grpc-java:1.54.1:exe:${os.detected.classifier}</pluginArtifact></configuration><executions><execution><goals><goal>compile</goal><goal>compile-custom</goal></goals></execution></executions></plugin></plugins></build>

3.编译完成之后，将类拷贝到 src 目录下面

4.2 服务注册发现接口

• 初始化
• 注册
• 注销
• 获取服务实例集合
• 关闭

public interface ServiceDiscovery {ServiceDiscovery DEFAULT = loadDefault(ServiceDiscovery.class);void initialize(Map<String, Object> config);void register(ServiceInstance serviceInstance);void deregister(ServiceInstance serviceInstance);List<ServiceInstance> getServiceInstances(String serviceName);void close();}

4.3 ServiceDiscoveryServer 服务发现服务端

将示例代码 com.alipay.sofa.jraft.example.counter.CounterServer 整个 copy 到我们的类中，再将下图中所有的报错处理完

• 将相关的组件替换成我们自己的组件
  • CounterStateMachine -> ServiceDiscoveryStateMachine
  • GetValueRequestProcessor -> RegistrationRpcProcessor
  • IncrementAndGetRequestProcessor -> GetServiceInstancesRequestRpcProcessor
  • 新增 HeartBeatRpcProcessor
• 将没有用的代码注释掉或者删除掉

4.4 ServiceDiscoveryStateMachine 状态机

按照上面的操作将代码复制，我在重要代码中增加了中文注释，从下图中可以看到大概有三个改造点

我们要实现功能点如下

功能点1

• 从 ServiceDiscoveryClosure 获取到当前请求的类型，这里我们可以建一个枚举类，类型如下：
  • REGISTRATION 注册
  • DEREGISTRATION 注销
  • GET_SERVICE_INSTANCES 获取实例
  • BEAT 心跳

    public enum Kind {REGISTRATION,DEREGISTRATION,GET_SERVICE_INSTANCES,BEAT;}

功能点2

ServiceDiscoveryOperation 序列化和反序列化的实现，也就是 改造点2 的部分，移到 ServiceDiscoveryOperation 类中来实现，减少主流程的冗余代码。

功能点3

通过请求类型来完成对应请求方法的调用，这里我们可以采用策略模式来实现

创建策略工厂类
ServiceDiscoveryRequestHandlerFactory

• RegistrationRequestHandler 注册处理者
• DeRegistrationRequestHandler 注销处理者
• GetServiceInstancesRequestHandler 获取服务实例处理者
• HeartBeatRequestHandler 心跳处理者

public class ServiceDiscoveryRequestHandlerFactory {/*** 服务名称与服务实例列表（List）映射*/private final Map<String, Map<String, ServiceInstance>> serviceNameToInstancesStorage = new ConcurrentHashMap<>();private final Map<Kind, ServiceDiscoveryRequestHandler> handlers = new HashMap<>();public void init() {handlers.put(Kind.REGISTRATION, new RegistrationRequestHandler(this));handlers.put(Kind.DEREGISTRATION, new DeRegistrationRequestHandler(this));handlers.put(Kind.GET_SERVICE_INSTANCES, new GetServiceInstancesRequestHandler(this));handlers.put(Kind.BEAT, new HeartBeatRequestHandler(this));}public ServiceDiscoveryRequestHandlerFactory() {}public ServiceDiscoveryRequestHandler getHandler(Kind kind) {return handlers.get(kind);}public synchronized void storage(String id, String serviceName, ServiceInstance serviceInstance) {Map<String, ServiceInstance> serviceInstancesMap = serviceNameToInstancesStorage.computeIfAbsent(serviceName, n -> new LinkedHashMap<>());serviceInstancesMap.put(id, serviceInstance);}public synchronized void delete(String id, String serviceName) {Map<String, ServiceInstance> instanceMap = getServiceInstancesMap(serviceName);instanceMap.remove(id);}public Map<String, ServiceInstance> getServiceInstancesMap(String serviceName) {return serviceNameToInstancesStorage.computeIfAbsent(serviceName, n -> new LinkedHashMap<>());}}

在 ServiceDiscoveryServer 创建的过程中，通过构造函数来创建 Factory，并传入到 Fsm 状态机中
改造完成之后状态机代码如下

  @Overridepublic void onApply(Iterator iter) {while (iter.hasNext()) {long current = 0;ServiceDiscoveryOperation operation = null;ServiceDiscoveryClosure closure = null;if (iter.done() != null) {// 从当前 Leader 节点获取 Closureclosure = (ServiceDiscoveryClosure) iter.done();// 从 Closure 获取服务操作的类型operation = closure.getServiceDiscoveryOperation();logger.info("The closure with operation[{}] at the Leader node[{}]", operation, node);} else {// 在 Follower 节点通过 日志反序列化得到 ServiceDiscoveryOperationfinal ByteBuffer data = iter.getData();operation = ServiceDiscoveryOperation.deserialize(data);logger.info("The closure with operation[{}] at the Follower node[{}]", operation, node);}// 根据服务操作类型的不同来进行不同的业务操作if (operation != null) {ServiceDiscoveryRequestHandlerFactory instanceFactory = ServiceDiscoveryRequestHandlerFactory.getInstance();instanceFactory.init();instanceFactory.getHandler(kind).doHandle(closure, (ServiceInstance) operation.getData());if (closure != null) {closure.run(Status.OK());}}iter.next();}}

关键代码：
instanceFactory.getHandler(kind).doHandle(closure, (ServiceInstance) operation.getData());
通过 kind 获取到对应的 handler，处理对应的请求方法。

功能点4

分别实现注册，注销，获取实例，心跳方法

服务注册请求处理者

public class RegistrationRequestHandler implements ServiceDiscoveryRequestHandler {private static final Logger logger = LoggerFactory.getLogger(RegistrationRequestHandler.class);private ServiceDiscoveryRequestHandlerFactory factory;public RegistrationRequestHandler(ServiceDiscoveryRequestHandlerFactory factory) {this.factory = factory;}@Overridepublic void doHandle(ServiceDiscoveryClosure closure, ServiceInstance serviceInstance) {if (null == serviceInstance) {return;}String serviceName = serviceInstance.getServiceName();String id = serviceInstance.getId();factory.storage(id, serviceName, serviceInstance);logger.info("{} has been registered at the node", serviceInstance);}
}

服务注销请求处理者

public class DeRegistrationRequestHandler implements ServiceDiscoveryRequestHandler {private static final Logger logger = LoggerFactory.getLogger(DeRegistrationRequestHandler.class);private ServiceDiscoveryRequestHandlerFactory factory;public DeRegistrationRequestHandler(ServiceDiscoveryRequestHandlerFactory factory) {this.factory = factory;}@Overridepublic void doHandle(ServiceDiscoveryClosure closure, ServiceInstance serviceInstance) {if (null == serviceInstance) {return;}String serviceName = serviceInstance.getServiceName();String id = serviceInstance.getId();factory.delete(id, serviceName);logger.info("{} has been deregistered at the node", serviceInstance);}
}

4.5 RpcProcessor 请求处理器

调用流程

RpcProcessor 实现的是 client -> apply(task) 这一部分的功能，具体的调用流程可以看官网 Counter 示例中的
com.alipay.sofa.jraft.example.counter.CounterServiceImpl#incrementAndGet 方法

此方法是在 IncrementAndGetRequestProcessor 中来调用的

GetServiceInstancesRequestRpcProcessor

参考 com.alipay.sofa.jraft.example.counter.rpc.IncrementAndGetRequestProcessor 示例来看需要完成两步

• 构造 Closure 回调
• 构造 task 对象，调用 Node().apply(task);

将对应的代码 copy 到 GetServiceInstancesRequestRpcProcessor 中，核心代码如下：

构造 Closure 回调，还有一个 getValueResponse() 方法需要实现，我们拿到返回结果；
getValueResponse() ->ServiceDiscoveryClosure#getResult()

  @Overridepublic void handleRequest(RpcContext rpcContext, GetServiceInstancesRequest request) {String serviceName = request.getServiceName();ServiceDiscoveryOperation op = new ServiceDiscoveryOperation(Kind.GET_SERVICE_INSTANCES,serviceName);final ServiceDiscoveryClosure closure = new ServiceDiscoveryClosure(op) {@Overridepublic void run(Status status) {rpcContext.sendResponse(getResult());}};if (!isLeader()) {handlerNotLeaderError(closure);return;}final Task task = new Task();task.setData(op.serialize());task.setDone(closure);this.serviceDiscoveryServer.getNode().apply(task);}

与 Counter 示例对比，发现 rpcContext.sendResponse(getResult()) 与原示例语义不同，rpcContext.sendResponse 需要的是 Response 对象，而我们这里返回的是 result 对象，是服务实例集合。

我们需要实现一个类似于 ValueResponse 的封装，返回 ServiceDiscoveryOuter.GetServiceInstancesResponse 对象。response 方法将 result 对象转换成 GetServiceInstancesResponse 对象，核心代码如下：

  private ServiceDiscoveryOuter.GetServiceInstancesResponse response(Object result) {Collection<ServiceInstance> serviceInstances = (Collection<ServiceInstance>) result;GetServiceInstancesResponse response = GetServiceInstancesResponse.newBuilder().addAllValue(convertRegistrations(serviceInstances)).build();return response;}

RegistrationRpcProcessor

按照上面的方式我们再实现注册功能，核心代码如下：

public class RegistrationRpcProcessor implements RpcProcessor<ServiceDiscoveryOuter.Registration> {...@Overridepublic void handleRequest(RpcContext rpcContext, Registration registration) {ServiceInstance serviceInstance = convertServiceInstance(registration);String serviceName = registration.getServiceName();final Kind kind = Kind.REGISTRATION;ServiceDiscoveryOperation op = new ServiceDiscoveryOperation(kind, serviceInstance);final ServiceDiscoveryClosure closure = new ServiceDiscoveryClosure(op) {@Overridepublic void run(Status status) {if (!status.isOk()) {logger.warn("Closure status is : {} at the {}", status, serviceDiscoveryServer.getNode());return;}rpcContext.sendResponse(response(status));logger.info("'{}' has been handled ,serviceName : '{}' , result : {} , status : {}",kind, serviceName, getResult(), status);}};if (!isLeader()) {handlerNotLeaderError(closure);return;}final Task task = new Task();task.setData(op.serialize());task.setDone(closure);this.serviceDiscoveryServer.getNode().apply(task);}...
}

里面有很多重复代码，我们再进行重构。
将通用的代码抽取到 RpcProcessorImpl 中

public class RpcProcessorImpl implements RpcProcessorService {private static final Logger logger = LoggerFactory.getLogger(RpcProcessorImpl.class);private final ServiceDiscoveryServer serviceDiscoveryServer;public RpcProcessorImpl(ServiceDiscoveryServer serviceDiscoveryServer) {this.serviceDiscoveryServer = serviceDiscoveryServer;}@Overridepublic Node getNode() {return this.serviceDiscoveryServer.getNode();}@Overridepublic void applyOperation(ServiceDiscoveryClosure closure) {if (!isLeader()) {handlerNotLeaderError(closure);return;}final Task task = new Task();// 写入本地日志，将作为 AppendEntries RPC 请求的来源 -> Followerstask.setData(closure.getServiceDiscoveryOperation().serialize());// 触发 Leader 节点上的状态机 onApply 方法task.setDone(closure);this.serviceDiscoveryServer.getNode().apply(task);}private ServiceDiscoveryStateMachine getFsm() {return this.serviceDiscoveryServer.getFsm();}private boolean isLeader() {return getFsm().isLeader();}private void handlerNotLeaderError(final Closure closure) {logger.error("No Leader node : {}", getNode().getNodeId());closure.run(new Status(RaftError.EPERM, "Not leader"));}}

RegistrationRpcProcessor 核心代码如下：

public class RegistrationRpcProcessor implements RpcProcessor<ServiceDiscoveryOuter.Registration> {...@Overridepublic void handleRequest(RpcContext rpcContext, Registration registration) {ServiceInstance serviceInstance = convertServiceInstance(registration);String serviceName = registration.getServiceName();final Kind kind = Kind.REGISTRATION;ServiceDiscoveryOperation op = new ServiceDiscoveryOperation(kind, serviceInstance);final ServiceDiscoveryClosure closure = new ServiceDiscoveryClosure(op) {@Overridepublic void run(Status status) {if (!status.isOk()) {logger.warn("Closure status is : {} at the {}", status, rpcProcessorService.getNode());return;}rpcContext.sendResponse(response(status));logger.info("'{}' has been handled ,serviceName : '{}' , result : {} , status : {}",kind, serviceName, getResult(), status);}};this.rpcProcessorService.applyOperation(closure);}...
}

4.6 ServiceDiscoveryClient 客户端

同样我们先将官网的示例 copy。
官网的示例大概做了以下动作

• 1.更新 Configuration
• 2.初始化 CliClientService
• 3.通过 RouteTable 获取到 Leader 节点
• 3.执行对应的请求方法

我们可以将 main 方法改造成 init 方法，因为我们后面会采用 spring web 的方式来进行注册的测试，而不是采用 main 方式来启动 client。
将两个配置参数 groupId，registerAddress 以构造函数的方式进行注入。

public class ServiceDiscoveryClient {private String groupId = "service-discovery";/*** 127.0.0.1:8083*/private String registerAddress;private CliClientService cliClientService;private RpcClient rpcClient;public ServiceDiscoveryClient(String groupId, String registerAddress) {this.groupId = groupId;this.registerAddress = registerAddress;}public void init(final String[] args) {ServiceDiscoveryGrpcHelper.initGRpc();final Configuration conf = new Configuration();if (!conf.parse(registerAddress)) {throw new IllegalArgumentException("Fail to parse conf:" + registerAddress);}RouteTable.getInstance().updateConfiguration(groupId, conf);final CliClientServiceImpl cliClientService = new CliClientServiceImpl();cliClientService.init(new CliOptions());this.cliClientService = cliClientService;this.rpcClient = cliClientService.getRpcClient();}...
}

下面我们将需求 3 和 4 重构成一个通用的方法

  public <R> R invoke(Object request) throws Throwable {if (!RouteTable.getInstance().refreshLeader(cliClientService, groupId, 1000).isOk()) {throw new IllegalStateException("Refresh leader failed");}PeerId leader = RouteTable.getInstance().selectLeader(groupId);return (R) rpcClient.invokeSync(leader.getEndpoint(), request, TimeUnit.SECONDS.toMillis(5));}

4.7 实现 ServiceDiscovery 接口

以 register 注册方法为例
我们只需要实现两步
1.构造 Registration 参数对象
2.采用 RPC 的方式调用注册方法
核心代码如下：

  @Overridepublic void register(ServiceInstance serviceInstance) {// 调用 RPCServiceDiscoveryOuter.Registration registration = buildRegistration(serviceInstance, false);try {serviceDiscoveryClient.invoke(registration);} catch (Throwable e) {e.printStackTrace();}}

4.8 Spring Web 项目集成

构建一个 Spring Web 的工程，在 Spring Application 启动的时候，初始化 JRaftServiceDiscovery，将 web 服务信息注册到注册中心即可。
pom 文件引入依赖

  <parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.3.0.RELEASE</version></parent><dependencies>...<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency>...</dependencies>

启动类 MyApplication，这里为了测试方便，配置都是写死的，实际可以从 Spring Environment 获取 Spring 中的环境变量

• 在 Spring Application 启动中，初始化 JRaftServiceDiscovery
• 再调用 register 方法注册服务实例即可

@RestController
@SpringBootApplication
public class MyApplication implements ApplicationListener<ApplicationReadyEvent> {@RequestMapping("/")String home() {return "Hello World!";}public static void main(String[] args) {SpringApplication.run(MyApplication.class, args);}@Overridepublic void onApplicationEvent(ApplicationReadyEvent event) {ConfigurableApplicationContext applicationContext = event.getApplicationContext();ConfigurableEnvironment environment = applicationContext.getEnvironment();JRaftServiceDiscovery jRaftServiceDiscovery = new JRaftServiceDiscovery();environment.getSystemProperties().put("service.discovery.jraft.registry.address","127.0.0.1:9081,127.0.0.1:9082,127.0.0.1:9083");jRaftServiceDiscovery.initialize(environment.getSystemProperties());DefaultServiceInstance serviceInstance = new DefaultServiceInstance();serviceInstance.setHost("127.0.0.1");serviceInstance.setId("1");serviceInstance.setPort(8080);serviceInstance.setServiceName("test1");jRaftServiceDiscovery.register(serviceInstance);}
}

5.测试

为了日志观察方便，我们可以在 ServiceDiscoveryRequestHandlerFactory 类中增加一个打印方法，每次操作之后打印 serviceNameToInstancesStorage 集合的元素

public class ServiceDiscoveryRequestHandlerFactory {...public synchronized void storage(String id, String serviceName, ServiceInstance serviceInstance) {Map<String, ServiceInstance> serviceInstancesMap = serviceNameToInstancesStorage.computeIfAbsent(serviceName, n -> new LinkedHashMap<>());serviceInstancesMap.put(id, serviceInstance);print();}private void print() {serviceNameToInstancesStorage.forEach((k, v) -> {logger.info(" key :{}", k);v.forEach((nk, nv) -> {logger.info(" n_key :{} + n_value:{}", nk, nv);});});}
...
}

编辑服务端启动参数三个服务端参数分别为

• /tmp/server1 service-discovery 127.0.0.1:9081 127.0.0.1:9081,127.0.0.1:9082,127.0.0.1:9083
• /tmp/server2 service-discovery 127.0.0.1:9082 127.0.0.1:9081,127.0.0.1:9082,127.0.0.1:9083
• /tmp/server3 service-discovery 127.0.0.1:9083 127.0.0.1:9081,127.0.0.1:9082,127.0.0.1:9083

依次启动 ServiceDiscoveryServer 服务。
再启动 Spring MyApplication，为了测试方便，我们可以直接采用写死配置的方式来进行调试，利用 debug 模式，来模拟多个 web 服务的注册

每次执行完，再替换参数，再次执行即可
核心代码如下：

DefaultServiceInstance serviceInstance = new DefaultServiceInstance();
serviceInstance.setHost("127.0.0.1");
serviceInstance.setId("2");
serviceInstance.setPort(8082);
serviceInstance.setServiceName("test2");
jRaftServiceDiscovery.register(serviceInstance);

观察每个注册中心服务端的打印信息
第一次注册
ServiceDiscoveryServer1：

ServiceDiscoveryServer2：

第二次注册
ServiceDiscoveryServer1：

ServiceDiscoveryServer2：

ServiceDiscoveryServer3：

可以看到每次服务注册的信息，都被同步到了三个服务端节点中。

这篇关于基于 SOFAJRaft 实现注册中心的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---