Spring Data Redis

发布于：2023-01-04 ⋅ 阅读:(277) ⋅ 点赞:(0)
微信交流群：https://732903.hlcode.cn/?id=NK1fWUR

目录

一、Spring Data 介绍

1.1  Spring Data Redis 介绍

 1.2 为什么用redis？什么时候用redis？

1.3 缓存同步

二、Spring Data Redis 使用

2.1 创建父工程

2.2 导入依赖 

 2.3 application.yml

 2.4 config(RedisTemplate的配置)

 2.5 启动器

 2.6 实体类pojo

 2.7 RedisClient 工具类

 2.7 开始测试

一、Spring Data 介绍

Spring Data是一个用于简化数据库访问的开源框架。其主要目标是使得对数据的访问变得方便快捷，包含多个子项目：

  • Spring Data JDBC- 对JDBC的Spring Data存储库支持。

  • Spring Data JPA - 对JPA的Spring Data存储库支持。

  • Spring Data MongoDB - 对MongoDB的基于Spring对象文档的存储库支持。

  • Spring Data Redis - 从Spring应用程序轻松配置和访问Redis。

    ... ...

1.1  Spring Data Redis 介绍

Spring Data Redis 是属于 Spring Data 下的一个模块，作用就是简化对于 redis 的操做。

spring-data-redis针对jedis提供了如下功能：

  1. 提供了一个高度封装的“RedisTemplate”类，里面封装了对于Redis的五种数据结构的各种操作，包括：

     - redisTemplate.opsForValue()：操作字符串
 - redisTemplate.opsForHash()：操作hash
 - redisTemplate.opsForList()：操作list
 - redisTemplate.opsForSet()：操作set
 - redisTemplate.opsForZSet()：操作zset

  2. SpringBoot2.x后RedisTemplate采用是lettuce(基于netty采用异步非阻塞式lO)进行通信，大并发下比jedis效率更高。

  3. RedisTemplate模板使用序列化器操作redis数据，预定义的序列化方案有：

    序列化器 说明
    JdkSerializationRedisSerializer POJO对象的存取场景，使用JDK本身序列化机制，将pojo类通过ObjectInputstream/ObjectOutputstream进行序列化操作，最终redis-server中将存储字节序列。是目前最常用的序列化策略。
    stringRedisSerializer Key或者value为字符串的场景，根据指定的charset对数据的字节序列编码成string,是"new String(bytes,charset)"和“string.getBytes(charset)"的直接封装。是最轻量级和高效的策略。
    GenericJackson2JsonRedisSerializer jackson-json工具提供了javabean与json之间的转换能力，可以将pojo实例序列化成json格式存储在redis中，也可以将json格式的数据转换成pojo实例。

 1.2 为什么用redis？什么时候用redis？

 首先我们为什么用redis呢？

        众所周知redis的读取速度甩mysql好几条街，如果我们的项目中都使用连接数据库的查询那么在高并发访问量巨多的时候，mysql是撑不住的，所以我们选择有些地方使用redis来进行读取数据。

我们在什么时候使用redis呢？

记住一点就是在那些修改比较少，访问量极大的地方使用，比如：商城的主页，搜索展示页面~等等

1.3 缓存同步

做缓存的同时不能忘记做缓存同步，不然读取到的数据就是缺失的了

缓存同步就是在项目中的增删改操作后只需要把对应缓存删除即可

二、Spring Data Redis 使用

2.1 创建父工程

2.2 导入依赖 

<?xml version="1.0" encoding="UTF-8"?>
<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.bjpowernode</groupId>
    <artifactId>spring_Data_redis</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
    </parent>

    <properties>
        <!-- 项目源码及编译输出的编码 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <!-- springBoot的启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- Spring Data Redis的启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--junit 的启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>
</project>

 2.3 application.yml

这里设置的是连接redis集群ip地址和端口号，如果不会搭redis集群看主页文章

spring:
  redis:
    cluster:
      nodes:
        - 192.168.57.135:7001
        - 192.168.57.135:7002
        - 192.168.57.135:7003
        - 192.168.57.135:7004
        - 192.168.57.135:7005
        - 192.168.57.135:7006
    jedis:
      pool:
        max-active: 20 #连接池最大连接数
        max-idle: 10 #连接池中的最大空闲连接
        min-idle: 5 # 连接池中的最小空闲连接

 2.4 config(RedisTemplate的配置)

/**
 * 完成对Redis的整合的一些配置
 */
@Configuration
public class RedisConfig {

    /**
     * 创建RedisTemplate:用于执行Redis操作的方法
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory)    {
        RedisTemplate<String, Object> redisTemplate= new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(factory);

        //设置通用序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        
        return redisTemplate;
    }
}

 2.5 启动器

@SpringBootApplication
public class App {
	public static void main(String[] args) {
		SpringApplication.run(App.class, args);
	}
}

 2.6 实体类pojo

public class User implements Serializable {
	
	private Integer id;
	private String name;
	private Integer age;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
}

 2.7 RedisClient 工具类

package com.bjpowernode.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

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

/**
 * redisTemplate封装
 */
@Component
public class RedisClient {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key,long time){
        try {
            if(time>0){
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long ttl(String key){
        return redisTemplate.getExpire(key,TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public Boolean exists(String key){
        return redisTemplate.hasKey(key);
    }

    //============================String=============================
    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key){
        return key==null?null:redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key,Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    public Boolean del(String key){
       return redisTemplate.delete(key);
    }

    /**
     * 递增
     * @param key 键
     * @param delta 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta){
        if(delta<0){
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     * @param key 键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta){
        if(delta<0){
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().decrement(key, -delta);
    }

    //================================hash=================================
    /**
     * HashGet
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key,String item){
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key,String item,Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     * @param key 键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item){
        redisTemplate.opsForHash().delete(key,item);
    }

    //============================set=============================
    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    public Set<Object> smembers(String key){
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将数据放入set缓存
     * @param key 键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sadd(String key, Object...values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 移除值为value的
     * @param key 键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long srem(String key, Object ...values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    //===============================list=================================

    /**
     * 获取list缓存的内容
     * @param key 键
     * @param start 开始
     * @param end 结束  0 到 -1代表所有值
     * @return
     */
    public List<Object> lrange(String key, long start, long end){
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public boolean rpush(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public boolean lpush(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     * @param key 键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lrem(String key,long count,Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

}

 2.7 开始测试

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = {RedisAPP.class})
public class RedisTest {

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private RedisClient redisClient;

    @Test
    public void setStr(){
        User user = new User();
        user.setId(1);
        user.setName("彭于晏");
        user.setAge(23);
        //使用redisTemplate
        redisTemplate.opsForValue().set("user",user);

    }

    @Test
    public void getStr(){
        //使用redisTemplate
        User user1 = (User) redisTemplate.opsForValue().get("user1");
        System.out.println(user1);
    }

    @Test
    public void setUser(){
        User user = new User();
        user.setId(1);
        user.setName("张三丰");
        user.setAge(140);
        //使用RedisClient工具类
        redisClient.set("user2",user);
    }

    @Test
    public void getUser(){
        //使用RedisClient工具类
        User user2 = (User) redisClient.get("user2");
        System.out.println(user2);
    }
}

打开RedisPlus可以看到已经存到里面了

运行获取数据方法都可以从redis中获取，使用工具类的话更方便一些，不用硬记方法

本文含有隐藏内容，请 开通VIP 后查看

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布