欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-04-09 09:43:39
前言 本篇文章主要介绍的是SpringBoot整合Redis,使用Restful风格实现的CRUD功能。 Redis 介绍 Redis 是完全开源免费的,遵守BSD协议,是一个高性能的key value数据库。 Redis 与其他 key value缓存产品有以下三个特点: Redis支持数据的持久 ......

前言

本篇文章主要介绍的是springboot整合redis,使用restful风格实现的crud功能。

redis 介绍

redis 是完全开源免费的,遵守bsd协议,是一个高性能的key-value数据库。 redis 与其他 key - value缓存产品有以下三个特点:

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

更多的使用说明可以查看官方的文档。
官方文档: https://redis.io

springboot整合redis

说明:如果想直接获取工程那么可以直接跳到底部,通过链接下载工程代码。

开发准备

环境要求
jdk:1.8
springboot:1.5.15.release
redis:3.2或以上。

tips:redis的偶数为稳定版本,奇数为非稳定版本,所以在使用的时候最好使用偶数的版本!

reids的可以看我之前的写的这篇文章: redis安装教程

首先还是maven的相关依赖:

<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的对象,加载上述的配置。在使用的时候,只需要使用如下的方式注入就可以使用了

@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}

SpringBoot整合Redis使用Restful风格实现CRUD功能
界面返回true,表示新增成功了!

然后在进行查询,使用get请求。

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

返回:

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

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

我们再来使用redisdesktopmanager工具进行查询看下,是否真的写入到redis中去了。

SpringBoot整合Redis使用Restful风格实现CRUD功能
可以看到已经成功写入到redis中了。

然后我们再来更新下更新该数据,使用put方式请求。

put http://localhost:8180/api/user

这里只是更改了下age年龄,body参数为:

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

SpringBoot整合Redis使用Restful风格实现CRUD功能
可以看到已经成功更新了。

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

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

返回:

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

SpringBoot整合Redis使用Restful风格实现CRUD功能
可以看到已经成功更新了。

其它

其实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