1. 问题背景
某应用在启动完提供JSF服务后，短时间内出现了大量的空指针异常。
分析日志，发现是服务依赖的藏经阁配置数据未加载完成导致。即所谓的有损上线或者是直接发布，当应用启动时，service还没加载完，就开始对外提供服务，导致失败调用。
关键代码如下
数据的初始化加载是通过实现CommandLineRunner接口完成的
1@Component 2public class LoadSystemArgsListener implements CommandLineRunner { 3 4 @Resource 5 private CacheLoader cjgConfigCacheLoader; 6 7 @Override 8 public void run(String... args) { 9 // 加载藏经阁配置 10 cjgConfigCacheLoader.refresh(); 11 12 } 13}
cjgConfigCacheLoader.refresh()方法内部会将数据加载到内存中
1/** 藏经阁配置数据 key:租户 value:配置数据 */ 2public static Map<String, CjgRuleConfig> cjgRuleConfigMap = new HashMap<>();
如果此时还未加载完数据，调用cjgRuleConfigMap.get("301").getXX()，则会报空指针异常
总结根因：JSF Provider发布早于服务依赖的初始化数据加载，导致失败调用
2. 问题解决
在解决此问题前，我们需要先回忆并熟悉下Spring Boot的启动过程、JSF服务的发布过程
1）Spring Boot的启动过程（版本2.0.7.RELEASE）
run方法，主要关注refreshContext(context)刷新上下文
1public ConfigurableApplicationContext run(String... args) { 2 // 创建 StopWatch 实例：用于计算启动时间 3 StopWatch stopWatch = new StopWatch(); 4 stopWatch.start(); 5 ConfigurableApplicationContext context = null; 6 Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>(); 7 configureHeadlessProperty(); 8 9 // 获取SpringApplicationRunListeners：这些监听器会在启动过程的各个阶段发送对应的事件 10 SpringApplicationRunListeners listeners = getRunListeners(args); 11 listeners.starting(); 12 try { 13 ApplicationArguments applicationArguments = new DefaultApplicationArguments( 14 args); 15 16 // 创建并配置Environment：包括准备好对应的`Environment`，以及将`application.properties`或`application.yml`中的配置项加载到`Environment`中 17 ConfigurableEnvironment environment = prepareEnvironment(listeners, 18 applicationArguments); 19 configureIgnoreBeanInfo(environment); 20 21 // 打印Banner：如果 spring.main.banner-mode 不为 off，则打印 banner 22 Banner printedBanner = printBanner(environment); 23 24 // 创建应用上下文：根据用户的配置和classpath下的配置，创建合适的`ApplicationContext` 25 context = createApplicationContext(); 26 exceptionReporters = getSpringFactoriesInstances( 27 SpringBootExceptionReporter.class, 28 new Class[] { ConfigurableApplicationContext.class }, context); 29 30 // 准备上下文：主要是将`Environment`、`ApplicationArguments`等关键属性设置到`ApplicationContext`中，以及加载`ApplicationListener`、`ApplicationRunner`、`CommandLineRunner`等。 31 prepareContext(context, environment, listeners, applicationArguments, 32 printedBanner); 33 34 // 刷新上下文：这是Spring IoC容器启动的关键，包括Bean的创建、依赖注入、初始化，发布事件等 35 refreshContext(context); 36 afterRefresh(context, applicationArguments); 37 stopWatch.stop(); 38 // 打印启动信息：如果 spring.main.log-startup-info 为 true，则打印启动信息 39 if (this.logStartupInfo) { 40 new StartupInfoLogger(this.mainApplicationClass) 41 .logStarted(getApplicationLog(), stopWatch); 42 } 43 // 发布 ApplicationStartedEvent：通知所有的 SpringApplicationRunListeners 应用已经启动 44 listeners.started(context); 45 46 // 调用 Runner：调用所有的ApplicationRunner和CommandLineRunner 47 callRunners(context, applicationArguments); 48 } 49 catch (Throwable ex) { 50 handleRunFailure(context, ex, exceptionReporters, listeners); 51 throw new IllegalStateException(ex); 52 } 53 54 try { 55 // 运行中：通知所有的 SpringApplicationRunListeners 应用正在运行 56 listeners.running(context); 57 } 58 catch (Throwable ex) { 59 handleRunFailure(context, ex, exceptionReporters, null); 60 throw new IllegalStateException(ex); 61 } 62 return context; 63}
refreshContext(context)内部调用refresh()方法，此方法主要关注finishBeanFactoryInitialization(beanFactory) 实例化Bean 早于 finishRefresh() 发生
1public void refresh() throws BeansException, IllegalStateException { 2 synchronized (this.startupShutdownMonitor) { 3 // 准备刷新的上下文环境：设置启动日期，激活上下文，清除原有的属性源 4 prepareRefresh(); 5 6 // 告诉子类启动 'refreshBeanFactory()' 方法，创建一个新的bean工厂。 7 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); 8 9 // 为 BeanFactory 设置上下文特定的后处理器：主要用于支持@Autowired和@Value注解 10 prepareBeanFactory(beanFactory); 11 12 try { 13 // 为 BeanFactory 的处理提供在子类中的后处理器。 14 postProcessBeanFactory(beanFactory); 15 16 // 调用所有注册的 BeanFactoryPostProcessor Bean 的处理方法。 17 invokeBeanFactoryPostProcessors(beanFactory); 18 19 // 注册 BeanPostProcessor 的处理器，拦截 Bean 创建。 20 registerBeanPostProcessors(beanFactory); 21 22 // 为此上下文初始化消息源。 23 initMessageSource(); 24 25 // 为此上下文初始化事件多播器。 26 initApplicationEventMulticaster(); 27 28 // 在特定的上下文子类中刷新之前的进一步初始化。 29 onRefresh(); 30 31 // 检查监听器 Bean 并注册它们：注册所有的ApplicationListenerbeans 32 registerListeners(); 33 34 // 实例化所有剩余的（非延迟初始化）单例。 35 finishBeanFactoryInitialization(beanFactory); 36 37 // 完成刷新：发布ContextRefreshedEvent，启动所有Lifecyclebeans，初始化所有剩余的单例（lazy-init 单例和非延迟初始化的工厂 beans）。 38 finishRefresh(); 39 } 40 ... 41 } 42 43 44
实例化Bean中，需熟悉Bean的生命周期（重要）
2）JSF Provider的发布过程（版本1.7.5-HOTFIX-T6）
类com.jd.jsf.gd.config.spring.ProviderBean调用方法com.jd.jsf.gd.config.ProviderConfig#export进行发布
JSF源码地址：http://xingyun.jd.com/codingRoot/jsf/jsf-sdk
1public class ProviderBean<T> extends ProviderConfig<T> implements InitializingBean, DisposableBean, ApplicationContextAware, ApplicationListener, BeanNameAware { 2 3 // 此处代码省略... 4 5 public void onApplicationEvent(ApplicationEvent event) { 6 if (event instanceof ContextRefreshedEvent && this.isDelay() && !this.exported && !CommonUtils.isUnitTestMode()) { 7 LOGGER.info("JSF export provider with beanName {} after spring context refreshed.", this.beanName); 8 if (this.delay < -1) { 9 Thread thread = new Thread(new Runnable() { 10 public void run() { 11 try { 12 Thread.sleep((long)(-ProviderBean.this.delay)); 13 } catch (Throwable var2) { 14 } 15 16 ProviderBean.this.export(); 17 } 18 }); 19 thread.setDaemon(true); 20 thread.setName("DelayExportThread"); 21 thread.start(); 22 } else { 23 this.export(); 24 } 25 } 26 27 } 28 29 private boolean isDelay() { 30 return this.supportedApplicationListener && this.delay < 0; 31 } 32 33 public void afterPropertiesSet() throws Exception { 34 // 此处代码省略... 35 36 if (!this.isDelay() && !CommonUtils.isUnitTestMode()) { 37 LOGGER.info("JSF export provider with beanName {} after properties set.", this.beanName); 38 this.export(); 39 } 40 41 } 42} 43 44
1public synchronized void export() throws InitErrorException { 2 if (this.delay > 0) { 3 Thread thread = new Thread(new Runnable() { 4 public void run() { 5 try { 6 Thread.sleep((long)ProviderConfig.this.delay); 7 } catch (Throwable var2) { 8 } 9 10 ProviderConfig.this.doExport(); 11 } 12 }); 13 thread.setDaemon(true); 14 thread.setName("DelayExportThread"); 15 thread.start(); 16 } else { 17 this.doExport(); 18 } 19 20} 21 22
可以看出Provider发布有两个地方
Ⅰ、Bean的初始化过程（delay>=0）
实现InitializingBean接口，重写afterPropertiesSet方法。这里会判断是否延迟发布，如果大于等于0，则会此处进行发布。具体在export方法中，当delay>0，则会延迟发布，如配置5000，表示延迟5秒发布；当delay=0，则立即发布。
Ⅱ、监听ContextRefreshedEvent事件触发（delay<0）
实现ApplicationListener接口，重写onApplicationEvent方法。属于事件ContextRefreshedEvent，当delay<-1，则会延迟发布，如配置-5000，表示延迟5秒发布；反之，则立即发布。
3）解决方案
场景1：XML方式自动发布Provider（常用）
由上面的介绍，了解到执行顺序：1.Bean初始化 > 2.ContextRefreshedEvent事件触发 > 3.调用ApplicationRunner或CommandLineRunner；
上面已经知道Provider发布处于1、2过程，需避免使用方式3进行数据的初始化。
前提建议：delay默认配置为-1，可以不配置，或者配置负数。则JSF Provider发布则处于过程2，即监听ContextRefreshedEvent事件触发
方式1：Bean的初始化过程中
解决方法：使用**@PostConstruct注解、实现InitializingBean接口、配置init-method方法均可**
1@Component 2public class DataLoader { 3 4 @PostConstruct 5 @Scheduled(cron = "${cron.config}") 6 public void loadData() { 7 // 数据加载 8 System.out.println("数据加载工作"); 9 } 10 11} 12 13
注意：该Bean如果依赖了其他Bean，需确保依赖Bean已实例化，否则会报空指针异常。
方式2：ContextRefreshedEvent事件触发
ContextRefreshedEvent事件是如何发布的
调用过程 AbstractApplicationContext#finishRefresh -> AbstractApplicationContext#publishEvent-> SimpleApplicationEventMulticaster#multicastEvent
1public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) { 2 ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event)); 3 for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) { 4 Executor executor = getTaskExecutor(); 5 if (executor != null) { 6 executor.execute(() -> invokeListener(listener, event)); 7 } 8 else { 9 invokeListener(listener, event); 10 } 11 } 12} 13 14
在SimpleApplicationEventMulticaster的multicastEvent方法中调用invokeListener()进行事件发布，getTaskExecutor()默认值是null（除自定义设置Executor对象），所有ApplicationListener实现类串行执行onApplicationEvent方法。
getApplicationListeners(event, type)获取所有的实现类，继续向下看内部会调用AnnotationAwareOrderComparator.sort(allListeners)对所有ApplicationListener进行排序，allListeners 是待排序的对象列表。该方法将根据对象上的排序注解或接口来确定排序顺序，并返回一个按照指定顺序排序的对象列表。具体来说，排序的规则如下：
1.首先，根据对象上的 @Order 注解的值进行排序。@Order 注解的值越小，排序优先级越高。
2.如果对象上没有 @Order 注解，或者多个对象的 @Order 注解值相同，则根据对象是否实现了 Ordered 接口进行排序。实现了 Ordered 接口的对象，可以通过 getOrder() 方法返回一个排序值。
3.如果对象既没有 @Order 注解，也没有实现 Ordered 接口，则使用默认的排序值 LOWEST_PRECEDENCE（Integer.MAX_VALUE）。特别的：如果BeanA和BeanB排序值都是默认值，则保持原顺序，即Bean的加载顺序
总结：默认情况所有ApplicationListener实现类串行执行onApplicationEvent方法，而顺序取决于AnnotationAwareOrderComparator.sort(allListeners)，@Order 注解的值越小，排序优先级越高
解决方法：使用@Order注解保证执行顺序早于ProviderBean
1@Component 2@Order(1) 3public class DataLoader implements ApplicationListener<ContextRefreshedEvent> { 4 @Override 5 public void onApplicationEvent(ContextRefreshedEvent event) { 6 // 数据准备 7 System.out.println("初始化工作"); 8 9 } 10}
此外带有@SpringBootApplication的启动类中实现也是可以的（在Spring Boot中默认使用基于注解的方式进行配置和管理Bean，所以注解定义的Bean会在XML定义的Bean之前被加载）
1@SpringBootApplication 2public class DemoApplication implements ApplicationListener<ContextRefreshedEvent> { 3 4 public static void main(String[] args) { 5 SpringApplication.run(DemoApplication.class, args); 6 } 7 8 @Override 9 public void onApplicationEvent(ContextRefreshedEvent event) { 10 System.out.println("初始化工作"); 11 } 12}
场景2：API方式发布Provider（较少使用）
应用启动完成后，先做初始化动作，完成后再手动发布Provider。这种就可以通过实现接口ApplicationRunner或接口CommandLineRunner去执行初始化。
1@Component 2public class DataLoader implements ApplicationRunner { 3 4 @Override 5 public void run(ApplicationArguments args) throws Exception { 6 // 数据准备 7 System.out.println("初始化工作"); 8 9 // 发布provider 10 // 参考：https://cf.jd.com/pages/viewpage.action?pageId=296129902 11 } 12} 13 14
场景3：XML方式手动发布（不常用）
provider的dynamic属性设置为false
| 标签 | 属性 | 类型 | 是否必填 | 默认值 | 描述 | | provider | dynamic | boolean | 否 | true | 是否动态注册Provider，默认为true，配置为false代表不主动发布，需要到管理端进行上线操作 |
3. 总结
RPC服务（如JSF、Dubbo）进行优雅上线，常用的两种方式：1、延迟发布 2、手动发动
如果你的服务需要一些初始化操作后才能对外提供服务，如初始化缓存（不限与藏经阁、ducc、mysql、甚至调用其他jsf服务）、redis连接池等相关资源就位，可以参考本文中介绍的几种方式。
此文是笔者通过读取源码+本地验证得出的结论，如有错误遗漏或者更好的方案还烦请各位指出共同进步！
作者：京东零售 郭宏宇
来源：京东云开发者社区 转载请注明来源