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();
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

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