从零搭建 Spring Boot 后端项目（三）

亦凉 2023-02-28 05:42 236阅读 0赞

简介

这一小节主要是，整合Redis，需要提前在开发机上安装好Redis才能进行以下操作

步骤

这里我用的是Windows下的 redis 3.0，可以自行下载安装适合自己系统的redis

  • 添加Redis依赖

    1. <!-- redis -->
    2.     <dependency>
    3.         <groupId>org.springframework.boot</groupId>
    4.         <artifactId>spring-boot-starter-data-redis</artifactId>
    5.         <version>1.4.5.RELEASE</version>
    6.     </dependency>

  • 在 application-dev.properties 下添加如下配置

    1. # Redis
    2. # Redis服务器地址
    3. spring.redis.host=127.0.0.1
    4. # Redis连接端口
    5. spring.redis.port=6379
    6. # Redis连接密码(默认为空)
    7. spring.redis.password=password
    8. # 连接池最大连接数（使用负值表示没有限制）
    9. spring.redis.jedis.pool.max-active=20
    10. # 连接池最大阻塞等待时间（使用负值表示没有限制）
    11. spring.redis.jedis.pool.max-wait=-1
    12. # 连接池中的最大空闲连接、最小空闲连接
    13. spring.redis.jedis.pool.max-idle=10
    14. spring.redis.jedis.pool.min-idle=0
    15. # 连接超时时间（毫秒）
    16. spring.redis.timeout=1000

  • 在com.example.backend_template.config下新建RedisConfigurer类

    1. package com.example.backend_template.config;
    2. import org.slf4j.Logger;
    3. import org.slf4j.LoggerFactory;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
    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.RedisPassword;
    11. import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
    12. import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
    13. import org.springframework.data.redis.core.RedisTemplate;
    14. import org.springframework.data.redis.core.StringRedisTemplate;
    16. /**
    17.  * @ClassName RedisConfigurer Redis的配置类
    18.  * @Description
    19.  * @Author L
    20.  * @Date Create by 2020/6/26
    21.  */
    22. @Configuration
    23. @EnableCaching      //开启缓存
    24. public class RedisConfigurer extends CachingConfigurerSupport {
    26.     /**
    27.      * redis 的各种配置信息，由框架注入
    28.      */
    29.     @Autowired
    30.     private RedisProperties redisProperties;
    32.     /**
    33.      * 日志工具
    34.      */
    35.     private static final Logger log = LoggerFactory.getLogger(RedisConfigurer.class);
    37.     @Bean
    38.     public JedisConnectionFactory getConnectionFactory() {
    39.         RedisStandaloneConfiguration redisStandaloneConfiguration =
    40.                 new RedisStandaloneConfiguration(redisProperties.getHost(), redisProperties.getPort());
    41.         redisStandaloneConfiguration.setPassword(RedisPassword.of(redisProperties.getPassword()));
    42.         JedisConnectionFactory factory = new JedisConnectionFactory(redisStandaloneConfiguration);
    43.         log.info("The hostname of the redis connection is：{}, and the port is: {}", factory.getHostName(), factory.getPort());
    44.         return factory;
    45.     }
    47.     public RedisTemplate<?, ?> getRedisTemplate() {
    48.         RedisTemplate<?, ?> template = new StringRedisTemplate(getConnectionFactory());
    49.         return template;
    50.     }
    51. }

  • 在com.example.backend_template.service下新建RedisService类

    1. package com.example.backend_template.service;
    3. import java.util.List;
    5. /**
    6.  * @ClassName RedisService Redis常用方法
    7.  * @Description 
    8.  * @Author L
    9.  * @Date Create by 2020/6/26
    10.  */
    11. public interface RedisService {
    13.     /**
    14.      * 设置给定 key 的值。如果 key 已经存储其他值， SET 就覆写旧值，且无视类型。
    15.      * @param key
    16.      * @param value
    17.      * @return
    18.      */
    19.     boolean set(String key, String value);
    21.     /**
    22.      * 获取指定 key 的值。如果 key 不存在，返回 nil 。如果key 储存的值不是字符串类型，返回一个错误。
    23.      * @param key
    24.      * @return
    25.      */
    26.     String get(String key);
    28.     /**
    29.      * 设置 key 的过期时间。key 过期后将不再可用。
    30.      * @param key
    31.      * @param expire
    32.      * @return
    33.      */
    34.     boolean expire(String key, long expire);
    36.     /**
    37.      * 存集合
    38.      * @param key
    39.      * @param list
    40.      * @param <T>
    41.      * @return
    42.      */
    43.     <T> boolean setList(String key, List<T> list);
    45.     /**
    46.      * 取集合
    47.      * @param key
    48.      * @param clz
    49.      * @param <T>
    50.      * @return
    51.      */
    52.     <T> List<T> getList(String key, Class<T> clz);
    54.     /**
    55.      * 将一个或多个值插入到列表头部。 如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。
    56.      * 当 key 存在但不是列表类型时，返回一个错误。
    57.      * @param key
    58.      * @param obj
    59.      * @return
    60.      */
    61.     long lpush(String key, Object obj);
    63.     /**
    64.      * 将一个或多个值插入到列表的尾部(最右边)。
    65.      * 如果列表不存在，一个空列表会被创建并执行 RPUSH 操作。 当列表存在但不是列表类型时，返回一个错误。
    66.      * @param key
    67.      * @param obj
    68.      * @return
    69.      */
    70.     long rpush(String key, Object obj);
    72.     /**
    73.      * 移除并返回列表的第一个元素。
    74.      * @param key
    75.      * @return
    76.      */
    77.     String lpop(String key);
    79.     /**
    80.      * 删除已存在的键。不存在的 key 会被忽略。
    81.      * @param key
    82.      * @return
    83.      */
    84.     long del(final String key);
    85. }

  • 在com.example.backend_template.service.impl下新建RedisServiceImpl类，这里需要alibaba的fastjson包，所示要提前有pom.xml添加如下依赖

    1. <!-- fastjson -->
    2.         <dependency>
    3.             <groupId>com.alibaba</groupId>
    4.             <artifactId>fastjson</artifactId>
    5.             <version>1.2.41</version>
    6.         </dependency>
    8. package com.example.backend_template.service.impl;
    10. import com.alibaba.fastjson.JSON;
    11. import com.example.backend_template.service.RedisService;
    12. import org.springframework.dao.DataAccessException;
    13. import org.springframework.data.redis.connection.RedisConnection;
    14. import org.springframework.data.redis.core.RedisCallback;
    15. import org.springframework.data.redis.core.RedisTemplate;
    16. import org.springframework.data.redis.serializer.RedisSerializer;
    17. import org.springframework.stereotype.Service;
    19. import javax.annotation.Resource;
    20. import java.util.List;
    21. import java.util.concurrent.TimeUnit;
    23. /**
    24.  * @ClassName RedisServiceImpl
    25.  * @Description 
    26.  * @Author L
    27.  * @Date Create by 2020/6/26
    28.  */
    29. @Service
    30. public class RedisServiceImpl implements RedisService {
    32.     @Resource
    33.     private RedisTemplate<String, ?> redisTemplate;
  1.         @Override
  2.         public boolean set(final String key, final String value) {
  3.             boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
  4.                 @Override
  5.                 public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
  6.                     RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
  7.                     connection.set(serializer.serialize(key), serializer.serialize(value));
  8.                     return true;
  9.                 }
  10.             });
  11.             return result;
  12.         }
  14.         @Override
  15.         public String get(final String key){
  16.             String result = redisTemplate.execute(new RedisCallback<String>() {
  17.                 @Override
  18.                 public String doInRedis(RedisConnection connection) throws DataAccessException {
  19.                     RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
  20.                     byte[] value =  connection.get(serializer.serialize(key));
  21.                     return serializer.deserialize(value);
  22.                 }
  23.             });
  24.             return result;
  25.         }
  27.         @Override
  28.         public long del(final String key){
  29.             long result = redisTemplate.execute(new RedisCallback<Long>() {
  30.                 @Override
  31.                 public Long doInRedis(RedisConnection connection) throws DataAccessException {
  32.                     RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
  33.                     long value =  connection.del(serializer.serialize(key));
  34.                     return value;
  35.                 }
  36.             });
  37.             return result;
  38.         }
  40.         @Override
  41.         public boolean expire(final String key, long expire) {
  42.             return redisTemplate.expire(key, expire, TimeUnit.SECONDS);
  43.         }
  45.         @Override
  46.         public <T> boolean setList(String key, List<T> list) {
  47.             String value = JSON.toJSONString(list);
  48.             return set(key,value);
  49.         }
  51.         @Override
  52.         public <T> List<T> getList(String key,Class<T> clz) {
  53.             String json = get(key);
  54.             if(json!=null){
  55.                 List<T> list = JSON.parseArray(json, clz);
  56.                 return list;
  57.             }
  58.             return null;
  59.         }
  61.         @Override
  62.         public long lpush(final String key, Object obj) {
  63.             final String value = JSON.toJSONString(obj);
  64.             long result = redisTemplate.execute(new RedisCallback<Long>() {
  65.                 @Override
  66.                 public Long doInRedis(RedisConnection connection) throws DataAccessException {
  67.                     RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
  68.                     long count = connection.lPush(serializer.serialize(key), serializer.serialize(value));
  69.                     return count;
  70.                 }
  71.             });
  72.             return result;
  73.         }
  75.         @Override
  76.         public long rpush(final String key, Object obj) {
  77.             final String value = JSON.toJSONString(obj);
  78.             long result = redisTemplate.execute(new RedisCallback<Long>() {
  79.                 @Override
  80.                 public Long doInRedis(RedisConnection connection) throws DataAccessException {
  81.                     RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
  82.                     long count = connection.rPush(serializer.serialize(key), serializer.serialize(value));
  83.                     return count;
  84.                 }
  85.             });
  86.             return result;
  87.         }
  89.         @Override
  90.         public String lpop(final String key) {
  91.             String result = redisTemplate.execute(new RedisCallback<String>() {
  92.                 @Override
  93.                 public String doInRedis(RedisConnection connection) throws DataAccessException {
  94.                     RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
  95.                     byte[] res =  connection.lPop(serializer.serialize(key));
  96.                     return serializer.deserialize(res);
  97.                 }
  98.             });
  99.             return result;
  100.         }
  101.     }

