关于后端:SpringBoot-整合-RedisMybatis封装-RedisUtils-工具类

5次阅读

共计 9289 个字符，预计需要花费 24 分钟才能阅读完成。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

package com.malf.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;

/**
 * @author malf
 * @description Redis 配置类，设置 Redis 的 Template
 * @date 2021/5/23
 * @project springboot_mybatis
 */
@Configuration
public class RedisConfig {

    // redisTemplate 注入到 Spring 容器
    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        RedisSerializer<String> 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;
    }

}

spring:
  redis:
    # 连贯的那个数据库 
    database: 0
    # redis 服务的 ip 地址
    host: localhost
    # redis 端口号
    port: 6379
    # redis 的明码，没设置过明码，可为空
    password:

package com.malf.util;

import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author malf
 * @description Redis 工具类
 * @date 2021/5/23
 * @project springboot_mybatis
 */
@Service
public class RedisUtils {

    @Resource
    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<Serializable, Object> 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<Serializable, Object> 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<Serializable, Object> 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<Serializable, Object> 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<Serializable, Object> 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<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key, hashKey, value);
    }

    /**
     * 哈希获取数据
     *
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey) {HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
    }

    /**
     * 列表增加
     *
     * @param k
     * @param v
     */
    public void lPush(String k, Object v) {ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }

    /**
     * 列表获取
     *
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> lRange(String k, long l, long l1) {ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }

    /**
     * 汇合增加
     *
     * @param key
     * @param value
     */
    public void add(String key, Object value) {SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key, value);
    }

    /**
     * 汇合获取
     *
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key) {SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * 有序汇合增加
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure) {ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }

    /**
     * 有序汇合获取
     *
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key, double scoure, double scoure1) {ZSetOperations<String, Object> 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<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rank(key, value);
    }


    /**
     * 有序汇合获取排名
     *
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> zRankWithScore(String key, long start, long end) {ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.rangeWithScores(key, start, end);
        return ret;
    }

    /**
     * 有序汇合增加
     *
     * @param key
     * @param value
     */
    public Double zSetScore(String key, Object value) {ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.score(key, value);
    }


    /**
     * 有序汇合增加分数
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void incrementScore(String key, Object value, double scoure) {ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.incrementScore(key, value, scoure);
    }


    /**
     * 有序汇合获取排名
     *
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithScore(String key, long start, long end) {ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeByScoreWithScores(key, start, end);
        return ret;
    }

    /**
     * 有序汇合获取排名
     *
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithRank(String key, long start, long end) {ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeWithScores(key, start, end);
        return ret;
    }

}

package com.malf.controller;

import com.malf.util.RedisUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @author malf
 * @description
 * @date 2021/5/23
 * @project springboot_mybatis
 */
@RestController
public class RedisController {

    @Resource
    private RedisUtils redisUtils;

    @RequestMapping("setAndGet")
    public String test(String k, String v) {redisUtils.set(k, v);
        return (String) redisUtils.get(k);
    }

}

<!--mybatis 依赖 -->
<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>2.1.4</version>
</dependency>
<!--mysql 驱动 -->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <scope>runtime</scope>
</dependency>
<!--druid-->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>1.1.23</version>
</dependency>

server:
  port: 8000
mybatis:
  # 配置扫描
  mapper-locations: classpath:mapping/*Mapper.xml
  # 实体类所在的包别名
  type-aliases-package: com.malf.entity
  configuration:
    # 开启控制台打印 sql
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    # mybatis 下划线转驼峰配置
    map-underscore-to-camel-case: true
#showSql
logging:
  level:
    com:
      example:
        mapper: debug
spring:
  redis:
    # 连贯的那个数据库
    database: 0
    # redis 服务的 ip 地址
    host: localhost
    # redis 端口号
    port: 6379
    # redis 的明码，没设置过明码，可为空
    password:
  # 数据库相干配置    
  datasource:
    url: jdbc:mysql://localhost:3306/springboot_mybatis?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    # 应用阿里巴巴 druid 数据源，默认应用自带
    type: com.alibaba.druid.pool.DruidDataSource

@MapperScan("com.malf.dao") // 扫描的 mapper

<!--fastjson 依赖 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.73</version>
</dependency>

    @RequestMapping("test")
    public Object test() {
        // step1 先从 redis 中取
        String strJson = (String) redisUtils.get("nbaPlayerCache");
        if (strJson == null) {System.out.println("从 db 取值");
            // step2 如果拿不到则从 DB 取值
            List<NBAPlayer> listNbaPlayer = nbaPlayerService.list();
            // 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);
        }
    }

目前为止曾经将 SpringBoot、Redis 和 Mybatis 整合到了一起，然而无奈晓得具体 QPS 多少，此时咱们能够应用压测工具来测压，参考：
https://www.cnblogs.com/chenyanbin/p/13332068.html

springboot+redis+mybatis

正文完

后端

发表至：后端

2021-06-19

0

关于后端:Cilium-如何处理-L7-流量

关于后端:静态代理还是动态代理来聊聊Java中的代理设计模式

关于后端:Flink-流批一体方案在数禾的实践

关于后端:Servlet系列两种创建方式xml注解

关于操作系统:从零开始写-OS-内核-虚拟内存完善

关于后端:SpringBoot-整合-RedisMybatis封装-RedisUtils-工具类

SpringBoot 整合 Redis、Mybatis，封装 RedisUtils 工具类

创立 SpringBoot 我的项目（略）

Redis 局部

引入 redis 依赖

Redis 配置类

配置 Redis 连贯信息

Redis 工具类

管制层

启动我的项目，测试 Redis

Mybatis 局部

增加 Mybatis 相干依赖

配置 Mybatis 及其他

启动类减少扫描门路

entity、dao、service、controller 代码见源码参考

测试

Redis 作为 Mybatis 缓存

增加 fastjson 依赖

测试接口

打印台成果

压测工具

源码参考

站内搜索