1.添加redis存取方法

2.缓存症状库

dbanaly/src/main/java/com/lantone/qc/dbanaly/config/CacheDeleteInit.java

@@ -0,0 +1,35 @@
+package com.lantone.qc.dbanaly.config;
+
+import com.lantone.qc.dbanaly.lt.facade.CacheFacade;
+import com.lantone.qc.dbanaly.lt.facade.ClinicFacade;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.core.annotation.Order;
+import org.springframework.stereotype.Component;
+
+/**
+ * @Description: 项目启动后初始化缓存
+ * @author: HUJING
+ * @time: 2020/5/13 11:20
+ */
+@Component //把类交给spring容器管理
+@Order(100)  //使用order属性，设置该类在spring容器中的加载顺序
+@Slf4j
+public class CacheDeleteInit implements CommandLineRunner {
+
+    @Autowired
+    CacheFacade cacheFacade;
+
+    @Autowired
+    ClinicFacade clinicFacade;
+
+    @Override
+    public void run(String... args) throws Exception {
+        // 服务启动清除redis缓存
+        cacheFacade.clear();
+        clinicFacade.getClinicInfo();
+
+        log.info("病历质控系统缓存启动初始化成功！");
+    }
+}

dbanaly/src/main/java/com/lantone/qc/dbanaly/config/RedisConfig.java

@@ -8,20 +8,190 @@ package com.lantone.qc.dbanaly.config;
 import com.fasterxml.jackson.annotation.JsonAutoDetect;
 import com.fasterxml.jackson.annotation.PropertyAccessor;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.CachingConfigurerSupport;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.cache.interceptor.KeyGenerator;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+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.connection.RedisStandaloneConfiguration;
+import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
+import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
+import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.core.StringRedisTemplate;
+import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
 import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.RedisSerializationContext;
 import org.springframework.data.redis.serializer.StringRedisSerializer;
 
 import java.net.UnknownHostException;
+import java.time.Duration;
 
 
 @Configuration
