Linux服务器使用Redis作为数据缓存，并用log4j2进行日志记录 ...

前言
个人网站使用Vue作为前端，SpringBoot作为后端，MySQL作为数据库，但前端每次请求都会从MySQL数据库中读取数据，而MySQL数据库的数据是存储于服务器磁盘中，所以响应速度有一定影响。之前了解过一点Redis数据库，该数据库数据存储于内存中（也可以持久化于磁盘中），数据读取速度就会比存储于磁盘中的MySQL快很多，故想把Redis数据库应用于该网站项目中。

一、安装Redis

Linux系统安装Redis比较简单，可以直接通过命令行安装，安装过程比较简单，在此就不赘述，下列出一些常用命令

1. # 更新apt
2. sudo apt update
3. # 安装Redis
4. sudo apt-get install redis-server
5. # 设置密码（在配置文件redis.conf中，位置在 /etc/redis/redis.conf)
6. requirepass ******
8. # 启动Redis服务
9. service redis-server start
10. # 停止Redis服务
11. service redis-server stop
12. # 重启Redis服务
13. service redis-server restart
15. # 启动Redis客户端
16. redis-cli
17. # 测试Redis是否连接
18. 127.0.0.1:6379> ping

复制代码

注意：需要修改Redis配置文件中的保护模式“protected-mode"为修改为no，否则会出现无法连接的情况

1. # 修改保护模式为no
2. # protected-mode yes
3. protected-mode no
5. # 若不修改可能无法连接Redis，出现以下错误
6. org.springframework.data.redis.RedisConnectionFailureException: Unable to connect to Redis; nested exception is io.lettuce.core.RedisConnectionException: Unable to connect to 127.0.0.1:6379
7.         at org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory$ExceptionTranslatingConnectionProvider.translateException(LettuceConnectionFactory.java:1689)
8.         at org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory$ExceptionTranslatingConnectionProvider.getConnection(LettuceConnectionFactory.java:1597)
9. ······
10. ······
11. ······
12. Caused by: io.lettuce.core.RedisConnectionException: Unable to connect to 127.0.0.1:6379
13.         at io.lettuce.core.RedisConnectionException.create(RedisConnectionException.java:78)
14.         at io.lettuce.core.RedisConnectionException.create(RedisConnectionException.java:56)
15. ······
16. ······
17. ······
18. Caused by: java.lang.IllegalStateException: RedisHandshakeHandler not registered
19.         at io.lettuce.core.AbstractRedisClient.lambda$initializeChannelAsync0$6(AbstractRedisClient.java:431)
20.         at io.netty.util.concurrent.DefaultPromise.notifyListener0(DefaultPromise.java:590)
21. ······
22. ······
23. ······

复制代码

二、SpringBoot项目集成Redis

1、pom.xml添加依赖

1. <dependency>
2.     <groupId>org.springframework.boot</groupId>
3.     <artifactId>spring-boot-starter-data-redis</artifactId>
4. </dependency>

复制代码

2、Redis数据库连接配置 application.yml

1. # Redis
2. redis:
3. # 服务器地址
4. host: 127.0.0.1
5. # 服务器端口号
6. port: 6379
7. # 使用的数据库索引
8. database: 0
9. # 连接超时时间
10. timeout: 10000
11. # 设置密码
12. password: ******
13. lettuce:
14.   # 连接池
15.   pool:
16.     # 最大阻塞等待时间，负数表示没有限制
17.     max-wait: -1
18.     # 连接池中最大空闲
19.     max-idle: 5
20.     # 连接池中最小空闲
21.     min-idle: 0
22.     # 连接池最大连接数
23.     max-active: 20

复制代码

3、Redis配置类RedisConfig

