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

汕尾海湾  金牌会员 | 2023-9-25 01:47:04 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 944|帖子 944|积分 2832

前言
个人网站使用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配置文件来自网络，查证源自何处比较麻烦，所以在此感谢所有人的分享！

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

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

汕尾海湾

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表