springboot项目启动，定时获取数据库信息，并保存至缓存中，减少程序与数据库交互问题。

在springboot项目中，以空间换时间的思想，解决程序中与数据库交互过多造成数据库压力过大，响应时间过长问题，可以考虑在项目启动之后预先把需要的数据从数据库中加载到内存，之后的程序处理时减少与数据库的交互，缩短处理时间。

import com.alibaba.fastjson.JSON;
import com.asiainfo.common.Constantskey;
import com.asiainfo.service.RedisFilterService;
import org.apache.commons.lang3.concurrent.BasicThreadFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;
@Component
public class DataCacheToMapUtil {
    @Autowired
    private TestService testService;
    private static final Logger LOGGER = LoggerFactory.getLogger(DataMapUtil.class);
    /**
     * 自动刷新时间（单位为秒）
     */
    private static final Integer EXPIRE_SENCOND = 60*60*24*30;
    /**
     * 存储数据的容器
     */
    private static final ConcurrentHashMap<String, String> DATA_MAP = new ConcurrentHashMap<>();

    /**
     * 缓存数据key
     */
    public static final String TEST_KEY = "test_key";
    /**
     * 获取全部缓存数据
     */
    public Map<String, String> getDataMap() {
        return DATA_MAP;
    }

    /**
     * Spring Bean创建之后执行的方法
     */
    @PostConstruct
    public void initMethod() {
        ExecutorService pool = new ThreadPoolExecutor(1, 1, 0L,
                TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(1),
                new BasicThreadFactory.Builder().namingPattern("data-map-pool-%d").daemon(true).build(),
                new ThreadPoolExecutor.AbortPolicy());
        pool.execute(new Task());
        pool.shutdown();
    }

    /**
     * 初始化方法，查询数据库数据储存到map中
     */
    private void initDataMap() {
        // 测试表数据
        setDataMap(DataMapUtil.TEST_KEY, testService.searchAll());
    }

    /**
     * 获取map缓存的对象
     */
    public static <T> T getObject(String key, Class<T> clazz) {
        return json2Object(DATA_MAP.get(key), clazz);
    }

	//获取map缓存的集合数据
    public static <T> List<T> getList(String key, Class<T> clazz) {
        return json2List(DATA_MAP.get(key), clazz);
    }
	//缓存对象数据到map中
    private <T> void setDataMap(String key, T value) {
        DATA_MAP.put(key, object2Json(value));
    }
	//缓存集合数据到map中
    private <T> void setDataMap(String key, List<T> value) {
        DATA_MAP.put(key, list2Json(value));
    }

    /**
     * json转换为Object
     */
    public static <T> T json2Object(String json, Class<T> clazz) {
        try {
            return JSON.parseObject(json, clazz);
        } catch (Exception e) {
            LOGGER.error("{} 转 JSON 失败", json);
        }
        return null;
    }

    /**
     * 对象转json
     */
    public static <T> String object2Json(T object){
        String json = JSON.toJSONString(object);
        return json;
    }

    /**
     * list转json
     */
    public static <T> String list2Json(List<T> list) {
        String jsons = JSON.toJSONString(list);
        return jsons;
    }

    /**
     * 获取key对应的List集合
     */
    public static <T> List<T> json2List(String json, Class<T> clazz) {
        List<T> list = JSON.parseArray(json, clazz);
        return list;
    }

    /**
     * 初始化及定时刷新
     */
    class Task implements Runnable {
        @Override
        public void run() {
            while (true) {
                LOGGER.info("=================初始化设备规划数据================= start");
                initDataMap();
                LOGGER.info("=================初始化设备规划数据=================  end");
                try {
                    Thread.sleep(EXPIRE_SENCOND * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

积跬步，以至千里，与君共勉。