搜索

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 领取，更多内容陆续奉上。

                              

                              

                              明天见(｡･ω･｡)ﾉ♡
浏览 24
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报
评论
图片
表情
推荐
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
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报