springboot2.0整合Jedis

• 单机版

  <!-- Spring Boot Redis依赖 -->
  <!-- 注意：1.5版本的依赖和2.0的依赖不一样-->
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
      <!-- 1.5的版本默认采用的连接池技术是jedis  2.0以上版本默认连接池是lettuce, 在这里采用jedis，所以需要排除lettuce的jar -->
      <exclusions>
          <exclusion>
              <groupId>redis.clients</groupId>
              <artifactId>jedis</artifactId>
          </exclusion>
          <exclusion>
              <groupId>io.lettuce</groupId>
              <artifactId>lettuce-core</artifactId>
          </exclusion>
      </exclusions>
  </dependency>
  <!-- 添加jedis客户端 -->
  <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
  </dependency>
  
  <!-- 将作为Redis对象序列化器 -->
  <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.47</version>
  </dependency>
  

  server:
    port: 8080
  spring:
    redis:
      host: 172.30.66.104
      port: 6379
      # 密码 没有则可以不填
      password: 19e.com.cn
      # 如果使用的jedis 则将lettuce改成jedis即可
      database: 0
      jedis:
        pool:
          # 最大活跃链接数 默认8
          max-active: 5
          # 最大空闲连接数 默认8
          max-idle: 10
          # 最小空闲连接数 默认0
          min-idle: 0
  

  # redis
  # Redis数据库索引（默认为0）
  spring.redis.database=0
  # Redis服务器地址
  spring.redis.host=localhost
  # Redis服务器连接端口
  spring.redis.port=6379
  # Redis服务器连接密码（默认为空）
  spring.redis.password=
  # 连接池最大连接数（使用负值表示没有限制）
  spring.redis.jedis.pool.max-active=20
  # 连接池最大阻塞等待时间（使用负值表示没有限制）
  spring.redis.jedis.pool.max-wait=-1
  # 连接池中的最大空闲连接
  spring.redis.jedis.pool.max-idle=10
  # 连接池中的最小空闲连接
  spring.redis.jedis.pool.min-idle=0
  # 连接超时时间（毫秒）
  spring.redis.timeout=1000
  

• RedisConfig

  import com.fasterxml.jackson.annotation.JsonAutoDetect;
  import com.fasterxml.jackson.annotation.PropertyAccessor;
  import com.fasterxml.jackson.databind.ObjectMapper;
  import org.springframework.boot.autoconfigure.AutoConfigureAfter;
  import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
  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配置
   *
   * @AutoConfigureAfter(RedisAutoConfiguration.class) 是让我们这个配置类在内置的配置类之后在配置，
   * 这样就保证我们的配置类生效，并且不会被覆盖配置
   */
  @Configuration
  @AutoConfigureAfter(RedisAutoConfiguration.class)
  public class RedisConfig {
  
      /**
       * 配置自定义redisTemplate
       *
       * @return
       */
      @Bean
      RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
  
          RedisTemplate<String, Object> template = new RedisTemplate<>();
          template.setConnectionFactory(redisConnectionFactory);
  
          //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
          Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
  
          ObjectMapper mapper = new ObjectMapper();
          mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
          mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
          serializer.setObjectMapper(mapper);
  
          template.setValueSerializer(serializer);
          //使用StringRedisSerializer来序列化和反序列化redis的key值
          template.setKeySerializer(new StringRedisSerializer());
          template.setHashKeySerializer(new StringRedisSerializer());
          template.setHashValueSerializer(serializer);
          template.afterPropertiesSet();
          return template;
      }
  }
  

  import com.qwe.common.demo.User;
  import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.boot.test.context.SpringBootTest;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.test.context.junit4.SpringRunner;
  
  @SpringBootTest
  @RunWith(SpringRunner.class)
  public class RedisTest {
      @Autowired
      private RedisTemplate redisTemplate;
  
  
      @Test
      public void redisTest() {
          // redis存储数据
          String key = "name";
          redisTemplate.opsForValue().set(key, "qwe");
          // 获取数据
          String value = (String) redisTemplate.opsForValue().get(key);
          System.out.println("key:" + key + ",value:" + value);
  
          User user = new User("qw",12);
  
          String userKey = "qwe";
          redisTemplate.opsForValue().set(userKey, user);
          User newUser = (User) redisTemplate.opsForValue().get(userKey);
          System.out.println("key:" + userKey + ",value:" + newUser);
  
      }
  }