redis学习-33-SpringBoot整合redis

最新推荐文章于 2024-07-10 14:39:07 发布
最新推荐文章于 2024-07-10 14:39:07 发布
阅读量343 收藏
点赞数
分类专栏： redis 文章标签： spring boot redis 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42045639/article/details/130568941
版权

36.SpringBoot整合redis

  • SpringBoot操作数据：使用spring-data项目。例如：jpa、jdbc 、mongodb 、redis…

  • SpringData也是和SpringBoot齐名的项目！说明：在SpringBoot2.×之后，原来使用的jedis被替换为了lettuce?

  • jedis和lettuce的区别：

    • jedis采用的直连，多个线程操作的话，是不安全的，如果想要避免不安全的，需使用jedis pool连接池。类似BIO阻塞通信方式，但会带来一些问题。如：线程数量多、redis服务太大了。
    • 采用高性能网络框架netty，采用异步请求NIO的方式。实例可以在多个线程中共享，不存在线程不安全的情况,可以减少线程数量，不需要开连接池了。（dubbo底层也是用的netty）。涉及到这种网络框架netty、dubbo等nio类型的框架，里面的对象都需要序列化才能进行通信。
36.1 整合步骤
  • 1.创建一个springboot整合项目：springboot-redis。其中的pom需要涉及的包为：
<dependencies>
        <!--操作redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
  • 源码分析：
#SpringBoot所有的配置类，都有一个自动配置类 redis在springboot 中的自动配置类  RedisAutoConfiguration
#自动配置类都会绑定一个properties配置属性类，来绑定配置文件application.properties/application.yml中的配置项		RedisProperties

@AutoConfiguration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

	@Bean
	@ConditionalOnMissingBean(name = "redisTemplate")	//可以自定义一个redisTemplate来替换默认的
	@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
	public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
		//默认的redisTemplate没有做过多的设置，比如：redis对象都需要序列化
		//RedisTemplate<Object, Object>两个都是Object，后续使用要进行强制转换为<String,Object>
		RedisTemplate<Object, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

	//由于string是redis中最常使用的类型，所以说单独提出来了一个bean!
	@Bean
	@ConditionalOnMissingBean
	@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
		return new StringRedisTemplate(redisConnectionFactory);
	}

}

注意：RedisConnectionFactory接口有两个实现类：JedisConnectionFactory、LettuceConnectionFactory
由于JedisConnectionFactory里面一些类不存在，所以JedisConnectionFactory不生效。所以配置redis的连接池、集群使用Lettuce的配置项

  • 2.配置连接，在application.yml进行配置
#配置redis
spring:
  redis:
    host: 121.x.x.x
    password: 123456
    ssl: false
    port: 6379
  • 链接测试，测试步骤：
    • 1.使用原生RedisTemplate、StringRedisTemplate进行存值测试：发现StringRedisTemplate存值不乱码，且无法存取对象；使用RedisTemplate存对象值乱码，且无法存取为序列化的对象；
    • 2.将对象进行序列化进行测试，使用RedisTemplate能够进行存值，但存在乱码，原因jdk序列化引起；
    • 3.自定义RedisTemplate替代jdk序列化，然后进行RedisTemplate能够进行存值不乱码；
    • 4.将RedisTemplate的常用方法进行封装为RedisUtil(网上一大堆)，进行测试。期间有两种改造RedisTemplate的方法。一种是在配置类中自定义RedisTemplate，第二种是对原有的RedisTemplate进行序列化重新设置，二者任选一使用。
@SpringBootTest
class SpringbootRedisApplicationTests {

    @Autowired                                      //按照 Bean 的类型进行装配Type。
    @Qualifier("redisTemplate")                     //存在多个RedisTemplate,可以使用Qualifier使用bean的name
    private RedisTemplate redisTemplate;            //当无法使用第一种自定义RedisTemplate方法
	//先将Qualifier注释掉使用原生redisTemplate对象测试

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private RedisUtil redisUtil;                 //第二种对原来的RedisTemplate进行改造

