Release 1.2.4

ci-aliyun
2 parents 4162469d a476e3ab
Showing 17 changed files with 772 additions and 14 deletions
.gitignore
README.md
pom.xml
src/main/java/com/irrigation/icl/cache/Command.java
src/main/java/com/irrigation/icl/cache/LayeringCacheAutoFactory.java
src/main/java/com/irrigation/icl/cache/LayeringCacheSyncCommandHandler.java
src/main/java/com/irrigation/icl/cache/config/CacheConfig.java
src/main/java/com/irrigation/icl/cache/core/CustomCacheKeyGenerator.java
src/main/java/com/irrigation/icl/cache/core/LayeringCache.java
src/main/java/com/irrigation/icl/cache/core/LayeringCacheLoadCondition.java
src/main/java/com/irrigation/icl/cache/core/LayeringCacheManager.java
src/main/java/com/irrigation/icl/cache/core/LayeringCacheProperties.java
src/main/java/com/irrigation/icl/entity/PageList.java
src/main/java/com/irrigation/icl/entity/PageParam.java
src/main/java/com/irrigation/icl/entity/RestResult.java
src/main/java/com/irrigation/icl/enums/ResultEnum.java
src/main/java/com/irrigation/icl/utils/RestResultGeneratorUtil.java
@@ -4,3 +4,5 @@
 target/
  
 \.DS_Store
+
+*.iml
-sass-common-lib:公共项目库
+## sass-common-lib:公共项目库
+
+### v 1.2.0版本更新记录
+- 利用redis和ehcache增加了缓存支持，redis为L2级缓存，ehcache为L1级cache；
+> application.yml基本配置如下:
+```json
+#开启ehcache和redis两级缓存
+springext:
+  cache:
+    enable: true
+    cacheL1:
+      enable: true
+      topic: cache  #同步L1缓存的topic
+      key: "keys"
+```
+```json
+#redis配置
+spring:
+  redis:
+    database: 10
+    host: 192.168.2.252
+    port: 6379
+#    password: zhnf@123
+    pool:
+      max-wait: 1
+```
+
+### v1.2.1 
+- 增加了KeyGenerator实现类，实现类中使用className.methodName:params拼接成key
+
+### v1.2.2
+- 增加了对@CacheEvict(allEntries = true)的支持
 \ No newline at end of file
@@ -6,19 +6,22 @@
  
     <groupId>com.irrigation</groupId>
     <artifactId>common-lib</artifactId>
-    <version>1.0-SNAPSHOT</version>
+    <version>1.2.4</version>
  
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <java.version>1.8</java.version>
+        <spring-boot.version>1.5.10.RELEASE</spring-boot.version>
         <swagger.version>2.7.0</swagger.version>
         <lombok.version>1.16.20</lombok.version>
         <commons-codec.version>1.11</commons-codec.version>
         <guava.vsersion>20.0</guava.vsersion>
         <slf4j.version>1.7.24</slf4j.version>
-        <fastjson.version>1.2.46</fastjson.version>
+        <fastjson.version>1.2.49</fastjson.version>
         <spring-web.version>4.3.14.RELEASE</spring-web.version>
         <spring-security-core.version>4.2.4.RELEASE</spring-security-core.version>
+        <ehcache.version>2.6.11</ehcache.version>
+
     </properties>
  
  
@@ -83,6 +86,36 @@
             <version>${spring-security-core.version}</version>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>net.sf.ehcache</groupId>
+            <artifactId>ehcache-core</artifactId>
+            <version>${ehcache.version}</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.slf4j</groupId>
+                    <artifactId>slf4j-api</artifactId>
+                </exclusion>
+            </exclusions>
+            <!--<scope>provided</scope>-->
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-cache</artifactId>
+            <version>${spring-boot.version}</version>
+            <!--<scope>provided</scope>-->
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+            <version>${spring-boot.version}</version>
+            <!--<scope>provided</scope>-->
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-configuration-processor</artifactId>
+            <version>${spring-boot.version}</version>
+            <!--<scope>provided</scope>-->
+        </dependency>
  
     </dependencies>
     <build>
