搜索

SpringBoot实战：整合Redis、mybatis，封装RedisUtils工具类等（附源码）

Java后端编程

共 45137字，需浏览 91分钟

 ·

2021-01-25 19:14




作者：陈彦斌


cnblogs.com/chenyanbin/p/13515268.html




创建SpringBoot项目


在线创建方式


网址：https://start.spring.io/



然后创建Controller、Mapper、Service包



SpringBoot整合Redis


引入Redis依赖



<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-data-redisartifactId>
dependency>

完整pom.xml



<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.3.3.RELEASEversion>
        <relativePath/> 
    parent>
    <groupId>com.cybgroupId>
    <artifactId>chenyb-mobile-redisartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>chenyb-mobile-redisname>
    <description>Demo project for Spring Bootdescription>

    <properties>
        <java.version>1.8java.version>
    properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintagegroupId>
                    <artifactId>junit-vintage-engineartifactId>
                exclusion>
            exclusions>
        dependency>
        <dependency>
            <groupId>io.projectreactorgroupId>
            <artifactId>reactor-testartifactId>
            <scope>testscope>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
        dependency>
    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>

project>

设置Redis的Template



RedisConfig.java


package com.cyb.mobile.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @ClassName：RedisConfig
 * @Description：Redis配置类
 * @Author：chenyb
 * @Date：2020/8/16 11:48 下午
 * @Versiion：1.0
 */
@Configuration //当前类为配置类
public class RedisConfig {
    @Bean //redisTemplate注入到Spring容器
    public RedisTemplate

      

        

       redisTemplate

       (RedisConnectionFactory factory)

      {
        RedisTemplate

     

       redisTemplate=

      new RedisTemplate<>();

      
        RedisSerializer

      

        redisSerializer = 

       new StringRedisSerializer();

       
        redisTemplate.setConnectionFactory(factory);

       
        

       //key序列化

       
        redisTemplate.setKeySerializer(redisSerializer);

       
        

       //value序列化

       
        redisTemplate.setValueSerializer(redisSerializer);

       
        

       //value hashmap序列化

       
        redisTemplate.setHashKeySerializer(redisSerializer);

       
        

       //key hashmap序列化

       
        redisTemplate.setHashValueSerializer(redisSerializer);

       
        

       return redisTemplate;

       
    }

       
}

设置Redis连接信息



# 连接的那个数据库
spring.redis.database=0
# redis服务的ip地址
spring.redis.host=192.168.199.142
# redis端口号
spring.redis.port=6379
# redis的密码，没设置过密码，可为空
spring.redis.password=12345678

Redis工具类


redisTemplate API





  1. opsForValue ==》String





  2. opsForSet ==》Set





  3. opsForHash ==》hash





  4. opsForZset ==》SortSet





  5. opsForList ==》list队列




RedisUtils.java



package com.cyb.mobile.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @ClassName：RedisUtils
 * @Description：Redis工具类
 * @Author：chenyb
 * @Date：2020/8/17 12:05 上午
 * @Versiion：1.0
 */
@Service
public class RedisUtils {
    @Autowired
    private RedisTemplate redisTemplate;

    private static double size = Math.pow(2, 32);


    /**
     * 写入缓存
     *
     * @param key
     * @param offset   位 8Bit=1Byte
     * @return
     */
    public boolean setBit(String key, long offset, boolean isShow) {
        boolean result = false;
        try {
            ValueOperations

     

       operations = redisTemplate.opsForValue();

      
            operations.setBit(key, offset, isShow);

      
            result = 

      true;

      
        } 

      catch (Exception e) {

      
            e.printStackTrace();

      
        }

      
        

      return result;

      
    }

      


      
    

      /**
     * 写入缓存
     *
     * @param key
     * @param offset
     * @return
     */

      
    

      public boolean getBit(String key, long offset) {

      
        

      boolean result = 

      false;

      
        

      try {

      
            ValueOperations

      

        operations = redisTemplate.opsForValue();

       
            result = operations.getBit(key, offset);

       
        } 

       catch (Exception e) {

       
            e.printStackTrace();

       
        }

       
        

       return result;

       
    }

       


       


       
    

       /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */

       
    

       public boolean set(final String key, Object value) {

       
        

       boolean result = 

       false;

       
        

       try {

       
            ValueOperations

       

         operations = redisTemplate.opsForValue();

        
            operations.set(key, value);

        
            result = 

        true;

        
        } 

        catch (Exception e) {

        
            e.printStackTrace();

        
        }

        
        

        return result;

        
    }

        


        
    