    @Test
    void contextLoads() {

        /*
        * stringRedisTemplate操作不同的数据类型
        * opsForValue()     操作String
        * opsForList()      操作list
        * opsForHash()      操作Hash
        * opsForGeo()       操作地图
        * opsForSet()       操作set
        * opsForZSet()      操作zset
        * opsForHyperLogLog()       操作HyperLogLog基数统计
        *stringRedisTemplate.opsForValue().getBit()     操作bitmap
        * */

        /*
        * 除了基本的操作，常用的方法还可以直接通过stringRedisTemplate进行操作。
        * 如：绑定操作、事务、过期时间、移除、删除、复制、重命名、排序、主从复制等操作
        * */
        System.out.println("redisTemplate:"+redisTemplate.opsForValue().get("name"));
        System.out.println(stringRedisTemplate.opsForValue().get("name"));
        System.out.println(stringRedisTemplate.opsForValue().get("num"));
        List mycourselist = stringRedisTemplate.opsForList().range("mycourselist", 0, -1);
        Object user = stringRedisTemplate.opsForHash().get("user", "id:1");
        Boolean mybit = stringRedisTemplate.opsForValue().getBit("mybit", 1);
        System.out.println(mycourselist);
        System.out.println(user.toString());
        System.out.println(mybit);

        //获取redis链接对象
        RedisConnection connection = stringRedisTemplate.getConnectionFactory().getConnection();
        /*
        connection.shutdown();
        connection.flushAll();
        connection.flushDb();
        connection.close();*/
        stringRedisTemplate.opsForValue().set("redisTemplate","redis模板");
        System.out.println(stringRedisTemplate.opsForValue().get("redisTemplate"));

    }

}

