SpringBoot整合Redis使用Restful风格实现CRUD功能

时间  2019-11-11
标签 springboot 整合 redis 使用 restful 风格 实现 crud 功能 栏目 Spring 繁體版
原文   原文链接

前言

本篇文章主要介绍的是SpringBoot整合Redis，使用Restful风格实现的CRUD功能。html

Redis 介绍

Redis 是彻底开源免费的，遵照BSD协议，是一个高性能的key-value数据库。 Redis 与其余 key - value缓存产品有如下三个特色：java

  • Redis支持数据的持久化，能够将内存中的数据保存在磁盘中，重启的时候能够再次加载进行使用。
  • Redis不只仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
  • Redis支持数据的备份，即master-slave模式的数据备份。

更多的使用说明能够查看官方的文档。
官方文档: https://redis.ionode

SpringBoot整合Redis

说明：若是想直接获取工程那么能够直接跳到底部，经过连接下载工程代码。git

开发准备

环境要求
JDK：1.8
SpringBoot：1.5.15.RELEASE
Redis：3.2或以上。github

Tips：Redis的偶数为稳定版本，奇数为非稳定版本，因此在使用的时候最好使用偶数的版本！web

Reids的能够看我以前的写的这篇文章: Redis安装教程redis

首先仍是Maven的相关依赖:spring

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
    <fastjson>1.2.41</fastjson>
    <springboot>1.5.15.RELEASE</springboot>
  </properties>

  <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId> 
            <artifactId>spring-boot-starter-web</artifactId>
            <version>${springboot}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
            <version>${springboot}</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>${springboot}</version>
            <scope>test</scope>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>${springboot}</version>
        </dependency>
  
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson}</version>
        </dependency>
  
  </dependencies>

添加了相应的maven依赖以后，咱们再来查看配置。
Redis配置的说明在下面中已经说的很详细了，这里就不在过多说明了，不过须要注意的是若是Redis是集群版的话，须要使用这个spring.redis.cluster.nodes这个配置，该配置为Redis的Host加上Port，多个之间用，逗号隔开。
application.properties的配置以下:数据库

# Redis服务器地址
# 单机版配置
spring.redis.host = 127.0.0.1
spring.redis.port = 6379
# redis最大重连数
redis.cluster.max-redirects=3
# Redis服务器链接密码（默认为空）
redis.password=
# 最大空闲数  
redis.maxIdle=5  
# 链接池的最大数据库链接数。
redis.maxTotal=5 
# 最大创建链接等待时间。若是超过此时间将接到异常。设为-1表示无限制。  
redis.maxWaitMillis=1000  
# 链接的最小空闲时间 默认1800000毫秒(30分钟)  
redis.minEvictableIdleTimeMillis=300000  
# 每次释放链接的最大数目,默认3  
redis.numTestsPerEvictionRun=3 
# 逐出扫描的时间间隔(毫秒) 若是为负数,则不运行逐出线程, 默认-1  
redis.timeBetweenEvictionRunsMillis=30000  
# 是否在从池中取出链接前进行检验,若是检验失败,则从池中去除链接并尝试取出另外一个  
redis.testOnBorrow=true  
# 在空闲时检查有效性, 默认false  
redis.testWhileIdle=true

代码编写

首先是编写Redis的配置类，对Redis这块进行配置。
在使用SpringBoot整合Redis的时候，SpringBoot是能够根据配置自动完成Redis的相关配置，不过为了更灵活一点，咱们这边仍是手动加载一下配置，配置成本身想要的那种效果吧。
首先，配置一个Redis的链接池，使用redis.clients.jedis.JedisPoolConfig这个类来进行实现，相关的配置在代码的注释中说明得很详细了，这里就不在过多讲述了；
而后，再来配置一个Redis的工厂，加载Redis的链接池配置，这里咱们也能够进行一下设置，若是Redis设置了密码，咱们就加载改密码，不然就不进行加载。
继而，咱们再来设置数据存入Redis的序列化的方式并开启事务。这里也顺便说下为何要设置序列化器，若是不设置，那么在用实体类(未序列化)进行存储的时候，会提示错误: Failed to serialize object using DefaultSerializer; 固然，也能够不设置，不过存储的实体类必须进行序列化。
最后，咱们再来实例化RedisTemplate的对象，加载上述的配置。在使用的时候，只须要使用以下的方式注入就可使用了json

@Autowired
RedisTemplate<String, Object> redisTemplate;

Redis的配置类的代码以下:

/**
 * 
 * @Title: RedisConfig
 * @Description: redis初始化配置
 * @Version:1.0.0
 * @author pancm
 * @date 2018年6月7日
 */
@Component
public class RedisConfig {

    @Value("${redis.maxIdle}")
    private Integer maxIdle;

    @Value("${redis.maxTotal}")
    private Integer maxTotal;

