0
点赞
收藏
分享

微信扫一扫

SpringBoot2快速入门07--redis

橙子好吃吗 2021-09-24 阅读 67

boot2不仅支持ORM框架,而且还支持redis,我们经常使用redis作缓存,之前java使用jedis连接redis服务,现在使用Lettuce作为连接客户端,它使用Netty的连接实例,可以在多个线程间并发访问。

导入依赖,如下:

    compile('org.springframework.boot:spring-boot-starter')
    compile('org.springframework.boot:spring-boot-starter-web')
    compile('org.springframework.boot:spring-boot-starter-data-redis')
    compile('org.apache.commons:commons-pool2')

commons依赖主要应用于单机版

redis配置,如下:

  • redis单机版
  redis:
    host: 127.0.0.1
    #password:
    timeout: 1000
    database: 0  #默认有16个db(集群模式用hash槽代替),这里配置具体使用的db,默认是0
    lettuce:
      pool:
        max-active: 8 #最大连接数(使用负值表示没有限制) 默认 8
        max-wait: -1 #最大阻塞等待时间(使用负值表示没有限制) 默认 -1
        max-idle: 8  #最大空闲连接 默认 8
        min-idle: 0

可以配置需要获取的数据库,账号、密码,连接池等等。

  • redis集群版
redis:
    timeout: 6000ms
    database: 0
    cluster:
      nodes:
        - 192.168.40.156:7001
        - 192.168.40.156:7002
        - 192.168.40.157:7003
        - 192.168.40.157:7004
        - 192.168.40.158:7005
        - 192.168.40.158:7006
      max-redirects: 3 # 获取失败 最大重定向次数
    lettuce:
      pool:
        max-active: 1000  #连接池最大连接数(使用负值表示没有限制)
        max-idle: 10 # 连接池中的最大空闲连接
        min-idle: 5 # 连接池中的最小空闲连接
        max-wait: -1 # 连接池最大阻塞等待时间(使用负值表示没有限制)

添加RedisConfig 添加序列化方式以及缓存配置

@Configuration
@EnableCaching // 开启缓存支持
public class RedisConfig extends CachingConfigurerSupport {

    @Resource
    private LettuceConnectionFactory lettuceConnectionFactory;

    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuffer sb = new StringBuffer();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }

    // 缓存管理器
    @Bean
    public CacheManager cacheManager() {
        RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager.RedisCacheManagerBuilder
                .fromConnectionFactory(lettuceConnectionFactory);
        @SuppressWarnings("serial")
        Set<String> cacheNames = new HashSet<String>() {
            {
                add("codeNameCache");
            }
        };
        builder.initialCacheNames(cacheNames);
        return builder.build();
    }

    /**
     * RedisTemplate配置
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
         // 设置序列化
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, Visibility.ANY);
        om.enableDefaultTyping(DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        RedisSerializer<?> stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer);// key序列化
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);// value序列化
        redisTemplate.setHashKeySerializer(stringSerializer);// Hash key序列化
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);// Hash value序列化
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

注:序列化带泛型的数据时,会以map的结构进行存储,反序列化是不能将map解析成对象。
解决方案:序列化存储时,转成JSON字符串

自定义Template
默认情况下,RedisTemplate只支持字符串,在开发中常需要存入对象,我们可以自定义一个模板,如下:

@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisCacheAutoConfiguration {
    @Bean
    public RedisTemplate<String, Serializable> redisCacheTemplate(LettuceConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Serializable> template = new RedisTemplate<>();
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

注:使用GenericJackson2JsonRedisSerializer序列化时,会保存序列化的对象的包名和类名,反序列化时以这个作为标示就可以反序列化成指定的对象。

测试上面的template

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class ApplicationTests {
    private static final Logger log = LoggerFactory.getLogger(ApplicationTests.class);
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Autowired
    private RedisTemplate<String, Serializable> redisCacheTemplate;

    @Test
    public void get() {
                //存入字符串
        stringRedisTemplate.opsForValue().set("key1", "value1");
        final String k1 = stringRedisTemplate.opsForValue().get("key1");
        log.info("字符缓存结果 - {}", k1);
        String key = "user:1";
        User user1 = new User();
        user1.setAge(22);
        user1.setName("test");
                //存入对象
        redisCacheTemplate.opsForValue().set(key, user1);
        final User user = (User) redisCacheTemplate.opsForValue().get(key);
        log.info("对象缓存结果 - {}", user);
    }
}

关于redis的操作方式,还有其它几种:

  • opsForValue: 对应 String(字符串)
  • opsForZSet: 对应 ZSet(有序集合)
  • opsForHash: 对应 Hash(哈希)
  • opsForList: 对应 List(列表)
  • opsForSet: 对应 Set(集合)
举报

相关推荐

0 条评论