1. package cn.huskysir.Config;
3. import com.fasterxml.jackson.annotation.JsonAutoDetect;
4. import com.fasterxml.jackson.annotation.PropertyAccessor;
5. import com.fasterxml.jackson.databind.ObjectMapper;
6. import org.springframework.cache.annotation.CachingConfigurerSupport;
7. import org.springframework.cache.annotation.EnableCaching;
8. import org.springframework.context.annotation.Bean;
9. import org.springframework.context.annotation.Configuration;
10. import org.springframework.data.redis.connection.RedisConnectionFactory;
11. import org.springframework.data.redis.core.*;
12. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
13. import org.springframework.data.redis.serializer.StringRedisSerializer;
15. @Configuration
16. @EnableCaching //开启注解
17. public class RedisConfig extends CachingConfigurerSupport {
19.     /**
20.      * retemplate相关配置
21.      */
22.     @Bean
23.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
25.         RedisTemplate<String, Object> template = new RedisTemplate<>();
26.         // 配置连接工厂
27.         template.setConnectionFactory(factory);
29.         //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
30.         Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
32.         ObjectMapper om = new ObjectMapper();
33.         // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
34.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
35.         // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
36.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
37.         jacksonSeial.setObjectMapper(om);
39.         // 值采用json序列化
40.         template.setValueSerializer(jacksonSeial);
41.         //使用StringRedisSerializer来序列化和反序列化redis的key值
42.         template.setKeySerializer(new StringRedisSerializer());
44.         // 设置hash key 和value序列化模式
45.         template.setHashKeySerializer(new StringRedisSerializer());
46.         template.setHashValueSerializer(jacksonSeial);
47.         template.afterPropertiesSet();
49.         return template;
50.     }
52.     /**
53.      * 对hash类型的数据操作
54.      */
55.     @Bean
56.     public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
57.         return redisTemplate.opsForHash();
58.     }
60.     /**
61.      * 对redis字符串类型数据操作
62.      */
63.     @Bean
64.     public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
65.         return redisTemplate.opsForValue();
66.     }
68.     /**
69.      * 对链表类型的数据操作
70.      */
71.     @Bean
72.     public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
73.         return redisTemplate.opsForList();
74.     }
76.     /**
77.      * 对无序集合类型的数据操作
78.      */
79.     @Bean
80.     public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
81.         return redisTemplate.opsForSet();
82.     }
84.     /**
85.      * 对有序集合类型的数据操作
86.      */
87.     @Bean
88.     public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
89.         return redisTemplate.opsForZSet();
90.     }
91. }

复制代码

4、Redis工具类RedisUtil