    @Value("${redis.maxWaitMillis}")
    private Integer maxWaitMillis;

    @Value("${redis.minEvictableIdleTimeMillis}")
    private Integer minEvictableIdleTimeMillis;

    @Value("${redis.numTestsPerEvictionRun}")
    private Integer numTestsPerEvictionRun;

    @Value("${redis.timeBetweenEvictionRunsMillis}")
    private long timeBetweenEvictionRunsMillis;

    @Value("${redis.testOnBorrow}")
    private boolean testOnBorrow;

    @Value("${redis.testWhileIdle}")
    private boolean testWhileIdle;

    @Value("${redis.cluster.max-redirects}")
    private Integer mmaxRedirectsac;

    @Value("${redis.password}")
    private String redispwd;

    /**
     * JedisPoolConfig 链接池
     * 
     * @return
     */
    @Bean
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        // 最大空闲数
        jedisPoolConfig.setMaxIdle(maxIdle);
        // 链接池的最大数据库链接数
        jedisPoolConfig.setMaxTotal(maxTotal);
        // 最大创建链接等待时间
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
        // 逐出链接的最小空闲时间 默认1800000毫秒(30分钟)
        jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        // 每次逐出检查时 逐出的最大数目 若是为负数就是 : 1/abs(n), 默认3
        jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
        // 逐出扫描的时间间隔(毫秒) 若是为负数,则不运行逐出线程, 默认-1
        jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        // 是否在从池中取出链接前进行检验,若是检验失败,则从池中去除链接并尝试取出另外一个
        jedisPoolConfig.setTestOnBorrow(testOnBorrow);
        // 在空闲时检查有效性, 默认false
        jedisPoolConfig.setTestWhileIdle(testWhileIdle);
        return jedisPoolConfig;
    }



    
    /**
     * 配置工厂
     */
    @Bean
    public JedisConnectionFactory JedisConnectionFactory(JedisPoolConfig jedisPoolConfig) {
        JedisConnectionFactory JedisConnectionFactory = new JedisConnectionFactory(jedisPoolConfig);
        if (redispwd == null || redispwd.length() == 0) {
            JedisConnectionFactory.setPassword(redispwd);
        }
        return JedisConnectionFactory;
    }

    

    /**
     * 设置数据存入 redis 的序列化方式,并开启事务
     * 
     * @param redisTemplate
     * @param factory
     */
    private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
        /*
         * 设置 序列化器 .
         * 若是不设置，那么在用实体类(未序列化)进行存储的时候，会提示错误: Failed to serialize object using DefaultSerializer;
         */
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        // 开启事务
        redisTemplate.setEnableTransactionSupport(true);
        // 将链接工厂设置到模板类中
        redisTemplate.setConnectionFactory(factory);
    }
    
    /**
     * 实例化 RedisTemplate 对象
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> functionDomainRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
        return redisTemplate;
    }
    
}

固然，若是本身想使用自定义的Redis工具类进行实现，那么只需在该配置类中注册一个Bean注入封装一下就能够了，而后在工具类中加载一下就能够了。
配置类中添加:

@Bean(name = "redisUtil")
    public RedisUtil redisUtil(RedisTemplate<String, Object> redisTemplate) {
        RedisUtil redisUtil = new RedisUtil();
        redisUtil.setRedisTemplate(redisTemplate);
        return redisUtil;
    }'

Redis的工具类添加以下代码:

private RedisTemplate<String, Object> redisTemplate;

    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

使用Redis工具类示例:

@Resource
    private RedisUtil redisUtil;

讲完Redis的配置类以后，咱们再来进行编写相应的实体类、dao层、service层和Controller层的代码了。
因为这块的代码比较简单，并且格式和以前的项目基本相似，所以这里我就简单的贴下代码了。

实体类

又是万能的用户表 (^▽^)

代码以下：

public class User implements Serializable{
    private static final long serialVersionUID = 1L;
    /** 编号 */
     private int id;
     /** 姓名 */
     private String name;
     /** 年龄 */
     private int age;
     
     public User(){
     }

    public int getId() {
        return id;
    }
    
    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return JSONObject.toJSONString(this);
    }
}

Dao 数据层

这里我是使用的自定义的Redis工具类，其实也就是对RedisTemplate作了二次封装。
由于使用的是set（集合）方式存储的，因此我这边把用户数据的ID做为key，用户数据做为value了。

实现类的代码以下:

@Repository
public class UserDaoImpl implements UserDao {

    @Resource
    private RedisUtil redisUtil;
    

    @Override
    public void addUser(User user) {
        redisUtil.set(String.valueOf(user.getId()), user.toString());
    }


    @Override
    public void updateUser(User user) {
        redisUtil.set(String.valueOf(user.getId()), user.toString());
    }