        /**
     * 写入缓存设置时效时间
     *
     * @param key
     * @param value
     * @return
     */

        
    

        public boolean set(final String key, Object value, Long expireTime) {

        
        

        boolean result = 

        false;

        
        

        try {

        
            ValueOperations

        

          operations = redisTemplate.opsForValue();

         
            operations.set(key, value);

         
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);

         
            result = 

         true;

         
        } 

         catch (Exception e) {

         
            e.printStackTrace();

         
        }

         
        

         return result;

         
    }

         


         
    

         /**
     * 批量删除对应的value
     *
     * @param keys
     */

         
    

         public void remove(final String... keys) {

         
        

         for (String key : keys) {

         
            remove(key);

         
        }

         
    }

         


         


         
    

         /**
     * 删除对应的value
     *
     * @param key
     */

         
    

         public void remove(final String key) {

         
        

         if (exists(key)) {

         
            redisTemplate.delete(key);

         
        }

         
    }

         


         
    

         /**
     * 判断缓存中是否有对应的value
     *
     * @param key
     * @return
     */

         
    

         public boolean exists(final String key) {

         
        

         return redisTemplate.hasKey(key);

         
    }

         


         
    

         /**
     * 读取缓存
     *
     * @param key
     * @return
     */

         
    

         public Object get(final String key) {

         
        Object result = 

         null;

         
        ValueOperations

         

           operations = redisTemplate.opsForValue();

          
        result = operations.get(key);

          
        

          return result;

          
    }

          


          
    

          /**
     * 哈希 添加
     *
     * @param key
     * @param hashKey
     * @param value
     */

          
    

          public void hmSet(String key, Object hashKey, Object value) {

          
        HashOperations

          

            hash = redisTemplate.opsForHash();

           
        hash.put(key, hashKey, value);

           
    }

           


           
    

           /**
     * 哈希获取数据
     *
     * @param key
     * @param hashKey
     * @return
     */

           
    

           public Object hmGet(String key, Object hashKey) {

           
        HashOperations

           

             hash = redisTemplate.opsForHash();

            
        

            return hash.get(key, hashKey);

            
    }

            


            
    

            /**
     * 列表添加
     *
     * @param k
     * @param v
     */

            
    

            public void lPush(String k, Object v) {

            
        ListOperations

            

              list = redisTemplate.opsForList();

             
        list.rightPush(k, v);

             
    }

             


             
    

             /**
     * 列表获取
     *
     * @param k
     * @param l
     * @param l1
     * @return
     */

             
    

             public List lRange(String k, long l, long l1) {
        ListOperations

               

                 list = redisTemplate.opsForList();

                
        

                return list.range(k, l, l1);

                
    }

                


                
    

                /**
     * 集合添加
     *
     * @param key
     * @param value
     */

                
    

                public void add(String key, Object value) {

                
        SetOperations

                

                  set = redisTemplate.opsForSet();

                 
        set.add(key, value);

                 
    }

                 


                 
    

                 /**
     * 集合获取
     *
     * @param key
     * @return
     */

                 
    

                 public Set setMembers(String key) {
        SetOperations

                   

                     set = redisTemplate.opsForSet();

                    
        

                    return set.members(key);

                    
    }

                    


                    
    

                    /**
     * 有序集合添加
     *
     * @param key
     * @param value
     * @param scoure
     */

                    
    

                    public void zAdd(String key, Object value, double scoure) {

                    
        ZSetOperations

                    

                      zset = redisTemplate.opsForZSet();

                     
        zset.add(key, value, scoure);

                     
    }

                     


                     
    

                     /**
     * 有序集合获取
     *
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */

                     
    

                     public Set rangeByScore(String key, double scoure, double scoure1) {
        ZSetOperations

                       

                         zset = redisTemplate.opsForZSet();

                        
        redisTemplate.opsForValue();

                        
        

                        return zset.rangeByScore(key, scoure, scoure1);

                        
    }

                        


                        


                        
    

                        //第一次加载的时候将数据加载到redis中

                        
    

                        public void saveDataToRedis(String name) {

                        
        

                        double index = Math.abs(name.hashCode() % size);

                        
        

                        long indexLong = 

                        new Double(index).longValue();

                        
        

                        boolean availableUsers = setBit(

                        "availableUsers", indexLong, 

                        true);

                        
    }

                        


                        
    

                        //第一次加载的时候将数据加载到redis中

                        
    

                        public boolean getDataToRedis(String name) {

                        


                        
        

                        double index = Math.abs(name.hashCode() % size);

                        
        

                        long indexLong = 

                        new Double(index).longValue();

                        
        

                        return getBit(

                        "availableUsers", indexLong);

                        
    }

                        


                        
    

                        /**
     * 有序集合获取排名
     *
     * @param key 集合名称
     * @param value 值
     */

                        
    

                        public Long zRank(String key, Object value) {

                        
        ZSetOperations

                        

                          zset = redisTemplate.opsForZSet();

                         
        

                         return zset.rank(key,value);

                         
    }

                         


                         


                         
    

                         /**
     * 有序集合获取排名
     *
     * @param key
     */

                         
    

                         public Set

                         

                          > zRankWithScore(String key, long start,long end) {
        ZSetOperations

                           

                             zset = redisTemplate.opsForZSet();

                            
        Set

                            

                             > ret = zset.rangeWithScores(key,start,end);
        return ret;
    }

    /**
     * 有序集合添加
     *
     * @param key
     * @param value
     */
    public Double zSetScore(String key, Object value) {
        ZSetOperations

                              

                               zset = redisTemplate.opsForZSet();

                              
        

                              return zset.score(key,value);

                              
    }

                              


                              


                              
    

                              /**
     * 有序集合添加分数
     *
     * @param key
     * @param value
     * @param scoure
     */

                              
    

                              public void incrementScore(String key, Object value, double scoure) {

                              
        ZSetOperations

                              

                               zset = redisTemplate.opsForZSet();

                              
        zset.incrementScore(key, value, scoure);

                              
    }

                              


                              


                              
    

                              /**
     * 有序集合获取排名
     *
     * @param key
     */

                              
    

                              public Set

                              

                              > reverseZRankWithScore(String key, long start,long end) {
        ZSetOperations

                              

                               zset = redisTemplate.opsForZSet();

                              
        Set

                              

                              > ret = zset.reverseRangeByScoreWithScores(key,start,end);
        return ret;
    }

    /**
     * 有序集合获取排名
     *
     * @param key
     */
    public Set

                              

                              > reverseZRankWithRank(String key, long start, long end) {
        ZSetOperations

                              

                               zset = redisTemplate.opsForZSet();

                              
        Set

                              

                              > ret = zset.reverseRangeWithScores(key, start, end);
        return ret;
    }
}
控制层
RedisController.java
package com.cyb.mobile.controller;

