服务端的示例
我们首先贴上我们的服务端的示例：
public static void main(String[] args) {
ServerConfig serverConfig = new ServerConfig()
.setProtocol("bolt") // 设置一个协议，默认bolt
.setPort(12200) // 设置一个端口，默认12200
.setDaemon(false); // 非守护线程
ProviderConfig<HelloService> providerConfig = new ProviderConfig<HelloService>()
.setInterfaceId(HelloService.class.getName()) // 指定接口
.setRef(new HelloServiceImpl()) // 指定实现
.setServer(serverConfig); // 指定服务端
providerConfig.export(); // 发布服务
}
ProviderConfig#export
从示例入手我们设置好ServerConfig和ProviderConfig之后调用ProviderConfig的export方法进行暴露
ProviderConfig#export
public synchronized void export() {
if (providerBootstrap == null) {
providerBootstrap = Bootstraps.from(this);
}
//DefaultProviderBootstrap
providerBootstrap.export();
}
Bootstraps#from这个方法我们在《源码分析---SOFARPC客户端服务引用》中已经分析过，所以这里就不分析了，里面就是调用SOFARPC自己的SPI机制返回的是DefaultProviderBootstrap实例。
DefaultProviderBootstrap#export
然后调用DefaultProviderBootstrap#export方法
@Override
public void export() {
if (providerConfig.getDelay() > 0) { // 延迟加载,单位毫秒
Thread thread = factory.newThread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(providerConfig.getDelay());
} catch (Throwable ignore) { // NOPMD
}
doExport();
}
});
thread.start();
} else {
doExport();
}
}
这里有两个分支，如果在设置providerConfi的时候设置了延迟属性的话，那么就会调用NamedThreadFactory#newThread方法起一个线程，然后延迟调用doExport方法。
DefaultProviderBootstrap#doExport
/**
* 是否已发布
*/
protected transient volatile boolean exported;
/**
* 发布的服务配置
*/
protected final static ConcurrentMap<String, AtomicInteger> EXPORTED_KEYS = new ConcurrentHashMap<String, AtomicInteger>();
private void doExport() {
//校验一下，如果服务已经暴露过了那么就不再进行暴露
if (exported) {
return;
}
// 检查参数
checkParameters();
String appName = providerConfig.getAppName();
//key is the protocol of server,for concurrent safe
Map<String, Boolean> hasExportedInCurrent = new ConcurrentHashMap<String, Boolean>();
// 将处理器注册到server
List<ServerConfig> serverConfigs = providerConfig.getServer();
for (ServerConfig serverConfig : serverConfigs) {
String protocol = serverConfig.getProtocol();
String key = providerConfig.buildKey() + ":" + protocol;
if (LOGGER.isInfoEnabled(appName)) {
LOGGER.infoWithApp(appName, "Export provider config : {} with bean id {}", key, providerConfig.getId());
}
// 注意同一interface，同一uniqueId，不同server情况
AtomicInteger cnt = EXPORTED_KEYS.get(key); // 计数器
if (cnt == null) { // 没有发布过
cnt = CommonUtils.putToConcurrentMap(EXPORTED_KEYS, key, new AtomicInteger(0));
}
//计数器加一，如果计数器的值超过了设置的exportLimit，那么就会抛出异常
int c = cnt.incrementAndGet();
hasExportedInCurrent.put(serverConfig.getProtocol(), true);
int maxProxyCount = providerConfig.getRepeatedExportLimit();
if (maxProxyCount > 0) {
if (c > maxProxyCount) {
//计数器减一
decrementCounter(hasExportedInCurrent);
// 超过最大数量，直接抛出异常
throw new SofaRpcRuntimeException("Duplicate provider config with key " + key
+ " has been exported more than " + maxProxyCount + " times!"
+ " Maybe it's wrong config, please check it."
+ " Ignore this if you did that on purpose!");
} else if (c > 1) {
if (LOGGER.isInfoEnabled(appName)) {
LOGGER.infoWithApp(appName, "Duplicate provider config with key {} has been exported!"
+ " Maybe it's wrong config, please check it."
+ " Ignore this if you did that on purpose!", key);
}
}
}
}
try {
// 构造请求调用器
providerProxyInvoker = new ProviderProxyInvoker(providerConfig);
// 初始化注册中心
if (providerConfig.isRegister()) {
//如果有设置注册中心的话就遍历注册中心
List<RegistryConfig> registryConfigs = providerConfig.getRegistry();
if (CommonUtils.isNotEmpty(registryConfigs)) {
for (RegistryConfig registryConfig : registryConfigs) {
// 提前初始化Registry到ALL_REGISTRIES对象中
RegistryFactory.getRegistry(registryConfig);
}
}
}
//如果有多个配置则逐个遍历
// 将处理器注册到server
for (ServerConfig serverConfig : serverConfigs) {
try {
Server server = serverConfig.buildIfAbsent();
// 注册请求调用器
server.registerProcessor(providerConfig, providerProxyInvoker);
if (serverConfig.isAutoStart()) {
server.start();
}
} catch (SofaRpcRuntimeException e) {
throw e;
} catch (Exception e) {
LOGGER.errorWithApp(appName, "Catch exception when register processor to server: "
+ serverConfig.getId(), e);
}
}
providerConfig.setConfigListener(new ProviderAttributeListener());
// 注册到注册中心
register();
} catch (Exception e) {
decrementCounter(hasExportedInCurrent);
if (e instanceof SofaRpcRuntimeException) {
throw (SofaRpcRuntimeException) e;
} else {
throw new SofaRpcRuntimeException("Build provider proxy error!", e);
}
}
// 记录一些缓存数据
RpcRuntimeContext.cacheProviderConfig(this);
exported = true;
}
doExport方法里面主要做了以下几件事：
- 检查参数是否正确
- 检查注入的对象是否是接口的实现类
- providerConfig是否有设置server参数
- 检查方法，是否有重名的方法，对方法进行黑白名单的过滤（对配置的include和exclude方法进行过滤）
- 遍历设置的serverConfigs
- 对要发布的接口进行计数，如果超过了设置的repeatedExportLimit那么就抛出异常
- 构造请求调用器
- 初始化注册中心
- 注册请求调用器
- 启动服务
- 设置监听
- 注册到注册中心
接下来我们挨个分析上面的步骤
参数检查DefaultProviderBootstrap#checkParameters
protected void checkParameters() {
// 检查注入的ref是否接口实现类
Class proxyClass = providerConfig.getProxyClass();
String key = providerConfig.buildKey();
T ref = providerConfig.getRef();
if (!proxyClass.isInstance(ref)) {
throw ExceptionUtils.buildRuntime("provider.ref",
ref == null ? "null" : ref.getClass().getName(),
"This is not an instance of " + providerConfig.getInterfaceId()
+ " in provider config with key " + key + " !");
}
// server 不能为空
if (CommonUtils.isEmpty(providerConfig.getServer())) {
throw ExceptionUtils.buildRuntime("server", "NULL", "Value of \"server\" is not specified in provider" +
" config with key " + key + " !");
}
checkMethods(proxyClass);
}
这个方法里面主要做了一下几件事：
- 调用
providerConfig.getProxyClass();获取接口class，在我们这个示例中是interface com.alipay.sofa.rpc.quickstart.HelloService - 调用
providerConfig.getRef();获取接口实现类引用，我们这里对应的是HelloServiceImpl - 调用
proxyClass.isInstance判断ref是否是接口的实现类，如果不是的话抛出异常 - 校验server不能为空
- 调用checkMethods方法校验方法
进入到checkMethods方法中
protected void checkMethods(Class<?> itfClass) {
ConcurrentHashMap<String, Boolean> methodsLimit = new ConcurrentHashMap<String, Boolean>();
for (Method method : itfClass.getMethods()) {
String methodName = method.getName();
if (methodsLimit.containsKey(methodName)) {
// 重名的方法
if (LOGGER.isWarnEnabled(providerConfig.getAppName())) {
LOGGER.warnWithApp(providerConfig.getAppName(), "Method with same name \"" + itfClass.getName()
+ "." + methodName + "\" exists ! The usage of overloading method in rpc is deprecated.");
}
}
// 判断服务下方法的黑白名单
Boolean include = methodsLimit.get(methodName);
if (include == null) {
//对配置的include和exclude方法进行过滤
// 检查是否在黑白名单中
include = inList(providerConfig.getInclude(), providerConfig.getExclude(), methodName);
methodsLimit.putIfAbsent(methodName, include);
}
}
providerConfig.setMethodsLimit(methodsLimit);
}
在这个方法里首先会去遍历实现类的所有的方法。
- 判断一下这个实现类里面是否有同名的方法，如果有的话会打印提示，所以看到这里我们就可以知道，我们在使用定义接口的时候最好不要定义重载的方法，官方不提倡这么做
- 如果设置了Include和Exclude参数的话，会根据这两个参数对要发布的对象进行方法级别的过滤，默认Include是
*，Exclude参数默认是一个空的字符串
初始化注册中心
往下我们可以看到会调用RegistryFactory.getRegistry(registryConfig);对注册中心进行初始化
public static synchronized Registry getRegistry(RegistryConfig registryConfig) {
// 超过3次 是不是配错了？
if (ALL_REGISTRIES.size() > 3) {
if (LOGGER.isWarnEnabled()) {
LOGGER.warn("Size of registry is greater than 3, Please check it!");
}
}
try {
// 注意：RegistryConfig重写了equals方法，如果多个RegistryConfig属性一样，则认为是一个对象
Registry registry = ALL_REGISTRIES.get(registryConfig);
if (registry == null) {
//通过spi根据protocol来获取注册中心实例
ExtensionClass<Registry> ext = ExtensionLoaderFactory.getExtensionLoader(Registry.class)
.getExtensionClass(registryConfig.getProtocol());
if (ext == null) {
throw ExceptionUtils.buildRuntime("registry.protocol", registryConfig.getProtocol(),
"Unsupported protocol of registry config !");
}
registry = ext.getExtInstance(new Class[]{RegistryConfig.class}, new Object[]{registryConfig});
ALL_REGISTRIES.put(registryConfig, registry);
}
return registry;
} catch (SofaRpcRuntimeException e) {
throw e;
} catch (Throwable e) {
throw new SofaRpcRuntimeException(e.getMessage(), e);
}
}
这个方法里面主要是通过SPI实例化相应的注册中心，然后放入到ALL_REGISTRIES对象当中去。
初始化server
接下来我们会调用serverConfig.buildIfAbsent();初始化server
public synchronized Server buildIfAbsent() {
if (server != null) {
return server;
}
// 提前检查协议+序列化方式
// ConfigValueHelper.check(ProtocolType.valueOf(getProtocol()),
// SerializationType.valueOf(getSerialization()));
//通过工厂获取server实例
server = ServerFactory.getServer(this);
return server;
}
public synchronized static Server getServer(ServerConfig serverConfig) {
try {
//根据端口获取实例
Server server = SERVER_MAP.get(Integer.toString(serverConfig.getPort()));
if (server == null) {
// 算下网卡和端口
resolveServerConfig(serverConfig);
ExtensionClass<Server> ext = ExtensionLoaderFactory.getExtensionLoader(Server.class)
.getExtensionClass(serverConfig.getProtocol());
if (ext == null) {
throw ExceptionUtils.buildRuntime("server.protocol", serverConfig.getProtocol(),
"Unsupported protocol of server!");
}
//通过SPI获取server实例
server = ext.getExtInstance();
//初始化server里面具体的参数
server.init(serverConfig);
SERVER_MAP.put(serverConfig.getPort() + "", server);
}
return server;
} catch (SofaRpcRuntimeException e) {
throw e;
} catch (Throwable e) {
throw new SofaRpcRuntimeException(e.getMessage(), e);
}
}
然后我们会根据不同的server实现类调用不同的init方法来初始化参数，这里我们使用的是BoltServer
public void init(ServerConfig serverConfig) {
this.serverConfig = serverConfig;
// 启动线程池
bizThreadPool = initThreadPool(serverConfig);
boltServerProcessor = new BoltServerProcessor(this);
}
调用完buildIfAbsent方法后回到doExport方法中继续往下走，调用server.registerProcessor。这个方法里面主要是把对应的Invoker实例和实例所对应的方法缓存起来。
boltServer#registerProcessor
public void registerProcessor(ProviderConfig providerConfig, Invoker instance) {
// 缓存Invoker对象 包路径名+类名+版本号 com.alipay.sofa.rpc.quickstart.HelloService:1.0
String key = ConfigUniqueNameGenerator.getUniqueName(providerConfig);
invokerMap.put(key, instance);
// 把这个实例所对应的类加载器缓存到SERVICE_CLASSLOADER_MAP中
ReflectCache.registerServiceClassLoader(key, providerConfig.getProxyClass().getClassLoader());
// 缓存接口的方法
for (Method m : providerConfig.getProxyClass().getMethods()) {
ReflectCache.putOverloadMethodCache(key, m);
}
}
然后调用boltServer#start方法启动服务
public void start() {
//如果已经启动了，那么直接返回
if (started) {
return;
}
synchronized (this) {
//双重检查锁
if (started) {
return;
}
// 生成Server对象，返回的是RpcServer实例
remotingServer = initRemotingServer();
try {
//调用bolt包里面的内容，通过netty启动服务
if (remotingServer.start()) {
if (LOGGER.isInfoEnabled()) {
LOGGER.info("Bolt server has been bind to {}:{}", serverConfig.getBoundHost(),
serverConfig.getPort());
}
} else {
throw new SofaRpcRuntimeException("Failed to start bolt server, see more detail from bolt log.");
}
//设置started参数为true
started = true;
if (EventBus.isEnable(ServerStartedEvent.class)) {
EventBus.post(new ServerStartedEvent(serverConfig, bizThreadPool));
}
} catch (SofaRpcRuntimeException e) {
throw e;
} catch (Exception e) {
throw new SofaRpcRuntimeException("Failed to start bolt server!", e);
}
}
}
注册服务
接下来就是调用register方法注册服务
protected void register() {
if (providerConfig.isRegister()) {
List<RegistryConfig> registryConfigs = providerConfig.getRegistry();
if (registryConfigs != null) {
for (RegistryConfig registryConfig : registryConfigs) {
//得到注册中心对象
Registry registry = RegistryFactory.getRegistry(registryConfig);
//初始化注册中心
registry.init();
registry.start();
try {
registry.register(providerConfig);
} catch (SofaRpcRuntimeException e) {
throw e;
} catch (Throwable e) {
String appName = providerConfig.getAppName();
if (LOGGER.isWarnEnabled(appName)) {
LOGGER.warnWithApp(appName, "Catch exception when register to registry: "
+ registryConfig.getId(), e);
}
}
}
}
}
}
这里主要是通过RegistryFactory获取不同的注册中心实现类
目前来说sofarpc主要实现了一下几种注册中心：
SOFARegistry
Zookeeper
本地文件
Consul
Nacos
注册中心的内容我打算放在接下来的文章中讲解，所以这里我们略过。
以上就是SOFARPC服务端暴露的全部内容