1. package cn.huskysir.Utils;
3. import org.springframework.data.redis.core.RedisTemplate;
4. import org.springframework.stereotype.Component;
5. import org.springframework.util.CollectionUtils;
7. import javax.annotation.Resource;
8. import java.util.Collection;
9. import java.util.List;
10. import java.util.Map;
11. import java.util.Set;
12. import java.util.concurrent.TimeUnit;
14. @Component
15. public class RedisUtil {
17.     @Resource
18.     private RedisTemplate<String, Object> redisTemplate;
20.     public RedisUtil(RedisTemplate<String, Object> redisTemplate) {
21.         this.redisTemplate = redisTemplate;
22.     }
24.     /**
25.      * 指定缓存失效时间
26.      *
27.      * @param key  键
28.      * @param time 时间(秒)
29.      * @return
30.      */
31.     public boolean expire(String key, long time) {
32.         try {
33.             if (time > 0) {
34.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
35.             }
36.             return true;
37.         } catch (Exception e) {
38.             e.printStackTrace();
39.             return false;
40.         }
41.     }
43.     /**
44.      * 根据key 获取过期时间
45.      *
46.      * @param key 键 不能为null
47.      * @return 时间(秒) 返回0代表为永久有效
48.      */
49.     public long getExpire(String key) {
50.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
51.     }
53.     /**
54.      * 判断key是否存在
55.      *
56.      * @param key 键
57.      * @return true 存在 false不存在
58.      */
59.     public boolean hasKey(String key) {
60.         try {
61.             return redisTemplate.hasKey(key);
62.         } catch (Exception e) {
63.             e.printStackTrace();
64.             return false;
65.         }
66.     }
68.     /**
69.      * 删除缓存
70.      *
71.      * @param key 可以传一个值 或多个
72.      */
73.     @SuppressWarnings("unchecked")
74.     public void del(String... key) {
75.         if (key != null && key.length > 0) {
76.             if (key.length == 1) {
77.                 redisTemplate.delete(key[0]);
78.             } else {
79.                 redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
80.             }
81.         }
82.     }
84.     //============================String=============================
86.     /**
87.      * 普通缓存获取
88.      *
89.      * @param key 键
90.      * @return 值
91.      */
92.     public Object get(String key) {
93.         return key == null ? null : redisTemplate.opsForValue().get(key);
94.     }
96.     /**
97.      * 普通缓存放入
98.      *
99.      * @param key   键
100.      * @param value 值
101.      * @return true成功 false失败
102.      */
103.     public boolean set(String key, Object value) {
104.         try {
105.             redisTemplate.opsForValue().set(key, value);
106.             return true;
107.         } catch (Exception e) {
108.             e.printStackTrace();
109.             return false;
110.         }
111.     }
113.     /**
114.      * 普通缓存放入并设置时间
115.      *
116.      * @param key   键
117.      * @param value 值
118.      * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
119.      * @return true成功 false 失败
120.      */
121.     public boolean set(String key, Object value, long time) {
122.         try {
123.             if (time > 0) {
124.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
125.             } else {
126.                 set(key, value);
127.             }
128.             return true;
129.         } catch (Exception e) {
130.             e.printStackTrace();
131.             return false;
132.         }
133.     }
135.     /**
136.      * 递增
137.      *
138.      * @param key   键
139.      * @param delta 要增加几(大于0)
140.      * @return
141.      */
142.     public long incr(String key, long delta) {
143.         if (delta < 0) {
144.             throw new RuntimeException("递增因子必须大于0");
145.         }
146.         return redisTemplate.opsForValue().increment(key, delta);
147.     }
149.     /**
150.      * 递减
151.      *
152.      * @param key   键
153.      * @param delta 要减少几(小于0)
154.      * @return
155.      */
156.     public long decr(String key, long delta) {
157.         if (delta < 0) {
158.             throw new RuntimeException("递减因子必须大于0");
159.         }
160.         return redisTemplate.opsForValue().increment(key, -delta);
161.     }
163.     //================================Map=================================
165.     /**
166.      * HashGet
167.      *
168.      * @param key  键 不能为null
169.      * @param item 项 不能为null
170.      * @return 值
171.      */
172.     public Object hget(String key, String item) {
173.         return redisTemplate.opsForHash().get(key, item);
174.     }
176.     /**
177.      * 获取hashKey对应的所有键值
178.      *
179.      * @param key 键
180.      * @return 对应的多个键值
181.      */
182.     public Map<Object, Object> hmget(String key) {
183.         return redisTemplate.opsForHash().entries(key);
184.     }
186.     /**
187.      * HashSet
188.      *
189.      * @param key 键
190.      * @param map 对应多个键值
191.      * @return true 成功 false 失败
192.      */
193.     public boolean hmset(String key, Map<String, Object> map) {
194.         try {
195.             redisTemplate.opsForHash().putAll(key, map);
196.             return true;
197.         } catch (Exception e) {
198.             e.printStackTrace();
199.             return false;
200.         }
201.     }
203.     /**
204.      * HashSet 并设置时间
205.      *
206.      * @param key  键
207.      * @param map  对应多个键值
208.      * @param time 时间(秒)
209.      * @return true成功 false失败
210.      */
211.     public boolean hmset(String key, Map<String, Object> map, long time) {
212.         try {
213.             redisTemplate.opsForHash().putAll(key, map);
214.             if (time > 0) {
215.                 expire(key, time);
216.             }
217.             return true;
218.         } catch (Exception e) {
219.             e.printStackTrace();
220.             return false;
221.         }
222.     }
224.     /**
225.      * 向一张hash表中放入数据,如果不存在将创建
226.      *
227.      * @param key   键
228.      * @param item  项
229.      * @param value 值
230.      * @return true 成功 false失败
231.      */
232.     public boolean hset(String key, String item, Object value) {
233.         try {
234.             redisTemplate.opsForHash().put(key, item, value);
235.             return true;
236.         } catch (Exception e) {
237.             e.printStackTrace();
238.             return false;
239.         }
240.     }
242.     /**
243.      * 向一张hash表中放入数据,如果不存在将创建
244.      *
245.      * @param key   键
246.      * @param item  项
247.      * @param value 值
248.      * @param time  时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
249.      * @return true 成功 false失败
250.      */
251.     public boolean hset(String key, String item, Object value, long time) {
252.         try {
253.             redisTemplate.opsForHash().put(key, item, value);
254.             if (time > 0) {
255.                 expire(key, time);
256.             }
257.             return true;
258.         } catch (Exception e) {
259.             e.printStackTrace();
260.             return false;
261.         }
262.     }
264.     /**
265.      * 删除hash表中的值
266.      *
267.      * @param key  键 不能为null
268.      * @param item 项 可以使多个 不能为null
269.      */
270.     public void hdel(String key, Object... item) {
271.         redisTemplate.opsForHash().delete(key, item);
272.     }
274.     /**
275.      * 判断hash表中是否有该项的值
276.      *
277.      * @param key  键 不能为null
278.      * @param item 项 不能为null
279.      * @return true 存在 false不存在
280.      */
281.     public boolean hHasKey(String key, String item) {
282.         return redisTemplate.opsForHash().hasKey(key, item);
283.     }
285.     /**
286.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
287.      *
288.      * @param key  键
289.      * @param item 项
290.      * @param by   要增加几(大于0)
291.      * @return
292.      */
293.     public double hincr(String key, String item, double by) {
294.         return redisTemplate.opsForHash().increment(key, item, by);
295.     }
297.     /**
298.      * hash递减
299.      *
300.      * @param key  键
301.      * @param item 项
302.      * @param by   要减少记(小于0)
303.      * @return
304.      */
305.     public double hdecr(String key, String item, double by) {
306.         return redisTemplate.opsForHash().increment(key, item, -by);
307.     }
309.     //============================set=============================
311.     /**
312.      * 根据key获取Set中的所有值
313.      *
314.      * @param key 键
315.      * @return
316.      */
317.     public Set<Object> sGet(String key) {
318.         try {
319.             return redisTemplate.opsForSet().members(key);
320.         } catch (Exception e) {
321.             e.printStackTrace();
322.             return null;
323.         }
324.     }
326.     /**
327.      * 根据value从一个set中查询,是否存在
328.      *
329.      * @param key   键
330.      * @param value 值
331.      * @return true 存在 false不存在
332.      */
333.     public boolean sHasKey(String key, Object value) {
334.         try {
335.             return redisTemplate.opsForSet().isMember(key, value);
336.         } catch (Exception e) {
337.             e.printStackTrace();
338.             return false;
339.         }
340.     }
342.     /**
343.      * 将数据放入set缓存
344.      *
345.      * @param key    键
346.      * @param values 值 可以是多个
347.      * @return 成功个数
348.      */
349.     public long sSet(String key, Object... values) {
350.         try {
351.             return redisTemplate.opsForSet().add(key, values);
352.         } catch (Exception e) {
353.             e.printStackTrace();
354.             return 0;
355.         }
356.     }
358.     /**
359.      * 将set数据放入缓存
360.      *
361.      * @param key    键
362.      * @param time   时间(秒)
363.      * @param values 值 可以是多个
364.      * @return 成功个数
365.      */
366.     public long sSetAndTime(String key, long time, Object... values) {
367.         try {
368.             Long count = redisTemplate.opsForSet().add(key, values);
369.             if (time > 0) {
370.                 expire(key, time);
371.             }
372.             return count;
373.         } catch (Exception e) {
374.             e.printStackTrace();
375.             return 0;
376.         }
377.     }
379.     /**
380.      * 获取set缓存的长度
381.      *
382.      * @param key 键
383.      * @return
384.      */
385.     public long sGetSetSize(String key) {
386.         try {
387.             return redisTemplate.opsForSet().size(key);
388.         } catch (Exception e) {
389.             e.printStackTrace();
390.             return 0;
391.         }
392.     }
394.     /**
395.      * 移除值为value的
396.      *
397.      * @param key    键
398.      * @param values 值 可以是多个
399.      * @return 移除的个数
400.      */
401.     public long setRemove(String key, Object... values) {
402.         try {
403.             Long count = redisTemplate.opsForSet().remove(key, values);
404.             return count;
405.         } catch (Exception e) {
406.             e.printStackTrace();
407.             return 0;
408.         }
409.     }
410.     //===============================list=================================
412.     /**
413.      * 获取list缓存的内容
414.      *
415.      * @param key   键
416.      * @param start 开始
417.      * @param end   结束  0 到 -1代表所有值
418.      * @return
419.      */
420.     public List<Object> lGet(String key, long start, long end) {
421.         try {
422.             return redisTemplate.opsForList().range(key, start, end);
423.         } catch (Exception e) {
424.             e.printStackTrace();
425.             return null;
426.         }
427.     }
429.     /**
430.      * 获取list缓存的长度
431.      *
432.      * @param key 键
433.      * @return
434.      */
435.     public long lGetListSize(String key) {
436.         try {
437.             return redisTemplate.opsForList().size(key);
438.         } catch (Exception e) {
439.             e.printStackTrace();
440.             return 0;
441.         }
442.     }
444.     /**
445.      * 通过索引 获取list中的值
446.      *
447.      * @param key   键
448.      * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
449.      * @return
450.      */
451.     public Object lGetIndex(String key, long index) {
452.         try {
453.             return redisTemplate.opsForList().index(key, index);
454.         } catch (Exception e) {
455.             e.printStackTrace();
456.             return null;
457.         }
458.     }
460.     /**
461.      * 将list放入缓存
462.      *
463.      * @param key   键
464.      * @param value 值
465.      * @return
466.      */
467.     public boolean lSet(String key, Object value) {
468.         try {
469.             redisTemplate.opsForList().rightPush(key, value);
470.             return true;
471.         } catch (Exception e) {
472.             e.printStackTrace();
473.             return false;
474.         }
475.     }
477.     /**
478.      * 将list放入缓存
479.      *
480.      * @param key   键
481.      * @param value 值
482.      * @param time  时间(秒)
483.      * @return
484.      */
485.     public boolean lSet(String key, Object value, long time) {
486.         try {
487.             redisTemplate.opsForList().rightPush(key, value);
488.             if (time > 0) {
489.                 expire(key, time);
490.             }
491.             return true;
492.         } catch (Exception e) {
493.             e.printStackTrace();
494.             return false;
495.         }
496.     }
498.     /**
499.      * 将list放入缓存
500.      *
501.      * @param key   键
502.      * @param value 值
503.      * @return
504.      */
505.     public boolean lSet(String key, List<Object> value) {
506.         try {
507.             redisTemplate.opsForList().rightPushAll(key, value);
508.             return true;
509.         } catch (Exception e) {
510.             e.printStackTrace();
511.             return false;
512.         }
513.     }
515.     /**
516.      * 将list放入缓存
517.      *
518.      * @param key   键
519.      * @param value 值
520.      * @param time  时间(秒)
521.      * @return
522.      */
523.     public boolean lSet(String key, List<Object> value, long time) {
524.         try {
525.             redisTemplate.opsForList().rightPushAll(key, value);
526.             if (time > 0) {
527.                 expire(key, time);
528.             }
529.             return true;
530.         } catch (Exception e) {
531.             e.printStackTrace();
532.             return false;
533.         }
534.     }
536.     /**
537.      * 根据索引修改list中的某条数据
538.      *
539.      * @param key   键
540.      * @param index 索引
541.      * @param value 值
542.      * @return
543.      */
544.     public boolean lUpdateIndex(String key, long index, Object value) {
545.         try {
546.             redisTemplate.opsForList().set(key, index, value);
547.             return true;
548.         } catch (Exception e) {
549.             e.printStackTrace();
550.             return false;
551.         }
552.     }
554.     /**
555.      * 移除N个值为value
556.      *
557.      * @param key   键
558.      * @param count 移除多少个
559.      * @param value 值
560.      * @return 移除的个数
561.      */
562.     public long lRemove(String key, long count, Object value) {
563.         try {
564.             Long remove = redisTemplate.opsForList().remove(key, count, value);
565.             return remove;
566.         } catch (Exception e) {
567.             e.printStackTrace();
568.             return 0;
569.         }
570.     }
571. }