-public class RedisConfig {
+@EnableCaching
+@Slf4j
+public class RedisConfig extends CachingConfigurerSupport {
+    @Value("${spring.redis.database.cache}")
+    private String databaseCache;
+    @Value("${spring.redis.database.token}")
+    private String databaseMr;
+    @Value("${spring.redis.host}")
+    private String host;
+    @Value("${spring.redis.password}")
+    private String password;
+    @Value("${spring.redis.port}")
+    private int port;
+    @Value("${spring.redis.timeout}")
+    private int timeout;
+    @Value("${spring.redis.lettuce.pool.max-active}")
+    private int maxActive;
+    @Value("${spring.redis.lettuce.pool.max-idle}")
+    private int maxIdle;
+    @Value("${spring.redis.lettuce.pool.max-wait}")
+    private long maxWaitMillis;
+    @Value("${spring.redis.lettuce.pool.min-idle}")
+    private int minIdle;
+
+    @Autowired
+    @Qualifier("factoryForCache")
+    private LettuceConnectionFactory lettuceConnectionFactory;
+
+    @Bean
+    public GenericObjectPoolConfig getRedisConfig() {
+        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
+        poolConfig.setMaxTotal(maxActive);
+        poolConfig.setMaxIdle(maxIdle);
+        poolConfig.setMaxWaitMillis(maxWaitMillis);
+        poolConfig.setMinIdle(minIdle);
+        return poolConfig;
+    }
+
+    @Bean
+    @Override
+    public CacheManager cacheManager() {
+        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
+                // 设置 key为string序列化
+                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
+                // 设置value为json序列化
+                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(getSerializer()))
+                // 不缓存空值
+                .disableCachingNullValues();
+        RedisCacheManager cacheManager = RedisCacheManager.builder(lettuceConnectionFactory)
+                .cacheDefaults(redisCacheConfiguration)
+                .transactionAware()
+                .build();
+        cacheManager.afterPropertiesSet();
+        log.info("RedisCacheManager config success");
+        return cacheManager;
+    }
+
+    @Bean(name = "springSessionDefaultRedisSerializer")
+    public GenericJackson2JsonRedisSerializer getGenericJackson2JsonRedisSerializer() {
+        return new GenericJackson2JsonRedisSerializer();
+    }
+
+    /**
+     * 缓存使用的redis
+     *
+     * @return
+     */
+    @Bean(name = "factoryForCache")
+    @Primary
+    public LettuceConnectionFactory redisConnectionFactory() {
+        return getRedisConnectionFactory(Integer.valueOf(databaseCache));
+    }
+
+    @Bean
+    public RedisTemplate<String, Object> redisTemplate() {
+        return getRedisTemplate(lettuceConnectionFactory);
+    }
+
+    private Jackson2JsonRedisSerializer getSerializer() {
+        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);
+        return jackson2JsonRedisSerializer;
+    }
+
+    @Bean
+    @Override
+    public KeyGenerator keyGenerator() {
+        //  设置自动key的生成规则，配置spring boot的注解，进行方法级别的缓存
+        // 使用：进行分割，可以很多显示出层级关系
+        // 这里其实就是new了一个KeyGenerator对象
+        return (target, method, params) -> {
+            StringBuilder sb = new StringBuilder();
+            sb.append(target.getClass().getName());
+            sb.append(":");
+            sb.append(method.getName());
+            for (Object obj : params) {
+                sb.append(":" + String.valueOf(obj));
+            }
+            String rsToUse = String.valueOf(sb);
+            log.info("自动生成Redis Key -> [{}]", rsToUse);
+            return rsToUse;
+        };
+    }
+
+    /**
+     * Token使用的redis
+     *
+     * @return
+     */
+    @Bean(name = "factoryForToken")
+    public LettuceConnectionFactory redisConnectionFactoryForToken() {
+        return getRedisConnectionFactory(Integer.valueOf(databaseMr));
+    }
+
+    @Bean(name = "redisTemplateForToken")
+    public RedisTemplate<String, Object> redisTemplateForToken(@Qualifier("factoryForToken") LettuceConnectionFactory factory) {
+        return getRedisTemplate(factory);
+    }
+
+
+    private LettuceConnectionFactory getRedisConnectionFactory(Integer database) {
+        RedisStandaloneConfiguration connection = new RedisStandaloneConfiguration();
+        connection.setHostName(host);
+        connection.setPort(port);
+        connection.setPassword(password);
+        connection.setDatabase(database);
+        GenericObjectPoolConfig poolConfig = getRedisConfig();
+        LettuceClientConfiguration builder = LettucePoolingClientConfiguration.builder()
+                .commandTimeout(Duration.ofMillis(timeout))
+                .poolConfig(poolConfig)
+                .shutdownTimeout(Duration.ZERO)
+                .build();
+        LettuceConnectionFactory factory = new LettuceConnectionFactory(connection, builder);
+        return factory;
+    }
+
+    private RedisTemplate<String, Object> getRedisTemplate(LettuceConnectionFactory factory) {
+        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
+        redisTemplate.setConnectionFactory(factory);
+
+        // value值的序列化
+        redisTemplate.setValueSerializer(getSerializer());
+        redisTemplate.setHashValueSerializer(getSerializer());
+        // key的序列化采用StringRedisSerializer
+        redisTemplate.setKeySerializer(new StringRedisSerializer());
+        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
+        redisTemplate.afterPropertiesSet();
+        return redisTemplate;
+    }
 
     @Bean
     @ConditionalOnMissingBean(name = "redisTemplate")

dbanaly/src/main/java/com/lantone/qc/dbanaly/lt/facade/CacheFacade.java

@@ -0,0 +1,23 @@
+package com.lantone.qc.dbanaly.lt.facade;
+
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.stereotype.Component;
+
+/**
+ * @Description :
+ * @Author : HUJING
+ * @Date: 2020/8/13 16:52
+ */
+@Component
+public class CacheFacade {
+
+    /**
+     * 清除缓存信息
+     *
+     * @return
+     */
+    @CacheEvict(value = "cache", allEntries = true)
+    public void clear() {
+
+    }
+}

dbanaly/src/main/java/com/lantone/qc/dbanaly/lt/facade/ClinicFacade.java

@@ -5,6 +5,7 @@ import com.google.common.collect.Maps;
 import com.lantone.qc.dbanaly.lt.entity.Clinic;
 import com.lantone.qc.dbanaly.lt.service.impl.ClinicServiceImpl;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Component;
 
 import java.util.Map;