测试

  • 在com.example.backend_template.controller下新建RedisController类

    1. package com.example.backend_template.controller;
    3. import com.example.backend_template.service.RedisService;
    4. import org.springframework.web.bind.annotation.GetMapping;
    5. import org.springframework.web.bind.annotation.PostMapping;
    6. import org.springframework.web.bind.annotation.RequestMapping;
    7. import org.springframework.web.bind.annotation.RestController;
    9. import javax.annotation.Resource;
    11. /**
    12.  * @ClassName RedisController
    13.  * @Description 
    14.  * @Author L
    15.  * @Date Create by 2020/6/26
    16.  */
    17. @RestController
    18. @RequestMapping("redis")
    19. public class RedisController {
    21.     @Resource
    22.     private RedisService redisService;
    24.     @PostMapping("/setRedis")
    25.     public Boolean setRedis(String name) {
    26.         return redisService.set("name", name);
    27.     }
    29.     @GetMapping("/getRedis")
    30.     public String getRedis() {
    31.         return redisService.get("name");
    32.     }
    33. }
  • 启动项目，请求方式为POST，URL为 http://localhost:8080/redis/setRedis ，参数名为name，如下图方式进行访问
    在这里插入图片描述
  • 请求方式为GET，URL为 http://localhost:8080/redis/getRedis 如下图方式进行访问
    在这里插入图片描述
    如出现如上两种结果，则表示Redis已整合成功

项目地址

项目介绍：从零搭建 Spring Boot 后端项目
代码地址：https://github.com/xiaoxiamo/backend-template

下一篇

四、整合 Spring Security

发表评论

表情：
评论列表 （有 0 条评论，236人围观）

还没有评论，来说两句吧...

相关阅读

    相关 从零搭建 Spring Boot 后端项目

    简介 一个基于 Spring Boot 的后端开发模板，主要用于减少平时重复的工作量，以及使开发有良好的开发规范，主要功能包括但不限于权限管理、在线接口文档、日志记录、单

    蔚落蔚落/ 0 赞/ 125 阅读