复制代码

三、SpringBoot项目集成log4j2

SpringBoot项目在运行的时候可能会产生一些运行信息，如果能将这些信息记录下来，那么对于该项目的运行状态以及错误排查会起到一个非常好的帮助，所以采用log4j2进行日志记录

1、pom.xml添加依赖

1. <dependency>
2.     <groupId>org.springframework.boot</groupId>
3.     <artifactId>spring-boot-starter-web</artifactId>
4.     <exclusions>
5.         
6.         <exclusion>
7.             <groupId>org.springframework.boot</groupId>
8.             <artifactId>spring-boot-starter-logging</artifactId>
9.         </exclusion>
10.     </exclusions>
11. </dependency>
14. <dependency>
15.     <groupId>org.springframework.boot</groupId>
16.     <artifactId>spring-boot-starter-log4j2</artifactId>
17. </dependency>

复制代码

2、log4j2.xml配置文件，放置于resources文件夹下

1. <?xml version="1.0" encoding="UTF-8"?>
2. <Configuration status="fatal">
3.     <Properties>
4.         <Property name="baseDir" value="/home/leilee/Projects/back/logs"/>
5.     </Properties>
7.     <Appenders>
8.         <Console name="Console" target="SYSTEM_OUT">
9.             
10.             <ThresholdFilter level="info" onMatch="ACCEPT"
11.                              onMismatch="DENY"/>
12.             <PatternLayout
13.                     pattern="[%d{MM:dd HH:mm:ss.SSS}] [%level] [%logger{36}] - %msg%n"/>
14.         </Console>
16.         
17.         <RollingFile name="debug_appender" fileName="${baseDir}/debug.log"
18.                      filePattern="${baseDir}/debug_%i.log.%d{yyyy-MM-dd}">
19.             
20.             <Filters>
21.                
22.                 <ThresholdFilter level="debug"/>
23.                 <ThresholdFilter level="info" onMatch="DENY" onMismatch="NEUTRAL"/>
24.             </Filters>
25.             
26.             <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
27.             
28.             <Policies>
29.                
30.                 <TimeBasedTriggeringPolicy interval="1" modulate="true"/>
31.                
32.                 <SizeBasedTriggeringPolicy size="100 MB"/>
33.             </Policies>
34.         </RollingFile>
36.         
37.         <RollingFile name="info_appender" fileName="${baseDir}/info.log"
38.                      filePattern="${baseDir}/info_%i.log.%d{yyyy-MM-dd}">
39.             
40.             <Filters>
41.                
42.                 <ThresholdFilter level="info"/>
43.                 <ThresholdFilter level="error" onMatch="DENY" onMismatch="NEUTRAL"/>
44.             </Filters>
45.             
46.             <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
47.             
48.             <Policies>
49.                
50.                 <TimeBasedTriggeringPolicy interval="1" modulate="true"/>
51.                
52.                 <SizeBasedTriggeringPolicy size="100 MB"/>
53.             </Policies>
54.         </RollingFile>
56.         
57.         <RollingFile name="error_appender" fileName="${baseDir}/error.log"
58.                      filePattern="${baseDir}/error_%i.log.%d{yyyy-MM-dd}">
59.             
60.             <Filters>
61.                
62.                 <ThresholdFilter level="error"/>
63.             </Filters>
64.             
65.             <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
66.             <Policies>
67.                
68.                 <TimeBasedTriggeringPolicy interval="1" modulate="true"/>
69.                
70.                 <SizeBasedTriggeringPolicy size="100 MB"/>
71.             </Policies>
72.         </RollingFile>
73.     </Appenders>
74.     <Loggers>
75.         <Root level="debug">
76.             <AppenderRef ref="Console"/>
77.             <AppenderRef ref="debug_appender"/>
78.             <AppenderRef ref="info_appender"/>
79.             <AppenderRef ref="error_appender"/>
80.         </Root>
81.     </Loggers>
82. </Configuration>