import com.cyb.mobile.utils.RedisUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @ClassName：TestController
 * @Description：Redis控制器
 * @Author：chenyb
 * @Date：2020/8/17 12:07 上午
 * @Versiion：1.0
 */
@RestController
public class RedisController {
    @Autowired
    private RedisUtils redisUtils;
    @RequestMapping("setAndGet")
    public String test(String k,String v){
        redisUtils.set(k,v);
        return (String) redisUtils.get(k);
    }
}
测试
SpringBoot整合Mybatis 
添加依赖

<dependency>
    <groupId>org.mybatis.spring.bootgroupId>
    <artifactId>mybatis-spring-boot-starterartifactId>
    <version>2.1.3version>
dependency>

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
dependency>

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>druidartifactId>
    <version>1.1.23version>
dependency>
完整pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.3.3.RELEASEversion>
        <relativePath/> 
    parent>
    <groupId>com.cybgroupId>
    <artifactId>chenyb-mobile-redisartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>chenyb-mobile-redisname>
    <description>Demo project for Spring Bootdescription>

    <properties>
        <java.version>1.8java.version>
    properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintagegroupId>
                    <artifactId>junit-vintage-engineartifactId>
                exclusion>
            exclusions>
        dependency>
        <dependency>
            <groupId>io.projectreactorgroupId>
            <artifactId>reactor-testartifactId>
            <scope>testscope>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
        dependency>
        
        <dependency>
            <groupId>org.mybatis.spring.bootgroupId>
            <artifactId>mybatis-spring-boot-starterartifactId>
            <version>2.1.3version>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
        dependency>
        
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druidartifactId>
            <version>1.1.23version>
        dependency>
    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>