+package com.irrigation.icl.cache;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+/**
+ * Command
+ */
+@Data
+public class Command implements Serializable {
+
+    private static final long serialVersionUID = 7126530485423286910L;
+
+    // 设置本地缓存
+    public final static byte OPT_SET = 0x01;
+    // 删除本地缓存Key
+    public final static byte OPT_DEL = 0x02;
+    // 删除本地缓存
+    public final static byte OPT_REM = 0x03;
+
+    public byte oper;
+    public String name;
+    public String key;
+    public String src;
+
+    public Command() {
+    }
+
+    public Command(String src, byte oper, String name, String key) {
+        this.src = src;
+        this.oper = oper;
+        this.name = name;
+        this.key = key;
+    }
+
+    /**
+     * 更新本地缓存
+     *
+     * @param cacheName
+     * @param key
+     * @return
+     */
+    public static Command set(String src, String cacheName, String key) {
+        return new Command(src, OPT_SET, cacheName, key);
+    }
+
+    /**
+     * 删除本地缓存Key
+     *
+     * @param cacheName
+     * @param key
+     * @return
+     */
+    public static Command del(String src, String cacheName, String key) {
+        return new Command(src, OPT_DEL, cacheName, key);
+    }
+
+    /**
+     * 删除本地缓存
+     *
+     * @param cacheName
+     * @return
+     */
+    public static Command rem(String src, String cacheName) {
+        return new Command(src, OPT_REM, cacheName, null);
+    }
+}
 \ No newline at end of file
+package com.irrigation.icl.cache;
+
+import com.irrigation.icl.cache.core.LayeringCacheLoadCondition;
+import com.irrigation.icl.cache.core.LayeringCacheManager;
+import com.irrigation.icl.cache.core.LayeringCacheProperties;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.cache.CacheManager;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Conditional;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.Message;
+import org.springframework.data.redis.connection.MessageListener;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.listener.PatternTopic;
+import org.springframework.data.redis.listener.RedisMessageListenerContainer;
+import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
+
+/**
+ * @Author: boni
+ * @Date: 2018/8/24-下午2:37
+ */
+@Configuration
+@Conditional(LayeringCacheLoadCondition.class)
+@EnableConfigurationProperties(LayeringCacheProperties.class)
+@Slf4j
+public class LayeringCacheAutoFactory {
+    @Bean
+    public LayeringCacheManager cacheManager(RedisTemplate<Object, Object> redisTemplate,
+                                             LayeringCacheProperties layeringCacheProperties) {
+        LayeringCacheManager cacheManager = new LayeringCacheManager(redisTemplate, layeringCacheProperties);
+        cacheManager.setUsePrefix(true);
+        long expire = layeringCacheProperties.getExpire() > 0L ? layeringCacheProperties.getExpire() : 120L;
+        cacheManager.setExpires(layeringCacheProperties.getExpires());
+        cacheManager.setDefaultExpiration(expire);
+        return cacheManager;
+    }
+
+    @Bean
+    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
+                                            LayeringCacheProperties layeringCacheProperties,
+                                            MessageListenerAdapter listenerAdapter) {
+        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
+        container.setConnectionFactory(connectionFactory);
+        container.addMessageListener(listenerAdapter, new PatternTopic(layeringCacheProperties.getCacheL1().getTopic()));
+
+        return container;
+    }
+
+    @Bean
+    LayeringCacheSyncCommandHandler layeringCacheSyncCommandHandler(CacheManager cacheManager) {
+        LayeringCacheSyncCommandHandler handler = new LayeringCacheSyncCommandHandler(cacheManager);
+        return handler;
+    }
+
+    @Bean
+    MessageListenerAdapter listenerAdapter(LayeringCacheSyncCommandHandler handler,
+                                           RedisTemplate<Object, Object> redisTemplate) {
+
+        return new MessageListenerAdapter(new MessageListener() {
+            @Override
+            public void onMessage(Message message, byte[] pattern) {
+                byte[] content = message.getBody();
+                if (content != null) {
+//                    String commandString = new String(content, Charset.defaultCharset());
+//                    Command command = JSON.parseObject(commandString, Command.class);
+                    Command command = (Command) redisTemplate.getValueSerializer().deserialize(content);
+                    if (command != null) {
+                        log.debug(command.toString());
+                        handler.handle(command);
+                    }
+                }
+            }
+
+        });
+    }
+}
 \ No newline at end of file