复制代码

注意：第四行中value的值即输出的log文件的存放路径
3、自定义log信息

如果自己想存入一些自定义的信息，那么采用@Log4j2对类进行注解，然后在类中使用log的方法即可，以该网站的数据库读取过程为例

1. package cn.huskysir.Service.Impl;
3. import cn.huskysir.Dao.DynastyMapper;
4. import cn.huskysir.Dao.EmperorMapper;
5. import cn.huskysir.Entity.MySQL.Dynasty;
6. import cn.huskysir.Entity.MySQL.Emperor;
7. import cn.huskysir.Service.EmperorService;
8. import cn.huskysir.Utils.RedisUtil;
9. import cn.huskysir.Vo.EmperorVo;
10. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
11. import lombok.extern.log4j.Log4j2;
12. import org.springframework.beans.BeanUtils;
13. import org.springframework.stereotype.Service;
15. import javax.annotation.Resource;
16. import java.util.Date;
17. import java.util.LinkedList;
18. import java.util.List;
20. /**
21. * Emperor Service层（实现类）
22. */
23. @Log4j2
24. @Service
25. public class EmperorServiceImpl implements EmperorService {
27.     @Resource
28.     EmperorMapper emperorMapper;
29.     @Resource
30.     DynastyMapper dynastyMapper;
31.     @Resource
32.     RedisUtil redisUtil;
34.     /**
35.      * 获得所有EmperorVo对象列表
36.      *
37.      * @return
38.      */
39.     @Override
40.     public List<EmperorVo> getAllEmperorVoList() {
41.         // 判断Redis是否存在该结果
42.         String key = "getAllEmperorVoList";
43.         if (redisUtil.hasKey(key)) {
44.             List<EmperorVo> emperorVoList = (List<EmperorVo>) redisUtil.get(key);
45.             System.out.println("由Redis得到" + key + "结果");
46.             // 日志记录
47.             log.info(new Date() + " 由Redis得到" + key + "数据");
48.             return emperorVoList;
49.         }
51.         List<Emperor> emperorList = emperorMapper.selectList(null);
52.         List<EmperorVo> emperorVoList = new LinkedList<>();
53.         for (Emperor emperor : emperorList) {
54.             EmperorVo emperorVo = new EmperorVo();
55.             BeanUtils.copyProperties(emperor, emperorVo);
56.             Dynasty dynasty = dynastyMapper.selectById(emperor.getDynastyId());
57.             emperorVo.setDynastyName(dynasty.getName());
58.             emperorVo.calculateTime();
59.             emperorVoList.add(emperorVo);
60.         }
61.         System.out.println("由MySQL得到" + key + "结果");
62.         // 日志记录
63.         log.info(new Date() + " 由MySQL得到" + key + "数据");
64.         if (redisUtil.set(key, emperorVoList, 600)) {
65.             System.out.println("Redis已存入" + key + "数据");
66.             // 日志记录
67.             log.info(new Date() + " Redis已存入" + key + "数据");
68.         }
70.         return emperorVoList;
71.     }
73.     /**
74.      * 根据id获得EmperorVo对象
75.      *
76.      * @param id
77.      * @return
78.      */
79.     @Override
80.     public EmperorVo getEmperorVoById(Integer id) {
81.         // 判断Redis是否存在该结果
82.         String key = "getEmperorVoById_" + String.valueOf(id);
83.         if (redisUtil.hasKey(key)) {
84.             EmperorVo emperorVo = (EmperorVo) redisUtil.get(key);
85.             System.out.println("由Redis得到" + key + "结果");
86.             // 日志记录
87.             log.info(new Date() + " 由Redis得到" + key + "数据");
88.             return emperorVo;
89.         }
91.         Emperor emperor = emperorMapper.selectById(id);
92.         EmperorVo emperorVo = new EmperorVo();
93.         BeanUtils.copyProperties(emperor, emperorVo);
94.         Dynasty dynasty = dynastyMapper.selectById(emperor.getDynastyId());
95.         emperorVo.setDynastyName(dynasty.getName());
96.         emperorVo.calculateTime();
97.         System.out.println("由MySQL得到" + key + "结果");
98.         // 日志记录
99.         log.info(new Date() + " 由MySQL得到" + key + "数据");
100.         if (redisUtil.set(key, emperorVo, 600)) {
101.             System.out.println("Redis已存入" + key + "数据");
102.             // 日志记录
103.             log.info(new Date() + " Redis已存入" + key + "数据");
104.         }
106.         return emperorVo;
107.     }
109.     /**
110.      * 根据dynastyId获得所有EmperorVo对象列表
111.      *
112.      * @param dynastyId
113.      * @return
114.      */
115.     @Override
116.     public List<EmperorVo> getEmperorListByDynastyId(Integer dynastyId) {
117.         // 判断Redis是否存在该结果
118.         String key = "getEmperorListByDynastyId_" + String.valueOf(dynastyId);
119.         if (redisUtil.hasKey(key)) {
120.             List<EmperorVo> emperorVoList = (List<EmperorVo>) redisUtil.get(key);
121.             System.out.println("由Redis得到" + key + "结果");
122.             // 日志记录
123.             log.info(new Date() + " 由Redis得到" + key + "数据");
124.             return emperorVoList;
125.         }
127.         QueryWrapper<Emperor> queryWrapper = new QueryWrapper<>();
128.         queryWrapper.eq("dynasty_id", dynastyId);
129.         List<Emperor> emperorList = emperorMapper.selectList(queryWrapper);
130.         List<EmperorVo> emperorVoList = new LinkedList<>();
131.         String nastyName = dynastyMapper.selectById(dynastyId).getName();
132.         for (Emperor emperor : emperorList) {
133.             EmperorVo emperorVo = new EmperorVo();
134.             BeanUtils.copyProperties(emperor, emperorVo);
135.             emperorVo.setDynastyName(nastyName);
136.             emperorVo.calculateTime();
137.             emperorVoList.add(emperorVo);
138.         }
139.         System.out.println("由MySQL得到" + key + "结果");
140.         // 日志记录
141.         log.info(new Date() + " 由MySQL得到" + key + "数据");
142.         if (redisUtil.set(key, emperorVoList, 600)) {
143.             System.out.println("Redis已存入" + key + "数据");
144.             // 日志记录
145.             log.info(new Date() + " Redis已存入" + key + "数据");
146.         }
148.         return emperorVoList;
149.     }
150. }

