springBoot springCache redis 配置

1）业务代码中如何使用缓存

1.1）注解配置使用redis缓存 快速启用缓存

    @Override
   @Cacheable(value = RUBIK_APPOINTMENT_NEW_UIFLOW_UI_CONFIG, keyGenerator = "simpleSpringCacheKeyGenerator")
    public TUiFlow getUcUiFlowByprocessDefinition(String processDefinitionid) {
        TUiFlow pcUiFlow = new TUiFlow();
        TUiFlow tucUiFlow = null;
        pcUiFlow.setProcessDefinitionid(processDefinitionid);
        List<TUiFlow> list = getUcUiFlowList(processDefinitionid);
        if (!CollectionUtils.isEmpty(list)) {
            tucUiFlow = list.get(0);
        }
        return tucUiFlow;
    }

1.2）删除修改 新建数据时候 删除缓存

  @Override
    @Transactional(rollbackFor = Exception.class)
    @Caching(evict = {

            @CacheEvict(value = RUBIK_BACKSTAGE_NEW_CACHE_UICONFIG_UI_CONFIG_SERVICE_IMPL, allEntries = true),
            @CacheEvict(value = SPRING_CACHE_RUBIK_UICONFIG_UI_CONFIG_SERVICE_IMPL, allEntries = true),
            @CacheEvict(value = RUBIK_APPOINTMENT_NEW_CACHE_UICONFIG_UI_CONFIG_SERVICE_IMPL, allEntries = true)


    })
    public void batchUpdateConfigDetail(List<TUiConfigDetail> tUiConfigDetails, String
            platformHospitalId, String ucuiflowId, String stepId) {
        if (CollectionUtils.isNotEmpty(tUiConfigDetails)) {
            List<PUiConfigDetail> dbConfigs = uiConfigDetailService.getUcuiconfDetailListFromDB(ucuiflowId, platformHospitalId, stepId);
            List<PUiConfigDetail> addList = new ArrayList<PUiConfigDetail>();
            List<PUiConfigDetail> updateList = new ArrayList<PUiConfigDetail>();
            if (CollectionUtils.isNotEmpty(dbConfigs)) {
                for (TUiConfigDetail tUiConfigDetail : tUiConfigDetails) {
                    boolean exist = false;
                    for (PUiConfigDetail dbConfig : dbConfigs) {
                        if (dbConfig.getUcUiConfigId().equals(tUiConfigDetail.getUcUiConfigId())) {
                            String componentValue = StringUtils.trimToEmpty(tUiConfigDetail.getComponentValue());
                            dbConfig.setComponentValue(componentValue);
                            dbConfig.setComponentDesc(tUiConfigDetail.getComponentDesc());
                            dbConfig.setRequired(tUiConfigDetail.getRequired());
                            dbConfig.setModifiedon(new Date());
                            dbConfig.setModifiedby(UserLoginHandler.getLoginName());
                            updateList.add(dbConfig);
                            exist = true;
                            break;
                        }
                    }
                    if (!exist) {
                        addList.add(createConfigDetail(tUiConfigDetail, ucuiflowId, platformHospitalId, stepId));
                    }
                }
            } else {
                for (TUiConfigDetail tUiConfigDetail : tUiConfigDetails) {
                    addList.add(createConfigDetail(tUiConfigDetail, ucuiflowId, platformHospitalId, stepId));
                }
            }

            if (CollectionUtils.isNotEmpty(addList)) {
                int cnt = uiConfigDetailMapper.batchInsertConfigDetail(addList);
            }

            if (CollectionUtils.isNotEmpty(updateList)) {
                int upcnt = uiConfigDetailMapper.batchUpdateConfigDetail(updateList);
            }

        }

    }

2 springBoot spring-boot-starter-cache 配置

2.1）springBoot 启用缓存 修改pom.xml springBoot Main启动

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

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

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

