SpringBoot整合Redis+简单测试

SpringBoot整合Redis并简单的测试

实现步骤

1. 搭建SpringBoot工程

• 导入依赖

<dependencies>
    <!--Redis-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!--hutool工具-->
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.5.7</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2. 配置redis相关属性

spring.redis.host=127.0.0.1
spring.redis.port=6379

3. 新建User对象（可省略）

public class User implements Serializable {
    private Integer age;
    private String name;

    public User() {
    }

    public User(Integer age, String name) {
        this.age = age;
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

4. 编写自定义的RedisTemplate实现序列化

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory)
    throws UnknownHostException {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
       redisTemplate.setConnectionFactory(factory);

       //Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        //指定要序列化的域，field,get和set，以及修饰符范围，ANY是都有，包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String，Integer等会抛出异常
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        //配置具体的序列化方式
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        //key采用String的序列化方式
        redisTemplate.setKeySerializer(stringRedisSerializer);

        //hash的key也采用String的序列化方式
        redisTemplate.setHashKeySerializer(stringRedisSerializer);

        //value序列化采用jackson
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();

        return  redisTemplate;
    }
}

5. 编写测试方法，简单测试

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringBootRedisApplicationTests {

    @Autowired
    RedisTemplate redisTemplate;

    @Test
    public void test1(){
        redisTemplate.opsForValue().set("myKey","heyichen");
        System.out.println(redisTemplate.hasKey("myKey"));
        System.out.println(redisTemplate.opsForValue().get("myKey"));
        redisTemplate.delete("myKey");
        System.out.println(redisTemplate.hasKey("myKey"));
    }

    /**
     * @author rxw
     * @date 2021/5/5
     * 测试向Redis中存入对象和取出对象
     */
    @Test
    public void test2() {
        //新建一个对象
        User user = new User(18,"何以琛");
        //将对象转为Json
        String userJson = JSONUtil.toJsonStr(user);
        //打印对象
        System.out.println(userJson);
        //将对象的Json存到redis
        redisTemplate.opsForValue().set("user",userJson);
        //查看Redis中是否成功存入数据
        System.out.println(redisTemplate.hasKey("user"));

        //从Redis中得到对象强制转化为User对象
        String userJson1 = (String) redisTemplate.opsForValue().get("user");
        //打印对象
        System.out.println(userJson1);
        //Json对象转化为对象实例
        User user1 = JSONUtil.toBean(userJson1, User.class);
        //打印对象
        System.out.println(user1);

        /*
        redisTemplate.opsForValue(); //操作字符串
        redisTemplate.opsForHash(); //操作hash
        redisTemplate.opsForList(); //操作list
        redisTemplate.opsForSet(); //操作set
        redisTemplate.opsForZSet(); //操作有序set
         */
    }

    /**
     * 测试set
     */

    @Test
    public void test3(){
        //新建对象
        User user = new User(19,"何以琛");
        //将对象的Json存到redis
        redisTemplate.opsForSet().add("user_set",user);
        //查看Redis中是否成功存入数据
        System.out.println(redisTemplate.hasKey("user_set"));
        //从Redis中得到对象强制转为User对象
        User userSet = (User) redisTemplate.opsForSet().pop("user_set");
        //打印对象
        System.out.println(userSet);
    }

    /**
     * @Deprecated redis设置过期时间
     */
    @Test
    public void test4(){
        //设置过期时间
        redisTemplate.expire("user", 10, TimeUnit.SECONDS);
        //查看Redis中是否有数据
        System.out.println(redisTemplate.hasKey("user"));
        System.out.println(redisTemplate.opsForValue().get("user"));
    }

    /**
     * @Deprecated 设置旧的键值对的值并返回对应的旧的value
     */
    @Test
    public void test5() {
        redisTemplate.opsForValue().set("key","何以琛");
        System.out.println("存入的数据："+redisTemplate.opsForValue().get("key"));

        Object value = redisTemplate.opsForValue().getAndSet("key", "heyichen");
        System.out.println("修改后返回的数据："+value);
        System.out.println("修改后的数据："+redisTemplate.opsForValue().get("key"));

        redisTemplate.delete("key");
    }
}