    @Override
    public void deleteUser(int id) {
        redisUtil.del(String.valueOf(id));
    }

    
    @Override
    public User findByUserId(int id) {
        String data = redisUtil.get(String.valueOf(id)).toString();
        User user = JSON.parseObject(data, User.class);
        return  user;
    }
}

Service 业务层

业务层这边处理比较简单，成功就返回true，失败就返回false。

实现类的代码以下:

@Service
public class UserServiceImpl implements UserService {   

    private  final Logger logger = LoggerFactory.getLogger(this.getClass());
    @Autowired
    private UserDao userDao;    
    
    @Override
    public boolean addUser(User user) {
        boolean flag=false;
        try{
            userDao.addUser(user);
            flag=true;
        }catch(Exception e){
            logger.error("新增失败!",e);
        }
        return flag;
    }

    @Override
    public boolean updateUser(User user) {
        boolean flag=false;
        try{
            userDao.updateUser(user);
            flag=true;
        }catch(Exception e){
            logger.error("修改失败!",e);
        }
        return flag;
    }

    @Override
    public boolean deleteUser(int id) {
        boolean flag=false;
        try{
            userDao.deleteUser(id);
            flag=true;
        }catch(Exception e){
            logger.error("删除失败!",e);
        }
        return flag;
    }


    @Override
    public User findByUserId(int id) {
        return userDao.findByUserId(id);
    }
}

Controller 控制层

控制层这边也比较简单，使用Restful风格实现的CRUD功能。

代码以下:

@RestController
@RequestMapping(value = "/api")
public class UserRestController {
    
    private  final Logger logger = LoggerFactory.getLogger(this.getClass());

    
    @Autowired
    private UserService userService;
 
    @PostMapping("/user")
    public boolean addUser(@RequestBody User user) {
        logger.info("开始新增...");
        return userService.addUser(user);
    }
    
    @PutMapping("/user")
    public boolean updateUser(@RequestBody User user) {
        logger.info("开始更新...");
        return userService.updateUser(user);
    }
    
    @DeleteMapping("/user")
    public boolean delete(@RequestParam(value = "id", required = true) int userId) {
        logger.info("开始删除...");
        return userService.deleteUser(userId);
    }
    

    @GetMapping("/user")
    public User findByUserId(@RequestParam(value = "id", required = true) int userId) {
        logger.info("开始查询全部数据...");
        return userService.findByUserId(userId);
    }
}

App 入口

和普通的SpringBoot项目基本同样。

代码以下:

@SpringBootApplication
public class App 
{
    public static void main( String[] args )
    {
        SpringApplication.run(App.class, args);
        System.out.println("程序正在运行...");
    }
}

功能测试

咱们成功启动该程序以后，使用Postman工具来进行接口测试。

首先添加一条数据，使用POST方式进行请求

POST http://localhost:8180/api/user

Body参数为:

{"id":1,"name":"xuwujing","age":18}

在这里插入图片描述
界面返回true，表示新增成功了！

而后在进行查询，使用GET请求。

GET http://localhost:8180/api/user?id=1

返回:

{"id":1,"name":"xuwujing","age":18}

在这里插入图片描述

咱们再来使用RedisDesktopManager工具进行查询看下，是否真的写入到Redis中去了。

在这里插入图片描述
能够看到已经成功写入到Redis中了。

而后咱们再来更新下更新该数据，使用PUT方式请求。

PUT http://localhost:8180/api/user

这里只是更改了下age年龄，Body参数为:

{"id":1,"name":"xuwujing","age":19}

在这里插入图片描述
能够看到已经成功更新了。

最后咱们再来查询一遍看下是否成功更新。

GET http://localhost:8180/api/user?id=1

返回:

{"id":1,"name":"xuwujing","age":19}

在这里插入图片描述
能够看到已经成功更新了。

其它

其实SpringBoot整合Redis整个项目很早以前就已经写好而且上传到Github了，可是一直没有抽出时间写篇博客讲述(还有不少SpringBoot的项目也是如此)，最近不是那么的忙了，因而准备了下时间编写本篇博文。后续我的Github上的SpringBoot项目中之后有时间的话，也会对其中的一些发表博文进行讲解，不过那是之后的事了ヽ(ー_ー)ノ

关于SpringBoot整合Redis的文章就讲解到这里了，若有不妥，欢迎指正！

项目地址

SpringBoot整合Redis的项目工程地址:
https://github.com/xuwujing/springBoot-study/tree/master/springboot-Redis

SpringBoot整个集合的地址:
https://github.com/xuwujing/springBoot-study

SpringBoot整合系列的文章

音乐推荐

原创不易，若是感受不错，但愿给个推荐！您的支持是我写做的最大动力！ 版权声明: 做者：虚无境 博客园出处：http://www.cnblogs.com/xuwujing CSDN出处：http://blog.csdn.net/qazwsxpcm　　　　 我的博客出处：http://www.panchengming.com

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程