1.Spring项目启动时，加载相关初始化配置

Spring项目启动时，会加载一些常用的配置：

1、加载spring上下文

SpringApplicationContextUtils.initApplicationContext(event.getServletContext());

2、加载属性文件

EsbCommsUtils.initComms(event.getServletContext());

public class EsbCommsUtils {
    
    private static Log logger = LogFactory.getLog(EsbCommsUtils.class);
    
    public static final Properties properties = new Properties();
        
    public static void initComms(ServletContext sct){
        try{
            properties.load(sct.getResourceAsStream("/WEB-INF/conf/comms.properties"));
        }catch(Exception e){
            logger.error("加载comms.properties文件异常,cause:"+e.getMessage());
        }
    }
    
    public static String getCommsValue(String key){
        return properties.getProperty(key, null);
    }
    
}

3、加载本地緩存，定时轮询刷新（定义定时线程池，1个线程）

cacheManager = (CacheManager)SpringApplicationContextUtils.getBean(EsbUtils.CACHEMANAGER);
cacheManager.loadAllCache();

package com.zat.mesb.base;

import com.zat.mesb.util.EsbCommsUtils;
import com.zat.sproxy.thread.NamedThreadFactory;
import org.springframework.stereotype.Controller;

import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;


@Controller
public class CacheManager {
    
    private List<AbstractCache> listCaches;
    
       // 定义定时线程池，1个线程
18     private final ScheduledExecutorService scheduled = Executors.newScheduledThreadPool(1, new NamedThreadFactory("reloadcache", true));
    
    public List<AbstractCache> getListCaches() {
        return listCaches;
    }

    public void setListCaches(List<AbstractCache> listCaches) {
        this.listCaches = listCaches;
    }
    
　　　　// 定时查询参数
28     public void loadAllCache() {
29         //loadCache();
30         this.scheduled.scheduleWithFixedDelay(new Runnable() {
31 
32             @Override
33             public void run() {
34                 loadCache();
35             }
36         }, 1L, Long.valueOf(EsbCommsUtils.getCommsValue("flush.cache.data")), TimeUnit.SECONDS);
37     }
    
    private void loadCache() {    
        if(this.listCaches != null){
            for(AbstractCache cache : listCaches) {
                cache.loadCache();
            }
        }
    }

    public Object getCacheBySimpleClassName(String className){
        if(this.listCaches != null){
            for(AbstractCache cache : listCaches){
                if(cache.getClass().getSimpleName().equalsIgnoreCase(className)){
                    return cache.getCacheList();
                }
            }
        }
        return null;
    }
    
    public Object getCacheValueByKey(String className, String key){
        if(this.listCaches != null){
            for(AbstractCache cache : listCaches){
                if(cache.getClass().getSimpleName().equalsIgnoreCase(className)){
                    return cache.cacheMaps.get(key);
                }
            }
        }
        return null;
    }
    
    public Object getCacheValueByKey(String className, String key, String type){
        if(this.listCaches != null){
            for(AbstractCache cache : listCaches){
                if(cache.getClass().getSimpleName().equalsIgnoreCase(className)){
                    return cache.getCacheMaps().get(key);
                }
            }
        }
        return null;
    }
    
    public void clearCache(){
        if(this.listCaches != null){
            for(AbstractCache cache : listCaches){
                cache.clearCache();
            }
        }
    }

}

完整示例代码：

package com.zat.mesb.listener;


import com.zat.mesb.base.CacheManager;
import com.zat.mesb.stage.processor.StageProcessorManager;
import com.zat.mesb.util.*;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.web.context.ContextLoaderListener;

import javax.servlet.ServletContextEvent;

public class EsbListener extends ContextLoaderListener {
    
    private static Log logger = LogFactory.getLog(EsbListener.class);
    private CacheManager cacheManager;

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        super.contextDestroyed(sce);
    }

    @Override
    public void contextInitialized(ServletContextEvent event) {
        super.contextInitialized(event);
        logger.info("1.开始加载spring上下文...");
        SpringApplicationContextUtils.initApplicationContext(event.getServletContext());
        EsbCommsUtils.initComms(event.getServletContext());
        logger.info("1.加载spring上下文完成...");    

        logger.info("2.开始加载本地緩存...");
        cacheManager = (CacheManager)SpringApplicationContextUtils.getBean(EsbUtils.CACHEMANAGER);
        cacheManager.loadAllCache();
        logger.info("2.加载本地緩存完成...");
        
        logger.info("3.开始加載BusHandlers配置信息...");
        BusHandlerUtils.initBusHandlers(event.getServletContext());
        logger.info("3.加載BusHandlers配置信息完成...");

        logger.info("4.开始加載ApiHandlers配置信息...");
        ApiHandlerUtils.initApiHandlers(event.getServletContext());
        logger.info("4.加載ApiHandlers配置信息完成...");

        logger.info("5.开始加載ApiAlipayHandlers配置信息...");
        ApiAlipayHandlerUtils.initApiAlipayHandlers(event.getServletContext());
        logger.info("5.加載ApiAlipayHandlers配置信息完成...");

        logger.info("6.開始初始化業務階段流程...");
        Thread thread = StageProcessorManager.getInstance();
        thread.setPriority(Thread.MAX_PRIORITY);
        thread.start();
        if(thread != null && thread.isAlive()){
            try {
                thread.join();
            } catch (InterruptedException e) {
                logger.error("Init stage process error,cause:"+e.getMessage());
            }
        }
        logger.info("6.初始化業務階段流程完成...");
    }

}