@@ -17,7 +18,8 @@ import java.util.stream.Collectors;
  */
 @Component
 public class ClinicFacade extends ClinicServiceImpl {
-
+    @Autowired
+    ClinicFacade clinicFacade;
     @Autowired
     private LibraryInfoFacade libraryInfoFacade;
 
@@ -35,8 +37,25 @@ public class ClinicFacade extends ClinicServiceImpl {
         Map<Long, Clinic> clinicMap = getClinicMap();
         conceptIdMap.keySet().forEach(conceptName -> {
             ret.put(conceptName, clinicMap.get(conceptIdMap.get(conceptName)));
+            clinicFacade.clinicCache(conceptName, clinicMap.get(conceptIdMap.get(conceptName)));
         });
         return ret;
     }
 
+    @Cacheable(value = "cache", key = "#clinicName", unless = "#result == null")
+    public Clinic clinicCache(String clinicName, Clinic clinic) {
+        return clinic;
+    }
+
+    @Cacheable(value = "cache", key = "#clinicName", unless = "#result == null")
+    public Clinic clinicCache(String clinicName) {
+        QueryWrapper<Clinic> clinicQe = new QueryWrapper<>();
+        clinicQe.eq("is_deleted", "N");
+        clinicQe.isNotNull("concept_id");
+        clinicQe.eq("name", clinicName);
+        Clinic one = getOne(clinicQe, false);
+        System.out.println(one);
+        return one;
+    }
+
 }

kernel/src/main/java/com/lantone/qc/kernel/catalogue/behospitalized/BEH0016.java

@@ -34,7 +34,7 @@ public class BEH0016 extends QCCatalogue {
             Clinical clinical = clinicals.get(0);
             String clinicalName = clinical.getName();
             if (StringUtil.isNotBlank(clinicalName)) {
-                Clinic clinic = clinicFacade.getClinicInfo().get(clinicalName);
+                Clinic clinic = clinicFacade.clinicCache(clinicalName);
                 if (clinic != null && clinic.getHasProperty() == 1) {
                     Property property = clinical.getProperty();
                     if (property == null) {

kernel/src/main/java/com/lantone/qc/kernel/catalogue/behospitalized/BEH0019.java

@@ -35,7 +35,10 @@ public class BEH0019 extends QCCatalogue {
             Clinical clinical = clinicals.get(0);
             String clinicalName = clinical.getName();
             if (StringUtil.isNotBlank(clinicalName)) {
-                Clinic clinic = clinicFacade.getClinicInfo().get(clinicalName);
+                long start = System.currentTimeMillis();
+                Clinic clinic = clinicFacade.clinicCache(clinicalName);
+                long end = System.currentTimeMillis();
+                System.out.println("取缓存时间：" + (end-start));
                 if (clinic != null && clinic.getHasDegree() == 1) {
                     Degree degree = clinical.getDegree();
                     if (degree == null) {

kernel/src/main/java/com/lantone/qc/kernel/catalogue/behospitalized/BEH0020.java

@@ -35,7 +35,7 @@ public class BEH0020 extends QCCatalogue {
             Clinical clinical = clinicals.get(0);
             String clinicalName = clinical.getName();
             if (StringUtil.isNotBlank(clinicalName)) {
-                Clinic clinic = clinicFacade.getClinicInfo().get(clinicalName);
+                Clinic clinic = clinicFacade.clinicCache(clinicalName);
                 if (clinic != null && clinic.getHasRelieve() == 1) {
                     Modification modification = clinical.getModification();
                     if (modification == null || !modification.getName().contains("缓")) {

kernel/src/main/java/com/lantone/qc/kernel/catalogue/behospitalized/BEH0021.java

@@ -35,7 +35,7 @@ public class BEH0021 extends QCCatalogue {
             Clinical clinical = clinicals.get(0);
             String clinicalName = clinical.getName();
             if (StringUtil.isNotBlank(clinicalName)) {
-                Clinic clinic = clinicFacade.getClinicInfo().get(clinicalName);
+                Clinic clinic = clinicFacade.clinicCache(clinicalName);
                 if (clinic != null && clinic.getHasAggravate() == 1) {
                     Modification modification = clinical.getModification();
                     if (modification == null || (!modification.getName().contains("严重") && !modification.getName().contains("加剧")