SpringBoot中使用Redis

准备

1、创建SpringBoot项目

2、pom文件中需要有Redis依赖

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

3、yml中配置Redis

单机Redis配置：

#Redis 配置
spring:
  redis:
    host: 192.168.81.130
    password: 123456
    port: 6379
    jedis:
      pool:
        max-active: 20
        max-idle: 8
        min-idle: 0
        max-wait: 2000 #最大等待时间2s

Redis集群配置：

#Redis 配置
spring:
  redis:
    jedis:
      pool:
        max-active: 20
        max-idle: 8
        min-idle: 0
        max-wait: 2000 #最大等待时间2s
    cluster: #配置集群
      nodes: 192.160.81.130:7001,192.160.81.130:7002,192.160.81.130:7003,192.160.81.130:7004,192.160.81.130:7005,192.160.81.130:7006
 

Redis自动配置类说明

SpringBoot中所有的自动配置都在starter中的xxxAutoConfiguration类中，每个我们能在yaml中配置的内容都在xxxProperties类中有说明。

我们查看Redis的配置类：RedisProperties。它提供了一系列Redis所需的配置。

package org.springframework.boot.autoconfigure.data.redis;
@ConfigurationProperties(
    prefix = "spring.redis"
)
public class RedisProperties {
    private int database = 0;
    private String url;
    private String host = "localhost";
    private String password;
    private int port = 6379;
    private boolean ssl;
    private Duration timeout;
    private String clientName;
    private RedisProperties.Sentinel sentinel;
    private RedisProperties.Cluster cluster;
    private final RedisProperties.Jedis jedis = new RedisProperties.Jedis();
    private final RedisProperties.Lettuce lettuce = new RedisProperties.Lettuce();
    //...
}

SpringBoot中Redis为我们的自动配置都在RedisAutoConfiguration类中，它通过RedisTemplate，即Redis的模板进行自动装配。StringRedisTemplate继承自RedisTemplate，它只是将RedisTemplate的泛型<Object, Object>改为了<String,String>，我们只能在StringRedisTemplate存储String类型。

package org.springframework.boot.autoconfigure.data.redis;

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    public RedisAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    )
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

使用

测试配置

@SpringBootTest
class BootRedis02ApplicationTests {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    //keys *
    void contextLoads() {
        Set<String> keys = stringRedisTemplate.keys("*");
        for (String key : keys) {
            System.out.println(key);
        }
    }
}

StringRedisTemplate操作Redis

@SpringBootTest
class ApplicationTests {
    @Autowired
    private StringRedisTemplate redisTemplate;

    @Test
    //刷新Redis
    void flushdb(){
        redisTemplate.execute(new RedisCallback<String>() {
            @Override
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                connection.flushAll();
                connection.flushDb();
                return "ok";
            }
        });
    }
	
    @Test
    void testNormal(){
        redisTemplate.keys("*");//获取所有key
        redisTemplate.multi();//开启事务
        redisTemplate.exec();//提交事务
        redisTemplate.watch("");//监听
        redisTemplate.unwatch();//取消监听
        redisTemplate.delete("k1");//删除k1
        Collection<String> keys=null;
        redisTemplate.delete(keys);//删除多个key
        redisTemplate.randomKey();//随机一个key
        redisTemplate.rename("oldKey","newKey");//重命名key
        redisTemplate.discard();//放弃事务

        //redisTemplate提供的序列化
        redisTemplate.getStringSerializer(); //指redis key序列化方式
        redisTemplate.getValueSerializer();  //指值的序列化方式
        redisTemplate.getHashKeySerializer();//指hash中Value的key序列化方式 
        redisTemplate.getHashValueSerializer();//指hash  Value的 value序列化方式
    }

    @Test
    void testString(){
        ValueOperations<String, String> opsForValue = redisTemplate.opsForValue();
        //System.out.println(redisTemplate.getKeySerializer());
        //System.out.println(redisTemplate.getValueSerializer());

        //其它方法集
        RedisOperations<String, String> operations = opsForValue.getOperations();
//        opsForValue.get("");
//        opsForValue.set("","");
//        opsForValue.setIfPresent("","");
//        opsForValue.increment("");
//        opsForValue.decrement("");
//        opsForValue.set("name","xiaoming");
        System.out.println(opsForValue.get("name"));
    }

    @Test
    void testList(){
        ListOperations<String, String> opsForList = this.redisTemplate.opsForList();
        RedisOperations<String, String> operations = opsForList.getOperations();
        opsForList.leftPush("","");
        opsForList.leftPushAll("","","","");
        opsForList.rightPush("","");
        opsForList.rightPushAll("","");
        opsForList.leftPop("");
        opsForList.rightPop("");
        List<String> key = opsForList.range("key", 0, -1);
    }

    @Test
    void testHash(){
        HashOperations<String, Object, Object> opsForHash = this.redisTemplate.opsForHash();
        opsForHash.put("","hashKey","value");
        opsForHash.get("","hashKey");
    }

    @Test
    void testSet(){
        SetOperations<String, String> opsForSet = this.redisTemplate.opsForSet();
        opsForSet.add("","");
        opsForSet.members("");
    }

    @Test
    void testZset(){
        ZSetOperations<String, String> opsForZSet = this.redisTemplate.opsForZSet();
        opsForZSet.add("key","value",1);
    }

    //集群操作
    @Test
    void test(){
        ClusterOperations<String, String> clusterOperations = this.redisTemplate.opsForCluster();
        //关闭集群的7001端口的主机
        opsForCluster.shutdown(new RedisClusterNode("192.168.81.130", 7001));
    }
}

RedisTemplate操作Redis

@SpringBootTest
class ApplicationRedisTemplateTests {
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        System.out.println(redisTemplate);
        System.out.println(redisTemplate.getKeySerializer());
        System.out.println(redisTemplate.getValueSerializer());
    }
    @Test
    void testString(){
        //这是设置key的序列化方式,因为RedisTemplate<Object,Object> 如果传String key会被当做object进行序列化
        this.redisTemplate.setKeySerializer(new StringRedisSerializer());
        ValueOperations opsForValue = redisTemplate.opsForValue();
        //opsForValue.set("user:1".toString(),new User(1,"xiaoming","wh",new Date()));
        User user = (User) opsForValue.get("user:1");
        System.out.println(user);      
    }
    
    @Test
    void testString2(){
        this.redisTemplate.setKeySerializer(new StringRedisSerializer());
        this.redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        ValueOperations opsForValue = redisTemplate.opsForValue();
        //opsForValue.set("user:2".toString(),new User(1,"xiaoming","wh",new Date()));
        // 若该对象的强转转换，则redis 内部会使用JackSon的工具将字符串->java 对象 ，那jackson 转换为对象时，需要一个对象的类型 ，其实它已经自动获取对象的类型了
        User user = (User) opsForValue.get("user:2");
        System.out.println(user);       
    }
}

Redis中的序列化

Redis的序列化规则在package org.springframework.data.redis.serializer包下的RedisSerializer接口中。

public interface RedisSerializer<T> {}

若不设置序列化规则，它将使用JDK自动的序列化将对象转换为字节，存到Redis 里面。它可以存在对象到redis里面，如果对象没有序列化，那么默认使用的JDK的序列化方式。