Spring Boot 啟動優(yōu)化實踐
一、前言
隨著業(yè)務(wù)的發(fā)展，筆者項目對應(yīng)的Spring Boot工程的依賴越來越多。隨著依賴數(shù)量的增長，Spring 容器需要加載更多組件、解析復(fù)雜依賴并執(zhí)行自動裝配，導(dǎo)致項目啟動時間顯著增長。在日常開發(fā)或測試過程中，一旦因為配置變更或者其他熱部署不生效的變更時，項目重啟就需要等待很長的時間影響代碼的交付。加快Spring項目的啟動可以更好的投入項目中，提升開發(fā)效率。
整體環(huán)境介紹：
- Spring版本：4.3.22
- Spring Boot版本：1.5.19
- CPU：i5-9500
- 內(nèi)存：24GB
- 優(yōu)化前啟動耗時：280秒
二、Spring Boot項目啟動流程介紹
Spring Boot項目主要啟動流程都在org.spring-framework.boot.SpringApplication#run(java.lang.String...)方法中：
public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
// Spring上下文
ConfigurableApplicationContext context = null;
FailureAnalyzers analyzers = null;
configureHeadlessProperty();
// 初始化SpringApplicationRunListener監(jiān)聽器
SpringApplicationRunListeners listeners = getRunListeners(args);
listeners.starting();
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(
args);
// 環(huán)境準備
ConfigurableEnvironment environment = prepareEnvironment(listeners,
applicationArguments);
// 打印banner
Banner printedBanner = printBanner(environment);
// 創(chuàng)建上下文
context = createApplicationContext();
analyzers = new FailureAnalyzers(context);
// 容器初始化
prepareContext(context, environment, listeners, applicationArguments,
printedBanner);
// 刷新容器內(nèi)容
refreshContext(context);
afterRefresh(context, applicationArguments);
// 結(jié)束監(jiān)聽廣播
listeners.finished(context, null);
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass)
.logStarted(getApplicationLog(), stopWatch);
}
return context;
} catch (Throwable ex) {
handleRunFailure(context, listeners, analyzers, ex);
throw new IllegalStateException(ex);
}
}可以看到在啟動流程中，監(jiān)聽器應(yīng)用在了應(yīng)用的多個生命周期中。并且Spring Boot中也預(yù)留了針對listener的擴展點。我們可以借此實現(xiàn)一個自己的擴展點去監(jiān)聽Spring Boot的每個階段的啟動耗時，實現(xiàn)如下：
@Slf4j
public class MySpringApplicationRunListener implements SpringApplicationRunListener{
private Long startTime;
public MySpringApplicationRunListener(SpringApplication application, String[] args){
}
@Override
public void starting(){
startTime = System.currentTimeMillis();
log.info("MySpringListener啟動開始 {}", LocalTime.now());
}
@Override
public void environmentPrepared(ConfigurableEnvironment environment){
log.info("MySpringListener環(huán)境準備 準備耗時：{}毫秒", (System.currentTimeMillis() - startTime));
startTime = System.currentTimeMillis();
}
@Override
public void contextPrepared(ConfigurableApplicationContext context){
log.info("MySpringListener上下文準備 耗時：{}毫秒", (System.currentTimeMillis() - startTime));
startTime = System.currentTimeMillis();
}
@Override
public void contextLoaded(ConfigurableApplicationContext context){
log.info("MySpringListener上下文載入 耗時：{}毫秒", (System.currentTimeMillis() - startTime));
startTime = System.currentTimeMillis();
}
@Override
public void finished(ConfigurableApplicationContext context, Throwable exception){
log.info("MySpringListener結(jié)束 耗時：{}毫秒", (System.currentTimeMillis() - startTime));
startTime = System.currentTimeMillis();
}
}接著還需要在classpath/META-INF目錄下新建spring.factories文件，并添加如下文件內(nèi)容：
org.springframework.boot.SpringApplicationRunListener=com.vivo.internet.gameactivity.api.web.MySpringApplicationRunListener至此，借助Listener機制，我們能夠追蹤Spring Boot啟動各階段的耗時分布，為后續(xù)性能優(yōu)化提供數(shù)據(jù)支撐。
contextLoaded事件是在run方法中的prepareContext()結(jié)束時調(diào)用的，因此contextLoaded事件和finished事件之間僅存在兩個語句：refreshContext(context)和afterRefresh(context,applicationArguements)消耗了285秒的時間，調(diào)試一下就能發(fā)現(xiàn)主要耗時在refreshContext()中。
三、AbstractApplicationContext#refresh
refreshContext()最終調(diào)用到org.spring-framework.context.support.AbstractApplicationContext#refresh方法中，這個方法主要是beanFactory的預(yù)準備、對beanFactory完成創(chuàng)建并進行后置處理、向容器添加bean并且給bean添加屬性、實例化所有bean。通過調(diào)試發(fā)現(xiàn)，finishBeanFactoryInitialization(beanFactory) 方法耗時最久。該方法負責實例化容器中所有的單例 Bean，是啟動性能的關(guān)鍵影響點。
四、找出實例化耗時的Bean
Spring Boot也是利用的Spring的加載流程。在Spring中可以實現(xiàn)InstantiationAwareBeanPost-Processor接口去在Bean的實例化和初始化的過程中加入擴展點。因此我們可以實現(xiàn)該接口并添加自己的擴展點找到處理耗時的Bean。
@Service
public class TimeCostCalBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
private Map<String, Long> costMap = Maps.newConcurrentMap();
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
if (!costMap.containsKey(beanName)) {
costMap.put(beanName, System.currentTimeMillis());
}
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
return true;
}
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
return pvs;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (costMap.containsKey(beanName)) {
Long start = costMap.get(beanName);
long cost = System.currentTimeMillis() - start;
// 只打印耗時長的bean
if (cost > 5000) {
System.out.println("bean: " + beanName + "\ttime: " + cost + "ms");
}
}
return bean;
}
}具體原理就是在Bean開始實例化之前記錄時間，在Bean初始化完成后記錄結(jié)束時間，打印實例化到初始化的時間差獲得Bean的加載總體耗時。結(jié)果如圖：
可以看到有許多耗時在10秒以上的類，接下來可以針對性的做優(yōu)化。值得注意的是，統(tǒng)計方式為單點耗時計算，未考慮依賴鏈上下文對整體加載順序的影響，實際優(yōu)化還需結(jié)合依賴關(guān)系分析。
五、singletonDataSource
@Bean(name = "singletonDataSource")
public DataSource singletonDataSource(DefaultDataSourceWrapper dataSourceWrapper) throws SQLException {
//先初始化連接
dataSourceWrapper.getMaster().init();
//構(gòu)建分庫分表數(shù)據(jù)源
String dataSource0 = "ds0";
Map<String, DataSource> dataSourceMap = new HashMap<>();
dataSourceMap.put(dataSource0, dataSourceWrapper.getMaster());
//分庫分表數(shù)據(jù)源
DataSource shardingDataSource = ShardingDataSourceFactory.createDataSource
(dataSourceMap,shardingRuleConfiguration, prop);
return shardingDataSource;
}singletonDataSource是一個分庫分表的數(shù)據(jù)源，連接池采用的是Druid，分庫分表組件采用的是公司內(nèi)部優(yōu)化后的中間件。通過簡單調(diào)試代碼發(fā)現(xiàn)，整個Bean耗時的過程發(fā)生在createDataSource方法，該方法中會調(diào)用createMetaData方法去獲取數(shù)據(jù)表的元數(shù)據(jù)，最終運行到loadDefaultTables方法。該方法如下圖，會遍歷數(shù)據(jù)庫中所有的表。因此數(shù)據(jù)庫中表越多，整體就越耗時。
筆者的測試環(huán)境數(shù)據(jù)庫中有很多的分表，這些分表為了和線上保持一致，分表的數(shù)量都和線上是一樣的。
因此在測試環(huán)境啟動時，為了加載這些分表會更加的耗時。可通過將分表數(shù)量配置化，使測試環(huán)境在不影響功能驗證的前提下減少分表數(shù)量，從而加快啟動速度。
六、初始化異步
activityServiceImpl啟動中，主要會進行活動信息的查詢初始化，這是一個耗時的操作。類似同樣的操作在工程的其他類中也存在。
@Service
public class ActivityServiceImpl implements ActivityService, InitializingBean{
// 省略無關(guān)代碼
@Override
public void afterPropertiesSet() throws Exception {
initActivity();
}
// 省略無關(guān)代碼
}可以通過將afterPropertiesSet()異步化的方式加速項目的啟動。
觀察Spring源碼可以注意到afterPropertiesSet方法是在AbstractAutowireCapableBeanFactory#invokeInitMethods中調(diào)用的。在這個方法中，不光處理了afterPropertiesSet方法，也處理了init-method。
因此我們可以寫一個自己的BeanFactory繼承AbstractAutowireCapableBeanFactory，將invokeInitMethods方法進行異步化重寫。考慮到AbstractAutowireCapableBeanFactory是個抽象類，有額外的抽象方法需要實現(xiàn)，因此繼承該抽象類的子類DefaultListableBeanFactory。具體實現(xiàn)代碼如下：
public class AsyncInitListableBeanFactory extends DefaultListableBeanFactory{
public AsyncInitBeanFactory(ConfigurableListableBeanFactory beanFactory){
super(beanFactory);
}
@Override
protected void invokeInitMethods(String beanName, Object bean, RootBeanDefinition mbd)throws Throwable {
if (beanName.equals("activityServiceImpl")) {
AsyncTaskExecutor.submitTask(() -> {
try {
super.invokeInitMethods(beanName, bean, mbd);
} catch (Throwable throwable) {
throwable.printStackTrace();
}
});
} else {
super.invokeInitMethods(beanName, bean, mbd);
}
}
}又因為Spring在refreshContext()方法之前的prepareContext()發(fā)放中針對initialize方法提供了接口擴展(applyInitializers())。因此我們可以通過實現(xiàn)該接口并將我們的新的BeanFactory通過反射的方式更新到Spring的初始化流程之前。
public interface ApplicationContextInitializer<C extends ConfigurableApplicationContext> {
/**
* Initialize the given application context.
* @param applicationContext the application to configure
*/
void initialize(C applicationContext);
}改造后的代碼如下，新增AsyncAccelerate-Initializer類實現(xiàn)ApplicationContextInitializer接口：
public class AsyncBeanFactoryInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
@SneakyThrows
@Override
public void initialize(ConfigurableApplicationContext applicationContext){
if (applicationContext instanceof GenericApplicationContext) {
AsyncInitListableBeanFactory beanFactory = new AsyncInitListableBeanFactory(applicationContext.getBeanFactory());
Field field = GenericApplicationContext.class.getDeclaredField("beanFactory");
field.setAccessible(true);
field.set(applicationContext, beanFactory);
}
}
}
public class AsyncBeanInitExecutor{
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final AtomicReference<ThreadPoolExecutor> THREAD_POOL_REF = new AtomicReference<>();
private static final List<Future<?>> FUTURES = new ArrayList<>();
/**
* 創(chuàng)建線程池實例
*/
private static ThreadPoolExecutor createThreadPoolExecutor(){
int poolSize = CPU_COUNT + 1;
return new ThreadPoolExecutor(poolSize, poolSize, 50L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new ThreadPoolExecutor.CallerRunsPolicy()
);
}
/**
* 確保線程池已初始化（線程安全）
*/
private static void ensureThreadPoolExists(){
if (THREAD_POOL_REF.get() != null) {
return;
}
ThreadPoolExecutor executor = createThreadPoolExecutor();
if (!THREAD_POOL_REF.compareAndSet(null, executor)) {
executor.shutdown(); // 另一線程已初始化成功
}
}
/**
* 提交異步初始化任務(wù)
*
* @param task 初始化任務(wù)
* @return 提交后的 Future 對象
*/
public static Future<?> submitInitTask(Runnable task) {
ensureThreadPoolExists();
Future<?> future = THREAD_POOL_REF.get().submit(task);
FUTURES.add(future);
return future;
}
/**
* 等待所有初始化任務(wù)完成并釋放資源
*/
public static void waitForInitTasks(){
try {
for (Future<?> future : FUTURES) {
future.get();
}
} catch (Exception ex) {
throw new RuntimeException("Async init task failed", ex);
} finally {
FUTURES.clear();
shutdownThreadPool();
}
}
/**
* 關(guān)閉線程池并重置引用
*/
private static void shutdownThreadPool(){
ThreadPoolExecutor executor = THREAD_POOL_REF.getAndSet(null);
if (executor != null) {
executor.shutdown();
}
}
}實現(xiàn)類后，還需要在META-INF/spring.factories下新增說明org.springframework.context.Applicatinotallow=com.xxx.AsyncAccelerateInitializer，這樣這個類才能真正生效。
這樣異步化以后還有一個點需要注意，如果該初始化方法執(zhí)行耗時很長，那么會存在Spring容器已經(jīng)啟動完成，但是異步初始化任務(wù)沒執(zhí)行完的情況，可能會導(dǎo)致空指針等異常。為了避免這種問題的發(fā)生，還要借助于Spring容器啟動中finishRefresh()方法，監(jiān)聽對應(yīng)事件，確保異步任務(wù)執(zhí)行完成之后，再啟動容器。
public class AsyncInitCompletionListener implements ApplicationListener<ContextRefreshedEvent>, ApplicationContextAware, PriorityOrdered{
private ApplicationContext currentContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext)throws BeansException {
this.currentContext = applicationContext;
}
@Override
public void onApplicationEvent(ContextRefreshedEvent event){
if (event.getApplicationContext() == currentContext) {
AsyncBeanInitExecutor.waitForInitTasks();
}
}
@Override
public int getOrder(){
return Ordered.HIGHEST_PRECEDENCE;
}
}七、總結(jié)
啟動優(yōu)化后的項目實際測試結(jié)果如下：
通過異步化初始化和分庫分表加載優(yōu)化，項目啟動時間從 280 秒縮短至 159 秒，提升約 50%。這對于提升日常開發(fā)效率、加快測試與聯(lián)調(diào)流程具有重要意義。