project>
设置配置文件
application.properties
# 连接的那个数据库
spring.redis.database=0
# redis服务的ip地址
spring.redis.host=192.168.199.142
# redis端口号
spring.redis.port=6379
# redis的密码，没设置过密码，可为空
spring.redis.password=12345678
# 端口号
server.port=8081
# ========================数据库相关配置=====================
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/nba?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root
# 使用阿里巴巴druid数据源，默认使用自带
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
#开启控制台打印sql
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
# mybatis 下划线转驼峰配置，两者都可以
# mybatis.configuration.mapUnderscoreToCamelCase=true
mybatis.configuration.map-underscore-to-camel-case=true
# 配置扫描
mybatis.mapper-locations=classpath:mapper/*.xml
# 实体类所在的包别名
mybatis.type-aliases-package=com.cyb.mobile.domain
启动类上添加扫描路径
NbaPlayer.java（实体类）
NbaPlayerMapper.xml

mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cyb.mobile.mapper.NbaPlayerMapper">
    <select id="ListNbaPlayer" resultType="NbaPlayer">
        SELECT * FROM nba_player
    select>
mapper>
NbaPlayerMapper.java
NbaPlayerService.java
NbaPlayerServiceImpl.java
控制器(Controller)
测试
redis作为mybatis缓存 


                              

    
                              

  1. 
                              

    
                              
    用户第一次访问的时候获取数据库的值，再次访问时直接从缓存中获取数据

    
                              

    2. 
                              

  2. 
                              

    
                              
    设置缓存过期时间

    
                              

    3. 
                              


                              


                              
   练手项目，学习强化，点击这里


                              
代码演示
添加FastJSON依赖

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>fastjsonartifactId>
    <version>1.2.73version>
dependency>
~
@RequestMapping("test")
public Object test(){
    //step1 先从redis中取
    String strJson=(String) redisUtils.get("nbaPlayerCache");
    if (strJson==null){
        System.out.println("从db取值");
        // step2如果拿不到则从DB取值
       List

                              

                               listNbaPlayer=nbaPlayerService.ListNbaPlayer();

                              
       

                              // step3 DB非空情况刷新redis值

                              
       

                              if (listNbaPlayer!=

                              null){

                              
           redisUtils.set(

                              "nbaPlayerCache", JSON.toJSONString(listNbaPlayer));

                              
           

                              return listNbaPlayer;

                              
       }

                              
       

                              return 

                              null;

                              
    }

                              else

                              
    {

                              
        System.out.println(

                              "从redis缓存取值");

                              
        

                              return JSONObject.parseArray(strJson,NbaPlayer

                              .class);

                              
    }

                              
}

                              


                              
注意
项目8080是对外端口(向外部暴露的端口)，区别于内部进程号，查内部端口用ps -ef|grep port，查外部端口用lsof -i:port


                              


                              


                              


                              


                              


                              
压测工具 
上面我们已经SpringBoot整合Redis和Mybatis，但是无法知道具体QPS多少，此时我们可以使用压测工具来测压，参考：


                              


                              
https://www.cnblogs.com/chenyanbin/p/13332068.html


                              
资料下载 


                              


                              
链接: https://pan.baidu.com/s/1d4xwXVfA6dYHvLFxha59Kg   密码: bff7


                              


                              


                              


                              


                              
PS：欢迎在留言区留下你的观点，一起讨论提高。如果今天的文章让你有新的启发，欢迎转发分享给更多人。

Java后端编程交流群已成立

公众号运营至今，离不开小伙伴们的支持。为了给小伙伴们提供一个互相交流的平台，特地开通了官方交流群。扫描下方二维码备注 进群 或者关注公众号 Java后端编程 后获取进群通道。



                              


                              


                              


                              


                              



                              


                              —————END—————

                              


                              



                              


                              


                              


                              


                              
推荐阅读：


                              


                              


                              


                              



                              



                              


                              


                              
最近面试BAT，整理一份面试资料《Java面试BAT通关手册》，覆盖了Java核心技术、JVM、Java并发、SSM、微服务、数据库、数据结构等等。
获取方式：点“在看”，关注公众号并回复 666 领取，更多内容陆续奉上。


                              


                              


                              明天见(｡･ω･｡)ﾉ♡



浏览 36
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报
评论
图片
表情
推荐
SpringBoot实战：整合Redis、mybatis，封装RedisUtils工具类等（附源码）
Java项目开发
0
SpringBoot实战：整合Redis、mybatis，封装RedisUtils工具类等（附源码）
程序员闪充宝
0
SpringBoot实战：整合Redis、mybatis，封装RedisUtils工具类等（附源码）
Java开发宝典
0
SpringBoot实战：整合Redis、mybatis，封装RedisUtils工具类等（附源码）
Java高效学习
0
SpringBoot实战：整合Redis、mybatis，封装RedisUtils工具类等
程序IT圈
0
SpringBoot整合Redis、mybatis实战，封装RedisUtils工具类，redis缓存mybatis数据 附源码
java1234
0
Spring Boot实战：整合Redis、MyBatis，封装RedisUtils工具类
程序员的成长之路
0
SpringBoot整合SpringSecurity（附源码）
java1234
0
springboot 整合 redis
JAVA乐园
0
SpringBoot整合Redis做缓存，实战分享
Stephen
0
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报