复制代码

以“getEmperorListByDynastyId(Integer dynastyId)”方法为例，该方法是根据dynastyId获得List对象，首先会根据方法名及dynastyId在Redis数据库中查找，若存在则直接返回，否则从MySQL数据库中读取，并将结果存入Redis数据库中然后返回。使用log.info()记录数据库读取过程，该记录会存储于info.log文件中
该网站后台的info.log日志记录如下

1. [00:54:31:770] [INFO] - cn.huskysir.Service.Impl.EmperorServiceImpl.getEmperorListByDynastyId(EmperorServiceImpl.java:141) - Wed Sep 20 00:54:31 CST 2023 由MySQL得到getEmperorListByDynastyId_1数据
2. [00:54:31:773] [INFO] - cn.huskysir.Service.Impl.EmperorServiceImpl.getEmperorListByDynastyId(EmperorServiceImpl.java:145) - Wed Sep 20 00:54:31 CST 2023 Redis已存入getEmperorListByDynastyId_1数据
3. [00:54:35:853] [INFO] - cn.huskysir.Service.Impl.EmperorServiceImpl.getEmperorListByDynastyId(EmperorServiceImpl.java:141) - Wed Sep 20 00:54:35 CST 2023 由MySQL得到getEmperorListByDynastyId_2数据
4. [00:54:35:863] [INFO] - cn.huskysir.Service.Impl.EmperorServiceImpl.getEmperorListByDynastyId(EmperorServiceImpl.java:145) - Wed Sep 20 00:54:35 CST 2023 Redis已存入getEmperorListByDynastyId_2数据
5. [00:54:37:363] [INFO] - cn.huskysir.Service.Impl.EmperorServiceImpl.getEmperorListByDynastyId(EmperorServiceImpl.java:123) - Wed Sep 20 00:54:37 CST 2023 由Redis得到getEmperorListByDynastyId_1数据
6. [00:54:38:043] [INFO] - cn.huskysir.Service.Impl.EmperorServiceImpl.getEmperorListByDynastyId(EmperorServiceImpl.java:123) - Wed Sep 20 00:54:38 CST 2023 由Redis得到getEmperorListByDynastyId_2数据
7. [00:54:39:214] [INFO] - cn.huskysir.Service.Impl.EmperorServiceImpl.getEmperorListByDynastyId(EmperorServiceImpl.java:123) - Wed Sep 20 00:54:39 CST 2023 由Redis得到getEmperorListByDynastyId_1数据
8. [00:54:39:936] [INFO] - cn.huskysir.Service.Impl.EmperorServiceImpl.getEmperorListByDynastyId(EmperorServiceImpl.java:123) - Wed Sep 20 00:54:39 CST 2023 由Redis得到getEmperorListByDynastyId_2数据

复制代码

四、总结

关于SpringBoot项目配置Redis与log4j2是查询官方文档以及他人博客得到的，本文中的Redis配置类、Redis工具类以及log4j2.xml配置文件来自网络，查证源自何处比较麻烦，所以在此感谢所有人的分享！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！