springboot启动后加载字典表数据供业务调用

需求：在springboot项目启动完毕之后，自动查询业务字典表，将查询结果存入缓存，供其他代码模块调用（如果数据库中更新了字典表，则需要重新启动项目才能完成更新）

实现方式：

1.配置类实现CommandLineRunner接口作为项目启动入口类

2.业务字典缓存处理类，由上一步调用，将数据存入缓存

3.其他相关工具类

package org.jeecg.modules.config;

import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import lombok.extern.slf4j.Slf4j;

/**
 * @Description 字典缓存初始化
 * <pre>
 * 将业务字典表的数据初始化到缓存
 * </pre>
 *
 * 
 * @author sgc
 * @date 2021-07-13
 */
@Slf4j
@Component
@Order(2)
public class ResDictRunner implements CommandLineRunner {
 
    @Override
    public void run(String... args) throws Exception {
        log.info("初始化字典表到缓存中...");
        ResDictCache.load();
        log.info("初始化完毕.");
    }
}

package org.jeecg.modules.config;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.jeecg.module.pojo.service.ResDict;
import org.jeecg.modules.resources.mapper.ResDictMapper;
import org.springframework.util.CollectionUtils;

import lombok.extern.slf4j.Slf4j;

/**
 * @Description 业务字典缓存工具类
 * <pre>
 * 项目启动的时候将字典表处理之后加入缓存，提供给业务代码逻辑调用
 * 注意：数据库修改之后，需要重新启动项目才能更新
 * </pre>
 *
 * 
 * @author sgc
 * @date 2021-07-13
 */
@Slf4j
public class ResDictCache {

    private static ResDictMapper resDictMapper;

    public static Map<String, List<ResDict>> cache = new HashMap<>();

    /**
     * 初始化字典表
     * 
     * @author sgc
     * @date 2021-07-13
     */
    public static void load() {
    	cache.clear();
    	resDictMapper = SpringUtils.getBean(ResDictMapper.class);
        List<ResDict> all = resDictMapper.selectList(null);
        cache = all.stream().collect(Collectors.groupingBy(ResDict::getDictType));
//        if(log.isInfoEnabled()){
//            log.info("初始化完毕.");
//        }
//        log.info("获取示例：{}", getDictsByType("SIGN_TYPE"));
        
    }

    /**
     * 返回list数据格式
     * 
     * @author sgc
     * @date 2021-07-13
     */
    public static List<ResDict> getDictsByType(String findType){
        List<ResDict> dictionariesList = cache.get(findType);
        if(CollectionUtils.isEmpty(dictionariesList)){
            return new ArrayList<>();
        }
        return cache.get(findType);
    }

}

package org.jeecg.modules.config;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;

/**
 * @Description 字典表初始化工具类
 * 
 * @author sgc
 * @date 2021-07-13
 */
@SuppressWarnings("unchecked")
@Component
public class SpringUtils implements BeanFactoryPostProcessor {

    private static ConfigurableListableBeanFactory beanFactory; // Spring应用上下文环境

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        SpringUtils.beanFactory = beanFactory;
    }

    /**
     * 获取对象
     *
     * @param name
     * @return Object 一个以所给名字注册的bean的实例
     * @throws BeansException
     *
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) throws BeansException {
        //首字母默认小写
        name=lowerCaseInit(name);
        if (containsBean(name)) {
            return (T) beanFactory.getBean(name);
        }else{
            return null;
        }
    }

    /**
     * 获取类型为requiredType的对象
     *
     * @param clz
     * @return
     * @throws BeansException
     *
     */
    public static <T> T getBean(Class<T> clz) throws BeansException {
        @SuppressWarnings("unchecked")
        T result = (T) beanFactory.getBean(clz);
        return result;
    }

    /**
     * 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
     *
     * @param name
     * @return boolean
     */
    public static boolean containsBean(String name) {
        return beanFactory.containsBean(name);
    }

    /**
     * 判断以给定名字注册的bean定义是一个singleton还是一个prototype。
     * 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
     *
     * @param name
     * @return boolean
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
        return beanFactory.isSingleton(name);
    }

    /**
     * @param name
     * @return Class 注册对象的类型
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static Class<?> getType(String name) throws NoSuchBeanDefinitionException {
        return beanFactory.getType(name);
    }

    /**
     * 如果给定的bean名字在bean定义中有别名，则返回这些别名
     *
     * @param name
     * @return
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {
        return beanFactory.getAliases(name);
    }

    /**
     * 首字母小写
     * 
     * @param str 小写的首字母
     * @return
     */
    private static String lowerCaseInit(String str) {
        if (str.length()>0) {
            char c = str.charAt(0);
            if (c >= 65 && c <= 90) {
                int i = c + 32;
                return ((char)i)+str.substring(1);
            }else{
                return str;
            }
        }else{
            return  null;
        }
    }
}