--结果--
redisTemplate:null
tony
98
[c#, python, php, java]
wu
true
redis模板
36.2 对象序列化乱码配置
  • RedisTemplate源码序列化分析：
    在这里插入图片描述
    在这里插入图片描述

RedisTemplate:默认的序列化是jdk序列化，会使字符串转义，需要使用json进行序列化，为实现这个改造序列化，需要自定义配置类

  • 保存对象序列化测试，先将对象进行序列化为字符串之后进行保存：
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;

import java.io.Serializable;    //实现序列化接口

/**
 * @author CNCLUKZK
 * @create 2023/3/18-0:48
 */

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {		//先不序列化对象测试
    private String name;
    private int age;
}

//StringRedisTemplate.opsForValue.set()方法只有String,String参数 , 要传对象需要自己先手动装json
@Test
    public void testJson(){
        //真实的开发一般都使用5son来传递对象,用的json字符串加密后存储的
        User user = new User("张三", 18);
        //jackson将对象转为字符串
        ObjectMapper objectMapper = new ObjectMapper();
        String asString = "";
        try {
            //该方法可用于将任何Java值序列化为字符串
            asString = objectMapper.writeValueAsString(user);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        System.out.println(asString);
        System.out.println("user.toString():"+user.toString());
        /*stringRedisTemplate无法存对象
        stringRedisTemplate.opsForValue().set("user2",user);*/
        //stringRedisTemplate对象存string值key不乱码
        stringRedisTemplate.opsForValue().set("user3",asString);
        stringRedisTemplate.opsForValue().set("user4",user.toString());
        System.out.println("stringRedisTemplate对象json序列化："+stringRedisTemplate.opsForValue().get("user3"));
        System.out.println("stringRedisTemplate对象toString:"+stringRedisTemplate.opsForValue().get("user4"));
        /*redisTemplate无法存未序列化的对象
        redisTemplate.opsForValue().set("user1",user);*/
        //原生redisTemplate对象存string值key乱码，jdk序列化引起的
        redisTemplate.opsForValue().set("user5",asString);
        System.out.println("redisTemplate对象json序列化："+redisTemplate.opsForValue().get("user5"));
        redisTemplate.opsForValue().set("user6",user.toString());
        System.out.println("redisTemplate对象toString："+redisTemplate.opsForValue().get("user6"));
    }
    
    --结果--
{"name":"张三","age":18}
user.toString():User(name=张三, age=18)
stringRedisTemplate对象json序列化：{"name":"张三","age":18}
stringRedisTemplate对象toString:User(name=张三, age=18)
redisTemplate对象json序列化：{"name":"张三","age":18}
redisTemplate对象toString：User(name=张三, age=18)
  • 注意在保存对象时会报序列化错误，未将对象序列化时：
    在这里插入图片描述
  • 然后在定义对象时进行序列化，结果发现在redis中存放的确实是序列化的对象
import java.io.Serializable;    //实现序列化接口

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable{      //在企业中，我们的所有pojo都会序列化！SpringBoot
    private String name;
    private int age;
}

Test{
//autowired是mybatis里面工厂生产对象的注解，springboot里面用的是resource，
// 如果你不想爆红就加上mybatis-springboot的包
@Autowired                                      //按照 Bean 的类型进行装配Type。
@Qualifier("redisTemplate")                     //存在多个RedisTemplate,可以使用Qualifier使用bean的name
private RedisTemplate redisTemplate;            //当无法使用(跳不过去自定义方法)第一种自定义RedisTemplate方法


//之后在使用原生redisTemplate进行测试可以存对象了，但存在乱码
@Test
public void testJson2(){
    //对user对象进行序列化，之后用原生redisTemplate进行存值
    //原生redisTemplate对象存序列化后的对象或着是普通字符串key乱码，jdk序列化引起的
    User user = new User("李四", 18);
    redisTemplate.opsForValue().set("user7",user);
    System.out.println("对象user7序列化："+redisTemplate.opsForValue().get("user7"));
    redisTemplate.opsForValue().set("simpleStr","简单字符");
    System.out.println(redisTemplate.opsForValue().get("simpleStr"));
    //自定义redisTemplate对象存序列化后的对象或着是普通字符串key不乱码
}
}    
    --结果--
   对象user7序列化：User(name=李四, age=18)
	简单字符

在这里插入图片描述

  • 之后自定义RedisTemplate解决乱码问题
package com.zk.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.DefaultBaseTypeLimitingValidator;
import com.fasterxml.jackson.databind.jsontype.PolymorphicTypeValidator;
import com.zk.util.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisClusterConnection;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisSentinelConnection;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author CNCLUKZK
 * @create 2023/3/17-16:14
 */
@Configuration
public class RedisConfig {

    /*@Bean
    public RedisConnectionFactory redisConnectionFactory() {
        LettuceConnectionFactory lettuceConnectionFactory = new LettuceConnectionFactory();
        //lettuceConnectionFactory.setHostName("远程地址");   //默认为本地redis数据库
        return lettuceConnectionFactory;
    }*/

    //方式1.自定义RedisTemplate,固定模板。与下面的方式2，可以2选一
    //redisTemplate 序列化使用的jdkSerializeable，存储二进制字节码, 所以自定义序列化类
    //对比xml中bean方式返回值为class,name为方法名
    @Bean
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        //我们为了自己开发方使，一般直接使用<String,Object>
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        //配置具体的序列化方式,要实现RedisSerializer接口，其实现类
        //key采用string的序列化方式
        template.setKeySerializer(RedisSerializer.string());
        //Hash的key也采用string的序列化方式
        template.setHashKeySerializer(RedisSerializer.string());
        //value采用Jackson序列化方式序列化为json字符串
        template.setValueSerializer(RedisSerializer.json());
        //Hash的value采用Jackson序列化方式序列化为json字符串
        template.setHashValueSerializer(RedisSerializer.json());
        template.afterPropertiesSet();
        return template;
    }
    //旧版自定义redisTemplate，发现序列化后还是用的jdk乱码
    public RedisTemplate<String, Object> redisTemplateOld(RedisConnectionFactory redisConnectionFactory) {
        //我们为了自己开发方使，一般直接使用<String,Object>
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(redisConnectionFactory);
        //json序列化配置，用json解析任意配置
        Jackson2JsonRedisSerializer<Object> objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        //进行ObjectMapper进行转义
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //objectMapper.activateDefaultTyping();   // 过期使用这个
        /*//PolymorphicTypeValidator抽象类，DefaultBaseTypeLimitingValidator继承类
        DefaultBaseTypeLimitingValidator defaultBaseTypeLimitingValidator = new DefaultBaseTypeLimitingValidator();
        objectMapper.activateDefaultTyping(defaultBaseTypeLimitingValidator,ObjectMapper.DefaultTyping.NON_FINAL);*/
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        objectJackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        //String序列化配置
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //配置具体的序列化方式,要实现RedisSerializer接口，其实现类
        template.setValueSerializer(objectJackson2JsonRedisSerializer);
        //Hash的value采用Jackson序列化方式序列化为json字符串
        template.setHashValueSerializer(objectJackson2JsonRedisSerializer);
        //key采用string的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        //Hash的key也采用string的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }

    //方式2.使用原有的RedisTemplate，在使用前替换掉序列化类(initMethod = "init")
    @Bean(initMethod = "init")
    public RedisUtil redisUtil(){
        return new RedisUtil();
    }
}

  • RedisSerializer接口的实现类
    在这里插入图片描述

  • 再使用testJson2()方法进行测试，发现存值不乱码

 @Test
    public void testJson2(){
        //对user对象进行序列化，之后用原生redisTemplate进行存值
        //原生redisTemplate对象存序列化后的对象或着是普通字符串key乱码，jdk序列化引起的
        User user = new User("李四", 18);
        redisTemplate.opsForValue().set("user7",user);
        System.out.println("对象user7序列化："+redisTemplate.opsForValue().get("user7"));
        redisTemplate.opsForValue().set("simpleStr","简单字符");
        System.out.println(redisTemplate.opsForValue().get("simpleStr"));
       //自定义redisTemplate对象存序列化后的对象或着是普通字符串key不乱码
    }
36.3 封装RedisTemplate方法RedisUtil
  • 将RedisTemplate的常用方法封装为RedisUtil,除了封装常用方法也可以替代前面的自定义RedisTemplate对原有的RedisTemplate的序列化方式进行替换，然后将RedisUtil作为bean配置到配置类中，供后续测试使用。RedisUtil方法：
package com.zk.util;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author CNCLUKZK
 * @create 2023/3/18-3:22
 */

/*在企业开发中，我们8©%的情况下，都不会使用这个原生的方式去编写代码！
  般都可以看到一个公司自己封装Redisutils
  */

public class RedisUtil {

    @Autowired
    private RedisTemplate redisTemplate;            //当无法使用(跳不过去自定义方法)第一种自定义RedisTemplate方法

    //2.使用原有的RedisTemplate，在使用前替换掉序列化类
    public void init(){
        //配置具体的序列化方式,要实现RedisSerializer接口，其实现类
        //value采用Jackson序列化方式序列化为json字符串
        redisTemplate.setValueSerializer(RedisSerializer.json());
        //Hash的value采用Jackson序列化方式序列化为json字符串
        redisTemplate.setHashValueSerializer(RedisSerializer.json());
        //key采用string的序列化方式
        redisTemplate.setKeySerializer(RedisSerializer.string());
        //Hash的key也采用string的序列化方式
        redisTemplate.setHashKeySerializer(RedisSerializer.string());
    }

    // =============================common============================

    public Set<String> keys(String pattern) {
        return redisTemplate.keys(pattern);
    }

    /**
     * 指定缓存失效时间
     *
     * @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 getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(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   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     *
     * @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().increment(key, -delta);
    }

    // ================================Map=================================

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

    /**
     * 获取hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张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   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            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);
    }

    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    // ============================set=============================

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

    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

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

    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0)
                expire(key, time);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     *
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(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> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     *
     * @param key 键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

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

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

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

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

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

}




//方式2.使用原有的RedisTemplate，在使用前替换掉序列化类(initMethod = "init")
    @Bean(initMethod = "init")
    public RedisUtil redisUtil(){
        return new RedisUtil();
    }
  • 对RedisUtil进行测试，未出现乱码
   @Autowired
    private RedisUtil redisUtil;                 //第二种对原来的RedisTemplate进行改造
    
@Test
    public void testRedisUtil(){
        //如果将redisUtil里面的redisTemplate进行init则序列化乱码
        User user = new User("李四", 18);
        redisUtil.set("user8",user);
        redisUtil.set("redistool","redis工具类");
        System.out.println(redisUtil.get("user8"));
        System.out.println(redisUtil.get("redistool"));

    }
--结果---    
User(name=李四, age=18)
redis工具类

在这里插入图片描述

  • 所有的redis操作，其实对于java开发人员来说，十分的简单，更重要是要去理解redis的思想和每一种数据结构的用处和作用场景！
下一篇：redis学习-34-PHP/Python使用Redis
褚师子书
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot3.0(三)：集成 Redis
qq_2118119173的博客
08-11 1276
集成redis
springboot学习——整合redis
qq_36730158的博客
06-30 218
文章目录CacheSpring默认缓存使用步骤@Cacheable运行流程@Cacheable注解参数@CachePut@CacheEvict整合Redis 实现缓存1、整合流程2、redis中5种数据类型基本操作 Cache Spring默认缓存 理解spring默认缓存，遍历整合redis后，对缓存的使用。 使用步骤 引入spring-boot-starter-cache模块 使用@En...
【SpringBoot3】Spring Boot 3.0 集成 Redis 缓存
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
01-22 6691
Redis缓存是一个开源的使用ANSIC语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。它主要用于作为数据库、缓存和消息中间件，以快速读写和丰富的数据结构支持而著称。在应用程序和数据库之间，Redis缓存作为一个中间层起着关键作用。通过将常用的数据存储在Redis内存中，可以快速读取，从而避免了从数据库进行复杂的查询操作，减轻了数据库服务器的压力，并提高了应用程序的性能和响应速度。
【Redis】7、SpringBoot整合Redis、自定义RedisTemplate、RedisUtils工具类
土味儿
03-10 3282
命令窗口下（key-value）显示乱码原因分析：默认使用了的Jdk序列化方式自定义/*** @author 土味儿/*** 自定义RedisTemplate// 直接使用 ，避免类型转换 RedisTemplate < String , Object > template = new RedisTemplate < >();
SpringBoot3整合Redis保姆级教程
最新发布
超超IT的博客
07-10 1080
当SpringBoot项目需要整合Redis时，第一步肯定是先导入Redis的相关依赖（其实第一步应该先下载Redis服务，这里以本地已经安装好Redis为基础），然后再进行Redis相关配置。搞好以后，进行测试，没问题OK，有问题处理。下面就详细讲解SpringBot整合Redis的最基础过程（这里以SpringBoot3.1.5 + JDK17进行演示，其实和3以下的版本没什么区别）。本文涉及知识点：@PropertySource、@Configuration、@Bean、Redis、Lombok。
SpringBoot3整合Redis&基础操作
大菜的博客
03-13 2496
SpringBoot3整合Redis&基础操作
SpringBoot3 整合Redis
一位打工仔的博客
12-26 1220
RedisTemplate、StringRedisTemplate： 操作redis的工具类。要从redis的连接工厂获取链接才能操作redis。属于 JPA 操作，也不用管。属于响应式编程，不用管。
整合Redis（springboot学习15）
m0_55972160的博客
09-01 221
前言: springboot2.0版本之后，整合redis的底层从jedis替换成了lettue jedis：采用的是直连的server，多线程操作不安全，解决办法是使用jedis pool 连接池。类似Bio模式 lettuce： 采用netty，实例可以在多个线程中共享，线程安全，可以减少线程数量。类似Nio模式 源码分析： @Bean @ConditionalOnMissingBean(name = "redisTemplate")//可自定义Template来替换这个默认的 publ
springboot整合spring-data-redis遇到的坑
08-30
使用springboot整合redis,使用默认的序列化配置,然后使用redis-client去查询时查询不到相应的key.问题出在哪，怎么解决呢？下面小编给大家带来了springboot整合spring-data-redis遇到的坑，需要的的朋友参考下吧
springboot整合redis代码
05-14
springboot整合redis.算是比较全面的一种整合方式了. springboot整合redis.算是比较全面的一种整合方式了.
springboot整合redis集群（三种方式）源码
04-01
springboot整合redis集群（三种方式）源码
SpringBoot 整合 Lettuce Redis的实现方法
08-25
SpringBoot 整合 Lettuce Redis 的实现方法 Spring Boot 是为了简化 Spring 应用的创建、运行、调试、部署等一系列问题而诞生的产物，自动装配的特性让我们可以更好的关注业务本身而不是外部的 XML 配置。 Spring ...
解析SpringBoot整合SpringDataRedis的过程
08-19
解析SpringBoot整合SpringDataRedis的过程 SpringBoot整合SpringDataRedis的过程主要是指将SpringBoot框架与SpringDataRedis项目进行集成，以便更好地使用Redis数据库。下面将详细介绍这个过程的步骤和实现细节。 ...
Java --- springboot3整合redis
qq_46093575的博客
06-13 3312
​​​​​​​。
Spring Boot 集成Redis
m0_54239478的博客
09-22 872
java要通过程序访问redis服务器。需要一个中间件或驱动包，初代使用的就是jedis，Jedis Client是Redis官网推荐的一个面向java客户端，库文件实现了对各类API进行封装调用，随着出现一些问题，如线程池不安全等，就出现了lettuce，是一个Redis的java驱动包，是对jedis的优化，之后出现了redisTemplate，使用spring整合了redis，redisTemplate底层包含了lettuce。
Springboot整合Redis时遇到的一些问题
qq_35436635的博客
05-28 3695
Springboot整合Redis其实很简单，只要在项目中添加redis的starter依赖就可以了。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 但在整合过程中，出现了一些莫名其妙的问题。 可能是由于..
springboot框架(3):整合redis
不积跬步，无以至千里
03-30 2236
前言 redis常用于缓存等场景。 操作步骤 新建springboot项目 方法一：创建是选择插件 选择插件NoSQL>Spring Data Redis 方法二：直接引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactI
SpringBoot3.0 集成 Redis2.6
long13102053862的博客
03-08 1805
SpringBoot3.0 集成 Redis2.6
Springboot3- 整合redis
hooyoungzhang的博客
03-08 316
1、单机版redis 配置(引入依赖略) spring.redis.host = redis服务器ip spring.redis.port = redis服务端口 2、整合redis集群 spring.redis.cluster.nodes = 192.168.1.12:7001, 192.168.1.12:7002,192.168.1.13:7001,192.168.1.13:7002 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值