springboot2.0整合redis作为缓存以json格式存储对象

步骤1

         <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-redis</artifactId>

        </dependency>

        <dependency>

            <groupId>org.apache.commons</groupId>

            <artifactId>commons-pool2</artifactId>

            <version>2.5.0</version>

        </dependency> 

步骤2

  redis:

    host: 127.0.0.1

    jedis:

      pool:

        max-active: 8

        max-idle: 8

        max-wait: -1ms

        min-idle: 0

    lettuce:

      pool:

        max-active: 8

        max-idle: 8

        max-wait: -1ms

        min-idle: 0

      shutdown-timeout: 100ms

步骤3

package com.example.demo.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;

import com.fasterxml.jackson.annotation.PropertyAccessor;

import com.fasterxml.jackson.databind.ObjectMapper;

import org.springframework.cache.CacheManager;

import org.springframework.cache.annotation.CachingConfigurerSupport;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.redis.cache.RedisCacheConfiguration;

import org.springframework.data.redis.cache.RedisCacheManager;

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.RedisSerializationContext;

import org.springframework.data.redis.serializer.RedisSerializer;

import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

/**

 * @author: Administrator

 * @date: 2019/12/12 0012

 */

@Configuration

public class RedisConfig extends CachingConfigurerSupport {

    @Bean

    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();

        RedisSerializer<String> redisSerializer = new StringRedisSerializer();

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper om = new ObjectMapper();

        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        jackson2JsonRedisSerializer.setObjectMapper(om);

        template.setConnectionFactory(factory);

        //key序列化方式

        template.setKeySerializer(redisSerializer);

        //value序列化

        template.setValueSerializer(jackson2JsonRedisSerializer);

        //value hashmap序列化

        template.setHashValueSerializer(jackson2JsonRedisSerializer);

        return template;

    }

    @Bean

    public CacheManager cacheManager(RedisConnectionFactory factory) {

        RedisSerializer<String> redisSerializer = new StringRedisSerializer();

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        //解决查询缓存转换异常的问题

        ObjectMapper om = new ObjectMapper();

        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        jackson2JsonRedisSerializer.setObjectMapper(om);

        // 配置序列化（解决乱码的问题）,过期时间30秒

        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()

                .entryTtl(Duration.ofSeconds(30))

                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))

                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))

                .disableCachingNullValues();

        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)

                .cacheDefaults(config)

                .build();

        return cacheManager;

    }

}

步骤4

package com.example.demo.service;

import com.example.demo.bean.Employee;

import com.example.demo.mapper.EmployeeMapeer;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.cache.annotation.CachePut;

import org.springframework.cache.annotation.Cacheable;

import org.springframework.stereotype.Service;

/**

 * @author: Administrator

 * @date: 2019/12/11 0011

 */

@Service

public class EmployeeService {

    @Autowired

    EmployeeMapeer employeeMapeer;

    /**

     * 将方法的运行结果进行缓存，以后再要相同的数据，我们就从缓存中获取，不用调用方法了

     *

     * @param id

     * @return

     */

//    @Cacheable(cacheNames = {"emp"}, key = "#root.methodName+'['+#id+']'")

    @Cacheable(value = "emp")

    public Employee findById(Integer id) {

//        System.out.println("查询" + id + "员工信息");

        return employeeMapeer.selectById(id);

    }

    @CachePut(value = "emp")

    public Employee update(Employee employee) {

        System.out.println("updateEmp" + employee);

        employeeMapeer.update(employee);

        return employee;

    }

}