测试java连接redis的小demo

java连接redis

1. 导入依赖

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

2. 配置yaml

   spring:
     redis:
       database: 0
       host: 你要连的ip
       port: 你的redis端口
       timeout: 10000
       pool:
         # 最大可用连接数（默认为8，负数表示无限）
         max-active: 100
         # 最大空闲连接数（默认为8，负数表示无限）
         max-idle: 10
         # 最小空闲连接数（默认为0）
         min-idle: 5
         # 从连接池中获取连接最大等待时间（默认-1，单位为毫秒，负数表示无限）
         max-wait: -1
   

3. 创建配置类 config/RedisConfig

   package com.redis.config;
   
   import com.fasterxml.jackson.annotation.JsonAutoDetect;
   import com.fasterxml.jackson.annotation.PropertyAccessor;
   import com.fasterxml.jackson.databind.ObjectMapper;
   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.Jackson2JsonRedisSerializer;
   import org.springframework.data.redis.serializer.StringRedisSerializer;
   
   /**
    * redis配置序列化
    */
   @Configuration
   public class RedisConfig {
   
       @Bean
       public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
           RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
           redisTemplate.setConnectionFactory(redisConnectionFactory);
   
           // 使用Jackson2JsonRedisSerialize 替换默认序列化
           Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
   
           ObjectMapper objectMapper = new ObjectMapper();
           objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
           objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
   
           jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
   
           // 设置value的序列化规则和 key的序列化规则
           redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
           redisTemplate.setKeySerializer(new StringRedisSerializer());
   
           redisTemplate.setHashKeySerializer(jackson2JsonRedisSerializer);
           redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
   
           redisTemplate.setDefaultSerializer(jackson2JsonRedisSerializer);
           redisTemplate.setEnableDefaultSerializer(true);
           redisTemplate.afterPropertiesSet();
           return redisTemplate;
       }
   }
   

4. 创建user实体类

   package com.redis.pojo;
   
   import org.springframework.stereotype.Component;
   
   import java.io.Serializable;
   
   @Component
   
   public class User implements Serializable {
       private String name;
       private Integer age;
   
       @Override
       public String toString() {
           return "User{" +
                   "name='" + name + '\'' +
                   ", age=" + age +
                   '}';
       }
   
       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;
       }
   
       public User() {
       }
   
       public User(String name, Integer age) {
           this.name = name;
           this.age = age;
       }
   }
   

5. 测试连接，在test类中引入RedisTemplate

   package com.redis;
   
   import com.fasterxml.jackson.core.JsonProcessingException;
   import com.fasterxml.jackson.databind.ObjectMapper;
   import com.redis.pojo.User;
   import org.junit.jupiter.api.Test;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.test.context.SpringBootTest;
   import org.springframework.data.redis.connection.RedisConnection;
   import org.springframework.data.redis.core.RedisTemplate;
   
   @SpringBootTest
   class DemoApplicationTests {
   
       @Autowired
       private RedisTemplate redisTemplate;
   
       @Test
       void contextLoads() {
           RedisConnection connection = 		         redisTemplate.getConnectionFactory().getConnection();
           connection.flushDb();
           System.out.println(connection);
       }
   
       @Test
       public void test() throws JsonProcessingException {
           User user = new User("美阳", 3);
           String s = new ObjectMapper().writeValueAsString(user);
           redisTemplate.opsForValue().set("user", user);
           System.out.println(redisTemplate.opsForValue().get("user"));
       }
   }
   
   

• 输出结果

  User{name='美阳', age=3}