2.2）配置redis 缓存时间及值方式

 

    @Primary
    @Bean(name = "redisTemplate")
    public RedisTemplate getRedisTemplate(RedisConnectionFactory redisConnectionFactory) {

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        GenericJackson2JsonRedisSerializer json2java = new GenericJackson2JsonRedisSerializer(objectMapper);
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(json2java);
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(json2java);
        return redisTemplate;
    }



    // 设置缓存过期时间为一天
    // 禁用缓存空值，不缓存null校验
    
    @Bean
    @Primary
    public RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties) {

        CacheProperties.Redis redisProperties = cacheProperties.getRedis();
        org.springframework.data.redis.cache.RedisCacheConfiguration config = org.springframework.data.redis.cache.RedisCacheConfiguration
                .defaultCacheConfig();
//        //指定缓存序列化方式为json
//        Jackson2JsonRedisSerializer<Object> 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);
//
//        config = config.serializeValuesWith(
//                RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer(om)));
        //下面的这四个配置，如果我们不写在这里的话，将读取不到。默认的配置也会有的，但是我们自己写配置类的话，就需要加上去，
        //设置配置文件中的各项配置，如过期时间
        if (redisProperties.getTimeToLive() != null) {
            config = config.entryTtl(redisProperties.getTimeToLive());
        }

        //key的前缀
        if (redisProperties.getKeyPrefix() != null) {
            config = config.prefixKeysWith(redisProperties.getKeyPrefix());
        }

        //是否缓存空值
        if (!redisProperties.isCacheNullValues()) {
            config = config.disableCachingNullValues();
        }

        //是否使用key的前缀
        if (!redisProperties.isUseKeyPrefix()) {
            config = config.disableKeyPrefix();
        }

        return config;
    }
 

2.3）自定义key 生成方式

import cn.ucmed.common.constants.model.DefaultDBValue;
import com.alibaba.fastjson.JSON;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.cache.interceptor.SimpleKey;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 *
 */
@Configuration
@Component("simpleSpringCacheKeyGenerator")
@Primary
public class SimpleSpringCacheKeyGenerator implements KeyGenerator {
    public SimpleSpringCacheKeyGenerator() {
    }

    @Override
    public Object generate(Object target, Method method, Object... params) {

        return generateKey(target, method, params);
    }

    public static Object generateKey(Object target, Method method, Object... params) {

        StringBuilder strb = new StringBuilder();
        if (method != null && method.getDeclaringClass() != null) {
            strb.append(method.getDeclaringClass().getName()).append(DefaultDBValue.COLON).append(method.getName());
        }
        strb.append(DefaultDBValue.COLON).append(generateParamKey(params));
        return strb.toString();
    }


    public static Object generateParamKey(Object... params) {
        if (params.length == 0) {
            return SimpleKey.EMPTY;
        } else {
            if (params.length == 1) {
                Object param = params[0];
                if (param != null && !param.getClass().isArray()) {
                    return param;
                }
            }
            StringBuilder sb = new StringBuilder();
            for (Object obj : params) {
                if (obj != null) {
                    sb.append(obj.getClass().getName());
                    sb.append("[");
                    sb.append(JSON.toJSONString(obj));
                    sb.append("]:");
                }
            }

            return sb.toString();
        }
    }
}

2.4) 自定义配置缓存生成时间 及缓存Key前缀

# 使用 Redis 作为缓存组件
spring.cache.type=redis
# 缓存过期时间为 3600s
spring.cache.redis.time-to-live=3600000
# 缓存的键的名字前缀
spring.cache.redis.key-prefix=passjava:
# 是否使用缓存前缀
spring.cache.redis.use-key-prefix=true
# 是否缓存控制，防止缓存穿透
spring.cache.redis.cache-null-values=true

############# redis##############
spring.redis.database=6
spring.redis.host=192.168.0.251
spring.redis.password=XZg1bronaALyjIZ
spring.redis.port=6688
spring.redis.jedis.pool.max-active=100
spring.redis.jedis.pool.max-idle=10
spring.redis.jedis.pool.max-total=100
spring.redis.jedis.pool.max-wait-millis=15000
spring.redis.jedis.pool.min-idle=0
spring.redis.jedis.pool.test-on-borrow=true
spring.redis.jedis.timeout=6000