+package com.irrigation.icl.cache;
+
+import com.irrigation.icl.cache.core.LayeringCache;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.cache.CacheManager;
+
+/**
+ * @Author: boni
+ * @Date: 2018/8/29-下午5:44
+ */
+@Slf4j
+@Getter
+public class LayeringCacheSyncCommandHandler {
+    CacheManager cacheManager;
+
+    public LayeringCacheSyncCommandHandler(CacheManager cacheManager) {
+        this.cacheManager = cacheManager;
+    }
+
+    public void handle(Command command) {
+        if (cacheManager != null) {
+            LayeringCache layeringCache = (LayeringCache) cacheManager.getCache(command.getName());
+            if (layeringCache == null) {
+                return;
+            }
+            layeringCache.updateL1Cache(command);
+        }
+    }
+}
+package com.irrigation.icl.cache.config;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+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.JdkSerializationRedisSerializer;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+/**
+ * @Author: boni
+ * @Date: 2018/8/24-下午2:03
+ */
+@Configuration
+public class CacheConfig {
+
+    @ConditionalOnMissingBean(RedisTemplate.class)
+    @Bean
+    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
+        RedisTemplate<Object, Object> template = new RedisTemplate<>();
+        template.setConnectionFactory(connectionFactory);
+//        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
+//        ObjectMapper om = new ObjectMapper();
+//        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
+//        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
+//        jackson2JsonRedisSerializer.setObjectMapper(om);
+//
+        template.setValueSerializer(new JdkSerializationRedisSerializer());
+        //使用StringRedisSerializer来序列化和反序列化redis的key值
+        template.setKeySerializer(new StringRedisSerializer());
+        template.afterPropertiesSet();
+        return template;
+    }
+
+}
+package com.irrigation.icl.cache.core;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.cache.interceptor.KeyGenerator;
+import org.springframework.util.StringUtils;
+
+import java.lang.reflect.Method;
+
+/**
+ * @Author: boni
+ * @Date: 2018/9/4-下午3:20
+ */
+@Slf4j
+public class CustomCacheKeyGenerator implements KeyGenerator {
+    public static final int NO_PARAM_KEY = 0;
+
+    @Override
+    public Object generate(Object target, Method method, Object... params) {
+        StringBuilder key = new StringBuilder();
+        key.append(target.getClass().getSimpleName()).append(".").append(method.getName()).append(":");
+        if (params.length == 0) {
+            return key.append(NO_PARAM_KEY).toString();
+        }
+        key.append(StringUtils.arrayToCommaDelimitedString(params));
+        //String finalKey = key.toString();
+        //log.debug("using cache key={}", finalKey);
+        return key.toString();
+    }
+}
+package com.irrigation.icl.cache.core;
+
+import com.irrigation.icl.cache.Command;
+import lombok.extern.slf4j.Slf4j;
+import net.sf.ehcache.CacheException;
+import net.sf.ehcache.CacheManager;
+import net.sf.ehcache.Ehcache;
+import net.sf.ehcache.Element;
+import net.sf.ehcache.config.CacheConfiguration;
+import net.sf.ehcache.config.Configuration;
+import net.sf.ehcache.config.DiskStoreConfiguration;
+import net.sf.ehcache.config.PersistenceConfiguration;
+import net.sf.ehcache.store.MemoryStoreEvictionPolicy;
+import org.springframework.cache.Cache;
+import org.springframework.cache.support.SimpleValueWrapper;
+import org.springframework.data.redis.cache.RedisCache;
+import org.springframework.data.redis.core.RedisOperations;
+import org.springframework.util.StopWatch;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Future;
+import java.util.concurrent.FutureTask;
+
+/**
+ * @Author: boni
+ * @Date: 2018/8/24-下午2:27
+ */
+@Slf4j
+public class LayeringCache extends RedisCache {
+    private final ConcurrentHashMap<String, Future<Ehcache>> layeringL1CacheContainer = new ConcurrentHashMap<>();
+    private LayeringCacheProperties layeringCacheProperties;
+    private LayeringCacheManager layeringCacheManager;
+    private CacheManager layeringL1CacheManager;
+    private boolean layerL1Enable;
+    private String ID;
+//    private String HOST;
+//    private String CACHE_STORE;
+//    private String CACHE_STORE_SYNC;
+
+
+    public LayeringCache(LayeringCacheManager layeringCacheManager, String name, byte[] prefix,
+                         RedisOperations<? extends Object, ? extends Object> redisOperations, long expiration) {
+        super(name, prefix, redisOperations, expiration);
+        this.layeringCacheManager = layeringCacheManager;
+        this.layeringCacheProperties = layeringCacheManager.getLayeringCacheProperties();
+        this.layerL1Enable = layeringCacheProperties.getCacheL1().isEnable();
+        initEhcache();
+    }
+
+    @Override
+    public Cache.ValueWrapper get(Object key) {
+        StopWatch stopWatch = new StopWatch();
+        stopWatch.start();
+        Ehcache ehCache = null;
+        if (layerL1Enable) {
+            ehCache = getL1Cache(super.getName());
+            Element value = ehCache.get(key);
+            if (value != null) {
+                log.debug("Hit Cache L1 (ehcache) :{}={}", key, value);
+                return new SimpleValueWrapper(value.getObjectValue());
+            }
+        }
+        Cache.ValueWrapper wrapper = super.get(key);
+        if (layerL1Enable && ehCache != null && wrapper != null) {
+            ehCache.put(new Element(key, wrapper.get()));
+            log.debug("Hit Cache L2 (redis) :{}={}", key, wrapper);
+        }
+        stopWatch.stop();
+        log.debug("get use {} ms", stopWatch.getTotalTimeMillis());
+        return wrapper;
+    }
+
+    @Override
+    public void put(final Object key, final Object value) {
+        StopWatch stopWatch = new StopWatch();
+        stopWatch.start();
+        // 先更新1级然后再更新2级;允许短时间内的数据不一致
+        if (layerL1Enable) {
+            Ehcache ehCache = getL1Cache(super.getName());
+            ehCache.put(new Element(key, value, false, layeringCacheProperties.getCacheL1().getLocalTimeToIdleSeconds(), layeringCacheProperties.getCacheL1()
+                    .getLocalTimeToLiveSeconds()));
+            layeringCacheManager.publishMessage(Command.set(this.ID, super.getName(), String.valueOf(key)));
+        }
+        super.put(key, value);
+        stopWatch.stop();
+        log.debug("put use {} ms", stopWatch.getTotalTimeMillis());
+    }
+
+    @Override
+    public void evict(Object key) {
+        // 先删除2级缓存，然后再删除1级缓存;
+        super.evict(key);
+        if (layerL1Enable) {
+            Ehcache ehCache = getL1Cache(super.getName());
+            ehCache.remove(key);
+            layeringCacheManager.publishMessage(Command.del(this.ID, super.getName(), String.valueOf(key)));
+        }
+    }
+
+    @Override
+    public Cache.ValueWrapper putIfAbsent(Object key, final Object value) {
+        if (layerL1Enable) {
+            Ehcache ehCache = getL1Cache(super.getName());
+            ehCache.putIfAbsent(new Element(key, value, false, layeringCacheProperties.getCacheL1().getLocalTimeToIdleSeconds(), layeringCacheProperties
+                    .getCacheL1().getLocalTimeToLiveSeconds()));
+            layeringCacheManager.publishMessage(Command.set(this.ID, super.getName(), String.valueOf(key)));
+        }
+        Cache.ValueWrapper wrapper = super.putIfAbsent(key, value);
+        return wrapper;
+    }
+
+    @Override
+    public void clear() {
+        super.clear();
+        if (layerL1Enable) {
+            Ehcache ehCache = getL1Cache(super.getName());
+            ehCache.removeAll();
+            layeringCacheManager.publishMessage(Command.rem(this.ID, super.getName()));
+        }
+    }
+
+    public void updateL1Cache(Command command) {
+        if (layerL1Enable && command != null && !this.ID.equals(command.getSrc())) {
+            switch (command.getOper()) {
+                case Command.OPT_DEL:
+                    getL1Cache(command.getName()).remove(command.getKey());
+                    log.debug("Remove Cache L1 {} - {}", command.getName(), command.getKey());
+                    break;
+                case Command.OPT_REM:
+                    getL1Cache(command.getName()).removeAll();
+                    log.debug("Clear Cache L1 {}", command.getName());
+                    break;
+                case Command.OPT_SET:
+                    Cache.ValueWrapper wrapper = super.get(command.getKey());
+                    if (wrapper != null) {
+                        Ehcache ehCache = getL1Cache(super.getName());
+                        ehCache.put(new Element(command.getKey(), wrapper.get(), false, layeringCacheProperties.getCacheL1().getLocalTimeToIdleSeconds(),
+                                layeringCacheProperties.getCacheL1().getLocalTimeToLiveSeconds()));
+                        log.debug("Update Cache L1 {} - {}", command.getKey(), wrapper.get());
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    /**
+     * 创建本地缓存
+     */
+    private Ehcache getL1Cache(final String name) {
+        Future<Ehcache> future = this.layeringL1CacheContainer.get(name);
+        if (future == null) {
+            Callable<Ehcache> callable = () -> {
+                Ehcache cache = layeringL1CacheManager.getCache(name);
+                if (cache == null) {
+                    CacheConfiguration cacheConfiguration = getCacheConfiguration();
+                    cacheConfiguration.setName(name);
+                    Ehcache ehcache = new net.sf.ehcache.Cache(cacheConfiguration);
+                    layeringL1CacheManager.addCache(ehcache);
+                    cache = layeringL1CacheManager.getEhcache(name);
+                }
+                return cache;
+            };
+            FutureTask<Ehcache> task = new FutureTask<>(callable);
+            future = this.layeringL1CacheContainer.putIfAbsent(name, task);
+            if (future == null) {
+                future = task;
+                task.run();
+            }
+        }
+        try {
+            return future.get();
+        } catch (Exception e) {
+            this.layeringL1CacheContainer.remove(name);
+            throw new CacheException(e);
+        }
+
+    }
+
+
+    private String getDate() {
+        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMddHHmmssSSS");
+
+        return simpleDateFormat.format(new Date());
+    }
+
+    private CacheConfiguration getCacheConfiguration() {
+        // Cache
+        CacheConfiguration cacheConfiguration = new CacheConfiguration();
+        cacheConfiguration.setEternal(false);
+
+        PersistenceConfiguration persistenceConfiguration = new PersistenceConfiguration();
+        persistenceConfiguration.setStrategy(PersistenceConfiguration.Strategy.NONE.name());
+
+        cacheConfiguration.persistence(persistenceConfiguration);
+        cacheConfiguration.memoryStoreEvictionPolicy(MemoryStoreEvictionPolicy.LRU);
+        cacheConfiguration.setDiskExpiryThreadIntervalSeconds(layeringCacheProperties.getCacheL1().getLocalDiskExpiryThreadIntervalSeconds());
+        // 默认false,使用引用.设置为true,避免外部代码修改了缓存对象.造成EhCache的缓存对象也随之改变
+        // 但是设置为true后,将引起element的tti不自动刷新.如果直接新建element去覆盖原值.则本地ttl和远程ttl会产生一定的误差.
+        // 因此,使用时放弃手动覆盖方式刷新本地tti,当本地tti过期后,自动从Redis中再获取即可.
+        cacheConfiguration.copyOnRead(true);
+        cacheConfiguration.copyOnWrite(true);
+
+//        CopyStrategyConfiguration copyStrategyConfiguration = new CopyStrategyConfiguration();
+//        copyStrategyConfiguration.setClass(MyCopyStrategy.class.getName());
+//        copyStrategyConfiguration.setCopyStrategyInstance(new MyCopyStrategy());
+
+//        cacheConfiguration.addCopyStrategy(copyStrategyConfiguration);
+
+        cacheConfiguration.setTimeToIdleSeconds(layeringCacheProperties.getCacheL1().getLocalTimeToIdleSeconds());
+        cacheConfiguration.setTimeToLiveSeconds(layeringCacheProperties.getCacheL1().getLocalTimeToLiveSeconds());
+
+        return cacheConfiguration;
+    }
+
+    private void initEhcache() {
+        if (layerL1Enable) {
+            this.ID = layeringCacheProperties.getCacheL1().getKey() + "." + getDate();
+//            this.HOST = Utils.getLocalHostIP();
+//            this.CACHE_STORE = layeringCacheProperties.getCacheL1().getKey()
+//                    + layeringCacheProperties.getCacheL1().getSeparator()
+//                    + "cache"
+//                    + layeringCacheProperties.getCacheL1().getSeparator()
+//                    + "store";
+//            this.CACHE_STORE_SYNC = this.CACHE_STORE + layeringCacheProperties.getCacheL1().getSeparator() + "sync";
+
+            Configuration configuration = new Configuration();
+            configuration.setName(this.ID);
+            configuration.setMaxBytesLocalHeap(layeringCacheProperties.getCacheL1().getLocalMaxBytesLocalHeap());
+            configuration.setMaxBytesLocalDisk(layeringCacheProperties.getCacheL1().getLocalMaxBytesLocalDisk());
+            // DiskStore
+            // 每次启动设置新的文件地址,以避免重启期间一级缓存未同步,以及单机多应用启动造成EhcacheManager重复的问题.
+            DiskStoreConfiguration dsc = new DiskStoreConfiguration();
+            dsc.setPath(layeringCacheProperties.getCacheL1().getLocalStoreLocation() + this.ID);
+            configuration.diskStore(dsc);
+
+            CacheConfiguration cacheConfiguration = getCacheConfiguration();
+
+            configuration.setDefaultCacheConfiguration(cacheConfiguration);
+            configuration.setDynamicConfig(false);
+            configuration.setUpdateCheck(false);
+
+
+            layeringL1CacheManager = new CacheManager(configuration);
+        }
+    }
+//
+//    class MyCopyStrategy implements ReadWriteCopyStrategy<Element> {
+//        @Override
+//        public Element copyForWrite(Element value) {
+//            if (value != null) {
+//                Object temp = (Serializable) value.getObjectValue();
+//                return new Element(value.getObjectKey(), temp);
+//            }
+//            return value;
+//        }
+//
+//        @Override
+//        public Element copyForRead(Element storedValue) {
+//            if (storedValue != null) {
+//                Object temp = (Serializable) storedValue.getObjectValue();
+//                return new Element(storedValue.getObjectKey(), temp);
+//            }
+//            return storedValue;
+//
+//        }
+//    }
+}
+package com.irrigation.icl.cache.core;
+
+import org.springframework.boot.bind.RelaxedPropertyResolver;
+import org.springframework.context.annotation.Condition;
+import org.springframework.context.annotation.ConditionContext;
+import org.springframework.core.type.AnnotatedTypeMetadata;
+
+/**
+ * @Author: boni
+ * @Date: 2018/8/24-下午2:52
+ */
+public class LayeringCacheLoadCondition implements Condition {
+    @Override
+    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
+        RelaxedPropertyResolver resolver = new RelaxedPropertyResolver(
+                context.getEnvironment(), "springext.cache.");
+
+        Boolean enable = resolver.getProperty("enable",Boolean.class);
+        if(enable == null){
+            return false;
+        }
+        return enable.booleanValue();
+
+    }
+}
+package com.irrigation.icl.cache.core;
+
+import com.irrigation.icl.cache.Command;
+import org.springframework.data.redis.cache.RedisCache;
+import org.springframework.data.redis.cache.RedisCacheManager;
+import org.springframework.data.redis.core.RedisOperations;
+
+/**
+ * @Author: boni
+ * @Date: 2018/8/24-下午2:29
+ */
+public class LayeringCacheManager extends RedisCacheManager {
+
+    private LayeringCacheProperties layeringCacheProperties;
+
+    public LayeringCacheProperties getLayeringCacheProperties() {
+        return layeringCacheProperties;
+    }
+
+    public void setLayeringCacheProperties(LayeringCacheProperties layeringCacheProperties) {
+        this.layeringCacheProperties = layeringCacheProperties;
+    }
+
+    public LayeringCacheManager(RedisOperations redisOperations, LayeringCacheProperties layeringCacheProperties) {
+        super(redisOperations);
+        this.layeringCacheProperties = layeringCacheProperties;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    protected RedisCache createCache(String cacheName) {
+        long expiration = computeExpiration(cacheName);
+        return new LayeringCache(
+                this,
+                cacheName,
+                (this.isUsePrefix() ? this.getCachePrefix().prefix(cacheName) : null),
+                this.getRedisOperations(),
+                expiration);
+    }
+
+
+    //notify other redis clent to update L1
+    public void publishMessage(Command command) {
+        this.getRedisOperations().convertAndSend(this.getLayeringCacheProperties().getCacheL1().getTopic(), command);
+    }
+
+
+}
+package com.irrigation.icl.cache.core;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+import java.util.Map;
+
+/**
+ * @Author: boni
+ * @Date: 2018/8/24-下午2:59
+ */
+
+@Data
+@ConfigurationProperties(prefix = "springext.cache")
+public class LayeringCacheProperties {
+
+    /**
+     * L1缓存配置
+     */
+    private L1 cacheL1;
+    /**
+     * 是否启用缓存
+     */
+    private boolean enable = true;
+    /**
+     * L2级缓存的过期时间，单位秒
+     */
+    private long expire;
+
+
+    /**
+     * L2级缓存的过期时间，name :time
+     */
+    private Map<String, Long> expires;
+
+
+    @Data
+    // ehcache设置
+    public static class L1 {
+
+        /**
+         * 是否启用L1缓存
+         */
+        private boolean enable = false;
+        /**
+         * 启用L1缓存后同步的topic
+         */
+        private String topic = "default_L1_sync_topic";
+
+        /**
+         * cache中使用的key前缀
+         */
+        private String key = "L1";
+
+        /**
+         * key分隔符
+         */
+        private String separator = ":";
+
+        /**
+         * L1缓存存储磁盘位置
+         */
+        private String localStoreLocation = "./cache/";
+        /**
+         * 本地缓存最大内存大小
+         */
+        private String localMaxBytesLocalHeap = "128M";
+        /**
+         * 本地缓存最大磁盘大小
+         */
+        private String localMaxBytesLocalDisk = "1024M";
+
+        /**
+         * 本地缓存过期时间，单位秒，默认10分钟
+         */
+        private int localTimeToLiveSeconds = 1 * 60;
+        private int localTimeToIdleSeconds = 0;
+        /**
+         * 本地缓存清理周期，单位秒，默认3分钟
+         */
+        private int localDiskExpiryThreadIntervalSeconds = 90;
+    }
+}
@@ -9,10 +9,14 @@ import lombok.NoArgsConstructor;
  
 import java.util.List;
  
+/**
+ * 分页返回类
+ * @param <E>
+ */
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
-@ApiModel(value = "分页返回类")
+@ApiModel(value = "PageList")
 public class PageList<E> {
  
     @ApiModelProperty(value = "总页数")
@@ -6,10 +6,13 @@ import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
  
+/**
+ * 分页参数类
+ */
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
-@ApiModel(value = "分页参数类")
+@ApiModel(value = "PageParam")
 public class PageParam {
  
     @ApiModelProperty(value = "当前页")
@@ -10,14 +10,18 @@ import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
  
+/**
+ * 公共返回类
+ * @param <T>
+ */
 @Data
 @AllArgsConstructor
 @NoArgsConstructor
-@ApiModel(value = "公共返回类")
+@ApiModel(value = "RestResult")
 public class RestResult<T> {
-    @ApiModelProperty(value = "返回编码类型")
+    @ApiModelProperty(value = "返回编码类型",example = "200",allowableValues = "200,400")
     private int code;
-    @ApiModelProperty(value = "返回提示消息")
+    @ApiModelProperty(value = "返回提示消息",example = "成功")
     private String message;
     @ApiModelProperty(value = "返回请求数据对象")
     private T data;
@@ -26,7 +26,7 @@ public enum ResultEnum {
     private final int code;
     private final String message;
  
-    private ResultEnum(int code, String message) {
+     ResultEnum(int code, String message) {
         this.code = code;
         this.message = message;
     }
@@ -11,23 +11,35 @@ public class RestResultGeneratorUtil {
         return result;
     }
  
+    public static  <T> RestResult<T>  getSuccessResult() {
+        return getResult(ResultEnum.SUCCESS.getCode(), null, ResultEnum.SUCCESS.getMessage());
+    }
     public static <T> RestResult<T> getSuccessResult(T data) {
         return getResult(ResultEnum.SUCCESS.getCode(), data, ResultEnum.SUCCESS.getMessage());
     }
  
-    public static RestResult<String> getSuccessResult() {
-        return getResult(ResultEnum.SUCCESS.getCode(), null, ResultEnum.SUCCESS.getMessage());
+    public static  <T> RestResult<T> getSuccessResult(T data,String message) {
+        return getResult(ResultEnum.SUCCESS.getCode(), data, message);
     }
  
-    public static RestResult<String> getErrorResult(String message) {
+    public static  <T> RestResult<T> getSuccessResultMsg(String message) {
+        return getResult(ResultEnum.SUCCESS.getCode(), null, message);
+    }
+
+
+//    public static  RestResult<String> getErrorResult(String message) {
+//        return getResult(ResultEnum.ERROR.getCode(), null, message);
+//    }
+
+    public static <T> RestResult<T> getErrorResult(String message) {
         return getResult(ResultEnum.ERROR.getCode(), null, message);
     }
  
-    public static RestResult<String> getErrorResult(int code, String message) {
+    public static <T> RestResult<T> getErrorResult(int code, String message) {
         return getResult(code, null, message);
     }
  
-    public static RestResult<String> getErrorResult(ResultEnum resultEnum) {
+    public static <T> RestResult<T> getErrorResult(ResultEnum resultEnum) {
         return getResult(resultEnum.getCode(), null, resultEnum.getMessage());
     }
 }