redis使用工具类进行保存数据和Ehcache注解缓存类实现缓存value

系统管理员 2022-05-29 09:42 171阅读 0赞

## 前言 ##

本文主要是key value的形式。  
这里我先说下序列化吧  
  
GenericToStringSerializer：使用Spring转换服务进行序列化（可以用来专门转化存放Double等类型，我下面的工具类有介绍）；

JacksonJsonRedisSerializer：使用Jackson 1，将对象序列化为JSON；

Jackson2JsonRedisSerializer：使用Jackson 2，将对象序列化为JSON；

JdkSerializationRedisSerializer：使用Java序列化；

StringRedisSerializer：序列化String类型的key和value。实际上是String和byte数组之间的转换，那么Key只能是String类型的，不能为Long，Integer，否则会报错抛异常。

StringSerializer就是通过String.getBytes()来实现的，而且在Redis中，所有存储的值都是字符串类型的。所以这种方法保存后，通过Redis-cli控制台，是可以清楚的查看到我们保存了什么key,value是什么。它只能对String类型进行序列化

JdkSerializationRedisSerializer，这个序列化方法是Idk提供的，要求要被序列化的类继承自Serializeable接口，然后通过Jdk对象序列化的方法保存，这个序列化保存的对象，即使是个String类型的，在redis控制台，也是看不出来的，还是类似于 乱码的东西。因为它保存了一些对象的类型什么的额外信息。除非中间再加上一些objectmappr就可以看到内容了，如下

@Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
    	RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();
    	redisTemplate.setConnectionFactory(factory);
    
    	//key序列化方式,StringXX是转为String，JacksonXX是将对象转为json。
    	// 需要注意这里Key使用了StringRedisSerializer，那么Key只能是String类型的，不能为Long，Integer，否则会报错抛异常。
    	// 就是假如PostRepository里定义的@Cacheable（key="0"）的话就会报错，因为这样作为key的是int型，key必须为String。
    	//所以在没有自己定义key生成策略的时候，可以不配置,我就没有配置
    	RedisSerializer<String> redisSerializer = new StringRedisSerializer();//Long类型不可以会出现异常信息;
    	redisTemplate.setKeySerializer(redisSerializer);
    
    	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);
    
    	redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
    
    
    	return redisTemplate;
    }

![WX20180320-193953@2x][WX20180320-193953_2x]

## Ehcache和redis应该怎么用 ##

我公司的项目中既有Ehcache 又有Redis，所以这里都会讲解  
ehcache直接在jvm虚拟机中缓存，速度快，效率高；但是缓存共享麻烦，集群分布式应用不方便。

redis是通过socket访问到缓存服务，效率比ecache低，比数据库要快很多，处理集群和分布式缓存方便，有成熟的方案。

如果是单个应用或者对缓存访问要求很高的应用，用ehcache。  
如果是大型系统，存在缓存共享、分布式部署、缓存内容很大的，建议用redis。

补充下：ehcache也有缓存共享方案，不过是通过RMI或者Jgroup多播方式进行广播缓存通知更新，缓存共享复杂，维护不方便；简单的共享可以，但是涉及到缓存恢复，大数据缓存，则不合适

## 1、springBoot引入spring配置文件，进行redis的搭建    ##

@ImportResource(value = "classpath:applicationContext.xml")
    @SpringBootApplication
    public class SinoredisSpringbootApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(SinoredisSpringbootApplication.class, args);
    	}
    }

### 1.1、spring配置文件如下    ###

### 1.2、redis配置信息在properties中如下    ###

########################################################
    ###REDIS (RedisProperties) redis
    ########################################################
    hlj.redis.host-name=127.0.0.1
    hlj.redis.password=
    hlj.redis.max-total=64
    hlj.redis.max-idle=30
    hlj.redis.port=6379
    hlj.redis.pool.max-wait=-1

### 1.3、redis配置文件如下    ###

这里可以看到我使用了自定义的key 和value的序列化方式

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig" >
            <property name="maxTotal" value="${hlj.redis.max-total}"/>
            <property name="maxIdle" value="${hlj.redis.max-idle}"/>
            <property name="maxWaitMillis" value="${hlj.redis.pool.max-wait}"/>
        </bean>
    
        <bean id="jedisFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy">
            <property name="password" value="${hlj.redis.password}"/>
            <property name="hostName" value="${hlj.redis.host-name}"/>
            <property name="port" value="${hlj.redis.port}"/>
            <property name="usePool" value="true"/>
            <property name="poolConfig" ref="jedisPoolConfig"/>
        </bean>
    
        <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" scope="prototype">
            <property name="connectionFactory" ref="jedisFactory"/>
            <property name="keySerializer">
                <bean class="com.hlj.redis.cache.CustomStringRedisSerializer"/>
            </property>
            <property name="valueSerializer">
                <bean class="com.hlj.redis.cache.CustomJSONStringRedisSerializer"/>
            </property>
        </bean>
    </beans>

### 1.3.1 自定义key的序列化方式 ###

package com.hlj.config.serializer;
    
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.util.Assert;
    
    import java.math.BigDecimal;
    import java.math.BigInteger;
    import java.nio.charset.Charset;
    
    /**
     * 类名称：CustomStringRedisSerializer
     * 类描述：定制String 序列转换
     * 创建人：qingxu
     * 修改人：
     * 修改时间：2016/3/2 15:04
     * 修改备注：
     *
     * @version 1.0.0
     */
    public class CustomStringRedisSerializer implements RedisSerializer<Object> {
    
        private final Charset charset;
    
        public CustomStringRedisSerializer() {
            this(Charset.forName("UTF8"));
        }
    
        public CustomStringRedisSerializer(Charset charset) {
            Assert.notNull(charset);
            this.charset = charset;
        }
    
        public String deserialize(byte[] bytes) {
            return bytes == null?null:new String(bytes, this.charset);
        }
    
        public byte[] serialize(Object string) {
            if(string == null ) {
                return null;
            }
            if(string instanceof Long){
                return String.valueOf(string).getBytes(this.charset);
    
            }
            if(string instanceof Integer){
                return String.valueOf(string).getBytes(this.charset);
    
            }
            if(string instanceof BigDecimal){
                return ((BigDecimal)string).toString().getBytes(this.charset);
            }
    
            if(string instanceof BigInteger){
                return ((BigInteger)string).toString().getBytes(this.charset);
            }
    
            if(string instanceof Double){
                return ((Double)string).toString().getBytes(this.charset);
            }
    
            if(string instanceof Float){
                return ((Float)string).toString().getBytes(this.charset);
            }
            return ((String)string).getBytes(this.charset);
        }
    }

#### 1.3.2、自定义value的序列化方式 ####

package com.hlj.config.serializer;
    
    import com.fasterxml.jackson.annotation.JsonTypeInfo;
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.DeserializationFeature;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.SerializationException;
    import org.springframework.util.Assert;
    import org.springframework.util.StringUtils;
    
    /**
     * 类名称：CustomJSONStringRedisSerializer
     * 类描述：转换对象为json字符串
     * 创建人：qingxu
     * 修改人：
     * 修改时间：2016/3/2 15:04
     * 修改备注：
     *
     * @version 1.0.0
     */
    public class CustomJSONStringRedisSerializer implements RedisSerializer<Object> {
    
        public static final String EMPTY_JSON = "{}";
    
        public static final byte[] EMPTY_ARRAY = new byte[0];
    
        private final ObjectMapper mapper;
    
        /**
         * Creates {@link CustomJSONStringRedisSerializer} and configures {@link ObjectMapper} for default typing.
         */
        public CustomJSONStringRedisSerializer() {
            this((String) null);
        }
    
        /**
         * Creates {@link CustomJSONStringRedisSerializer} and configures {@link ObjectMapper} for default typing using the
         * given {@literal name}. In case of an {@literal empty} or {@literal null} String the default
         * {@link JsonTypeInfo.Id#CLASS} will be used.
         *
         * @param classPropertyTypeName Name of the JSON property holding type information. Can be {@literal null}.
         */
        public CustomJSONStringRedisSerializer(String classPropertyTypeName) {
    
            this(new RedisObjectMapper());
    
            if (StringUtils.hasText(classPropertyTypeName)) {
                mapper.enableDefaultTypingAsProperty(ObjectMapper.DefaultTyping.NON_FINAL, classPropertyTypeName);
            } else {
                mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
            }
        }
    
        /**
         * Setting a custom-configured {@link ObjectMapper} is one way to take further control of the JSON serialization
         * process. For example, an extended {@link} can be configured that provides custom serializers for
         * specific types.
         *
         * @param mapper must not be {@literal null}.
         */
        public CustomJSONStringRedisSerializer(ObjectMapper mapper) {
            Assert.notNull(mapper, "ObjectMapper must not be null!");
    
            mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);
            this.mapper = mapper;
        }
    
        /*
         * (non-Javadoc)
         * @see org.springframework.data.redis.serializer.RedisSerializer#serialize(java.lang.Object)
         */
        @Override
        public byte[] serialize(Object source) throws SerializationException {
            if (source == null) {
                return EMPTY_ARRAY;
            }
    
            try {
                return mapper.writeValueAsBytes(source);
            } catch (JsonProcessingException e) {
                throw new SerializationException("Could not write JSON: " + e.getMessage(), e);
            }
        }
    
        /*
         * (non-Javadoc)
         * @see org.springframework.data.redis.serializer.RedisSerializer#deserialize(byte[])
         */
        @Override
        public Object deserialize(byte[] source) throws SerializationException {
            return deserialize(source, Object.class);
        }
    
        /**
         * @param source can be {@literal null}.
         * @param type must not be {@literal null}.
         * @return {@literal null} for empty source.
         * @throws SerializationException
         */
        public <T> T deserialize(byte[] source, Class<T> type) throws SerializationException {
    
            Assert.notNull(type,
                    "Deserialization type must not be null! Pleaes provide Object.class to make use of Jackson2 default typing.");
    
            if (source == null || source.length == 0) {
                return null;
            }
    
            try {
                return mapper.readValue(source, type);
            } catch (Exception ex) {
                throw new SerializationException("Could not read JSON: " + ex.getMessage(), ex);
            }
        }
    }

1.3.4、如果使用上面序列化的话，那么redis库总可以看到是class或者是请他的java数据类型，下图是后期的答案，这里只是简单的介绍

![WX20180320-194420@2x][WX20180320-194420_2x]

![WX20180320-194333@2x][WX20180320-194333_2x]

### 1.4、至此，其实redis就已经搭建好了    ###

## 2、、reids存储对象工具类    ##

### 2.1、工具类    ###

1、这个工具类，在描述的时候，就说道，分不清Long和Integer，Double和Float。所以我们一般只用来存放对象

2、本类中可以看到有两个服务类`ValueOperations`和`RedisOperations`，但是其实是同一个类只不过名字不同。只是其作用的范围表面上意思不一样，**第一个是用来存取数据，第二个用来操作参数数据的**

package com.hlj.redis.redisTool;
    
    import org.springframework.data.redis.core.RedisOperations;
    import org.springframework.data.redis.core.ValueOperations;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.Resource;
    
    /**
     * 类描述：
     * 操作redis 对象数据的工具类
     * 提供存取数字外对象的存取，数字类型使用RedisLongData/RedisIntegerData进行操作
     * 这个类分不清Long和Integer,Float和Double。也无法进行原子操作
     * 创建人： j.sh
     * 创建时间： 2016/3/1
     * version：1.0.0
     */
    @Component
    public class RedisObjectData {
    
        @Resource(name="redisTemplate")
        private ValueOperations<String, Object> valueOperations;
    
        @Resource(name = "redisTemplate")
        private RedisOperations<String,Object> operations;
    
        /**
         * 根据key获取数据
         * @param key
         * @return
         */
        public Object getData(String key) {
            return valueOperations.get(key);
        }
    
        /**
         * 设置数据
         * @param key
         * @param object
         */
        public void setData(String key,Object object) {
            valueOperations.set(key,object);
        }
    
        /**
         * 根据key 删除对应的数据
         * @param key
         */
        public void delete(String key) {
            operations.delete(key);
        }
    }

### 2.2、controller测试 ###

#### 2.2.1、添加缓存对象和读取缓存对象 ####

package com.hlj.controller;
    
    import com.hlj.Format.ResponseBean;
    import com.hlj.bean.Person;
    import com.hlj.redis.redisTool.RedisLongData;
    import com.hlj.redis.redisTool.RedisObjectData;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import java.util.ArrayList;
    import java.util.List;
    
    
    @Controller
    public class RedisObjectDataController {
    
    	@Autowired
    	private RedisObjectData redisObjectData;
    
    	/**
    	 * 添加缓存对象
    	 */
        @RequestMapping("/setRedisObjectData")
        public @ResponseBody ResponseBean setRedisObjectData(Long id){
    		try {
    			Person person = new Person();
    			person.setName("HealerJean");
    			person.setPwd("123456");
    			person.setId(id);
    			redisObjectData.setData("person", person);
    			return  ResponseBean.buildSuccess();
    		}catch (Exception e){
    			return ResponseBean.buildFailure(e.getMessage());
    		}
        }
    
    	/**
    	 * 根据key获取缓存对象
    	 * @return
    	 */
    	@RequestMapping("/getRedisObjectData")
    	public @ResponseBody ResponseBean getRedisObjectData(String key){
    	   	try {
    			Person person = (Person) redisObjectData.getData(key);
    			return ResponseBean.buildSuccess(person);
    		}catch (Exception e){
    	   		return  ResponseBean.buildFailure(e.getMessage());
    		}
    	}

服务器启动：  
1.1、浏览器打开输入 [http://localhost:8080/setRedisObjectData?id=1][http_localhost_8080_setRedisObjectData_id_1]

![WX20180320-122358@2x][WX20180320-122358_2x]

1.2、查看redis中的数据,发现已经有数据了数据了

![WX20180320-122446@2x][WX20180320-122446_2x]

2.1、对数据进行读取，浏览器中打开[http://localhost:8080/getRedisObjectData?key=person][http_localhost_8080_getRedisObjectData_key_person]

![WX20180320-122622@2x][WX20180320-122622_2x]

2.2、上述读取数据成功

#### 2.2.2、 根据key值删除缓存    ####

/**
     * 根据key删除缓存对象
     * @return
     */
    @RequestMapping("/delRedisObjectData")
    public @ResponseBody ResponseBean delRedisObjectData(String key){
    	try {
    		redisObjectData.delete(key);
    		return ResponseBean.buildSuccess();
    	}catch (Exception e){
    		return  ResponseBean.buildFailure(e.getMessage());
    	}
    }

1.1、浏览器中打开 [http://localhost:8080/delRedisObjectData?key=person][http_localhost_8080_delRedisObjectData_key_person]

![WX20180320-122846@2x][WX20180320-122846_2x]

1.2、查看redis库,删除成功

![WX20180320-122931@2x][WX20180320-122931_2x]

#### 2.2.3、存储List对象集合    ####

/**
     * 添加List缓存对象
     * @param id
     * @return
     */
    @RequestMapping("/setListRedisObjectData")
    public @ResponseBody ResponseBean setListRedisObjectData(Long id){
    	try {
    		List<Person> persons = new ArrayList<>();
    		Person person1= new Person(id,"HealerJean"+id,"password"+id);
    		Person person2 = new Person(id+1,"HuangLiang"+id,"HuangLiang"+id);
    		persons.add(person1);
    		persons.add(person2);
    		redisObjectData.setData("persons", persons);
    		return  ResponseBean.buildSuccess();
    	}catch (Exception e){
    		return ResponseBean.buildFailure(e.getMessage());
    	}
    }
    
    /**
     * 根据key获取缓存List对象
     * @return
     */
    @RequestMapping("/getListRedisObjectData")
    public @ResponseBody ResponseBean getListRedisObjectData(String key){
    	try {
    		List<Person> persons = (List<Person>) redisObjectData.getData(key);
    		return ResponseBean.buildSuccess(persons);
    	}catch (Exception e){
    		return  ResponseBean.buildFailure(e.getMessage());
    	}
    }

1.1、浏览器中打开[http://localhost:8080/setListRedisObjectData?id=1][http_localhost_8080_setListRedisObjectData_id_1]

![WX20180320-123152@2x][WX20180320-123152_2x]

1.2、查看redis库,有数据

![WX20180320-123233@2x][WX20180320-123233_2x]

2.1、根据key值获取list对象，浏览器中打开[http://localhost:8080/getListRedisObjectData?key=persons][http_localhost_8080_getListRedisObjectData_key_persons]

![WX20180320-123356@2x][WX20180320-123356_2x]

2.2、成功,下面要测试，清除下redis库

fulshdb

#### 2.2.4、测试放入Long，报错误异常Integer不能转化为Long ####

/**
     * 添加Long类型缓存对象，这是个错误的演示，仅供测试
     * @param id
     * @return
     */
    @RequestMapping("/set")
    public @ResponseBody ResponseBean set(Long id){
    	try {
    
    		redisObjectData.setData("id", id);
    		return  ResponseBean.buildSuccess();
    	}catch (Exception e){
    		return ResponseBean.buildFailure(e.getMessage());
    	}
    }
    
    /**
     * 根据key获取Long，这是个错误的演示，仅供测试
     * @return
     */
    @RequestMapping("/get")
    public @ResponseBody ResponseBean get(String key){
    	try {
    		Long id = (Long) redisObjectData.getData("id");
    		return ResponseBean.buildSuccess(id);
    	}catch (Exception e){
    		return  ResponseBean.buildFailure(e.getMessage());
    	}
    }

1.1、浏览器中打开[http://localhost:8080/set?id=1][http_localhost_8080_set_id_1]

![WX20180320-131826@2x][WX20180320-131826_2x]

1.2、查看redis库

![WX20180320-131858@2x][WX20180320-131858_2x]

2.1、根据key值获取，这个时候 就会报错了，朋友们,提示Integer不能转化为long

![WX20180320-132003@2x][WX20180320-132003_2x]

## 3、redis存取Long类型工具类    ##

### 3.1、工具类代码    ###

package com.hlj.redis.redisTool;
    
    import org.springframework.beans.factory.InitializingBean;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.ValueOperations;
    import org.springframework.data.redis.serializer.GenericToStringSerializer;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.Resource;
    import java.util.concurrent.TimeUnit;
    
    /**
     * 类描述：
     * redis操作Long类型数据的工具类
     * 提供Long类型原子操作
     * 默认一天过期,其他过期时间调用setExpire
     * 创建人： j.sh
     * 创建时间： 2016/3/1
     * version：1.0.0
     */
    @Component
    public class RedisLongData implements InitializingBean {
    
        @Resource(name="redisTemplate")
        private ValueOperations<String, Long> valueOperations;
    
        @Resource(name="redisTemplate")
        private RedisTemplate<String,Long> redisTemplate;
    
    
        @Override
        public void afterPropertiesSet() throws Exception {
            redisTemplate.setValueSerializer(new GenericToStringSerializer<Long>(Long.class));
            valueOperations = redisTemplate.opsForValue();
        }
    
        /**
         * 根据key 删除
         * @param key
         */
        public void delete(String key) {
            redisTemplate.delete(key);
        }
    
        /**
         * 进行数值的增加
         * @param key
         * @param value
         * @return
         */
        public Long increase(String key,long value){
            Long result = valueOperations.increment(key,value);
            this.setExpire(key,1L,TimeUnit.DAYS);
            return result;
        }
    
        /**
         * 进行数值的增加
         * @param key
         * @return
         */
        public Long increase(String key){
            return increase(key,1);
        }
    
        /**
         * 进行数值的递减
         * @param key
         * @param value
         * @return
         */
        public Long decrease(String key,long value){
            Long result =  valueOperations.increment(key,0-value);
            this.setExpire(key,1L,TimeUnit.DAYS);
            return result;
        }
    
        /**
         * 进行数值的递减
         * @param key
         * @return
         */
        public Long decrease(String key){
            return decrease(key,1);
        }
    
        /**
         * 根据key获取
         * @param key
         * @return
         */
        public Long get(String key) {
            return valueOperations.get(key);
        }
    
        /**
         * 设置
         * @param key
         * @param value
         */
        public void set(String key,Long value) {
            valueOperations.set(key,value);
            this.setExpire(key,1L,TimeUnit.DAYS);
        }
    
        /**
         * 过期时间，默认单位秒
         * @param key
         * @param time
         */
        public void setExpire(String key,Long time){
            redisTemplate.expire(key,time, TimeUnit.SECONDS);
        }
    
        /**
         * 过期时间
         * @param key
         * @param time
         * @param timeUnit
         */
        public void setExpire(String key,Long time,TimeUnit timeUnit){
            redisTemplate.expire(key,time,timeUnit);
        }
    
    }

### 3.2、controller测试。没啥问题。自己测试吧 ###

package com.hlj.controller;
    
    import com.hlj.Format.ResponseBean;
    import com.hlj.redis.redisTool.RedisLongData;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    @Controller
    public class RedisLongDataController {
    
    
        @Autowired
        private RedisLongData redisLongData;
    
        /**
         * 添加Long类型的缓存数据
         */
        @RequestMapping("/setRedisLongData")
        public @ResponseBody  ResponseBean setRedisLongData(Long id){
            try {
                redisLongData.set("long",id);
                return  ResponseBean.buildSuccess();
            }catch (Exception e){
                return ResponseBean.buildFailure(e.getMessage());
            }
        }
    
    	/**
    	 * 获取Long类型的缓存数据
    	 */
    	
        @RequestMapping("/getRedisLongData")
        public @ResponseBody ResponseBean getRedisLongData(String key){
            try {
                Long id = redisLongData.get(key);
                return ResponseBean.buildSuccess(id);
            }catch (Exception e){
                return  ResponseBean.buildFailure(e.getMessage());
            }
        }
    
    }

## 4、Ehcache ##

那么关于它的使用，我先说明，这里是要使用注解的，而且是非常完美的注解

### 1、依赖的导入 ###

<dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-context-support</artifactId>
    </dependency>
    
    <dependency>
    	<groupId>net.sf.ehcache</groupId>
    	<artifactId>ehcache</artifactId>
    </dependency>

### 2、缓存配置文件 ###

之前学习的时候，这个配置文件中药写入value的缓存策略，但是我做了一个自定义的缓存管理器，直接在Java类中配置常量就可以了，非常小巧和方便

<ehcache updateCheck="false">
    
        
        
    
        
    
        <defaultCache
                maxElementsInMemory="10000"
                eternal="false"
                timeToIdleSeconds="600"
                timeToLiveSeconds="600"
                overflowToDisk="true"
                maxElementsOnDisk="10000000"
                diskPersistent="false"
                diskExpiryThreadIntervalSeconds="120"
                diskSpoolBufferSizeMB="64"
                memoryStoreEvictionPolicy="LRU"
        />
        
    
    </ehcache>

### 3、spring中进行配置 ###

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:cache="http://www.springframework.org/schema/cache"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
     http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd " >
    
    
        <description>spring configuration</description>
    
    
        <import resource="applicationContext-redis.xml"/>
    
    
        
        <cache:annotation-driven/>
    
        <bean id="cacheManager" class="com.hlj.Ehcache.config.CustomEhCacheManager">
            <property name="cacheManager" ref="ehcacheManager"/>
        </bean>
    
        <bean id="ehcacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
            <property name="configLocation" value="classpath:ehcache.xml"/>
            <property name="shared" value="true"/>
        </bean>
    
    </beans>

#### 3.1、配置自定义的缓存管理器 ####

package com.hlj.Ehcache.config;
    
    import net.sf.ehcache.Ehcache;
    import net.sf.ehcache.config.CacheConfiguration;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.cache.Cache;
    import org.springframework.cache.ehcache.EhCacheCache;
    import org.springframework.cache.ehcache.EhCacheCacheManager;
    
    import java.lang.reflect.Field;
    import java.util.*;
    
    /**
     *  类描述：继承 EhCacheCacheManager
     * @Description 初始化缓存。加载@CacheConstants中缓存定义及缓存自定义过期时间
     * @Date   2018/3/21 下午2:46.
     */
    public class CustomEhCacheManager extends EhCacheCacheManager {
    
        private static String CACHE_PREFIX = "CACHE_";
        private static String EXPIRE_PREFIX = "EXPIRE_";
        private static Logger logger = LoggerFactory.getLogger(CustomEhCacheManager.class);
    
        private static List<String> cacheNames = new ArrayList<>();
        private static Map<String,Long> expires = new HashMap<>();
    
        @Override
        public void afterPropertiesSet() {
            try {
                Class clazz = CacheConstants.class;
                Field[] fields = clazz.getDeclaredFields();
                for(Field field : fields){
                    if (field.getName().startsWith(CACHE_PREFIX)){
                        cacheNames.add(field.get(clazz).toString());
                    } else if (field.getName().startsWith(EXPIRE_PREFIX)){
                        expires.put(
                                clazz.getField(field.getName().replace(EXPIRE_PREFIX,"")).get(clazz).toString(),
                                Long.parseLong(field.get(clazz).toString())
                        );
                    }
                }
            } catch (Exception e) {
                logger.error(e.getMessage(),e);
                throw new RuntimeException("init cache failure!",e);
            }
            super.afterPropertiesSet();
        }
    
        @Override
        protected Collection<Cache> loadCaches() {
            LinkedHashSet<Cache> caches = new LinkedHashSet<Cache>(cacheNames.size());
            for(String name:cacheNames){
                Ehcache exist = this.getCacheManager().addCacheIfAbsent(name);
                if(exist != null){
                    Cache cache = new EhCacheCache(exist);
                    Ehcache ehcache = (Ehcache) cache.getNativeCache();
                    CacheConfiguration configuration = ehcache.getCacheConfiguration();
                    Long time = expires.get(name);
                    configuration.setTimeToIdleSeconds(time);
                    configuration.setTimeToLiveSeconds(time);
                    caches.add(cache);
                }
            }
            return caches;
        }
    }

#### 3.2、字段以缓存策略的名称，也叫缓存位置名称 ####

package com.hlj.Ehcache.config;
    
    /**
     * 类名称：CacheConstants
     * 类描述：缓存常量类
     * 创建人：HealerJean
     * 需要初始化的缓存定义名称需要以CACHE_为前缀。如：CACHE_XXX
     * 如果需要增加自定义过期时间，则增加过期时间变量定义EXPIRE_为前缀的缓存过期时间.如：EXPIRE_CACHE_XXX
     * 如不设置自定义过期时间即默认spring cache中设置过期时间
     *
     * @version 1.0.0
     */
    public class CacheConstants {
    
        //公共缓存，1分钟过期时间
        public static final String CACHE_PUBLIC_PERSON = "cache.public.person";
        public static final Long EXPIRE_CACHE_PUBLIC_PERSON = 60L;
    
    
        public static final String CACHE_PUBLIC = "cache.public";
        public static final Long EXPIRE_CACHE_PUBLIC = 60L;
    
        public static final String CACHE_PUBLIC_TEN_MINUTE = "cache.public.ten.minute";
        public static final Long EXPIRE_CACHE_PUBLIC_TEN_MINUTE = 10 * 60L;
    
    }

### 4、开始测试吧，朋友们，这里不像多讲解了，主要还是看代码吧，注释也非常详细 ###

#### 1、controller ####

package com.hlj.Ehcache.controller;
    
    
    import com.hlj.Ehcache.service.EhcacheService;
    import com.hlj.bean.Person;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import java.util.List;
    
    /**
     * @Description
     * @Author HealerJean
     * @Date 2018/3/21  下午1:58.
     */
    @Controller
    public class EhCacheController {
    
    
        @Autowired
        private EhcacheService ehcacheService;
    
        @GetMapping("save")
        public @ResponseBody Person save(Long id) {
            Person person = new Person(id,"EhcacheHealerJean","123465");
            return ehcacheService.save(person);
        }
    
        @GetMapping("findById")
        public @ResponseBody Person findById(Long id) {
            return ehcacheService.findById(id);
        }
    
        @GetMapping("update")
        public @ResponseBody Person update(Person person) {
            return ehcacheService.update(person);
        }
    
        @GetMapping("delete")
        public @ResponseBody String delete(Long id) {
            ehcacheService.delete(id);
            return "删除成功";
        }
    
        @GetMapping("listPerson")
        public@ResponseBody  List<Person> listPerson() {
            return ehcacheService.listPerson();
        }
    }

#### 4.2、service ####

package com.hlj.Ehcache.service.impl;
    
    import com.hlj.Ehcache.config.CacheConstants;
    import com.hlj.Ehcache.service.EhcacheService;
    import com.hlj.bean.Person;
    import com.hlj.repository.PersonRepository;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.annotation.CacheEvict;
    import org.springframework.cache.annotation.CachePut;
    import org.springframework.cache.annotation.Cacheable;
    import org.springframework.stereotype.Service;
    
    import java.util.List;
    
    /**
     * @Description
     * @Author HealerJean
     * @Date 2018/3/21  下午1:59.
     */
    @Service
    public class EhcacheServiceImpl implements EhcacheService{
    
        @Autowired
        private PersonRepository personRepository;
    
    
        //这里的单引号不能少，否则会报错，被识别是一个对象;
        public static final String CACHE_KEY = "'person'";
    
        /**
         * value属性表示使用哪个缓存策略，缓存策略在ehcache.xml,现在存放在下面的实体类中，在启动的时候自动加载了
         * 也叫缓存存放位置名称，不能为空
         */
        public static final String DEMO_CACHE_NAME = CacheConstants.CACHE_PUBLIC_PERSON;
    
    
        /**
         * 保存数据，防止是更新的操作，所以将之前缓存的删除,事实上，我也并没有很成功的实现它，后来明白啦，哈，原来是list集合缓存的时候，添加要删除的哦
         * @param Person
         */
    
        @CacheEvict(value=DEMO_CACHE_NAME,key=CACHE_KEY)
        public Person save(Person Person){
            return personRepository.save(Person);
        }
    
        /**
         * 查询数据.
         * @param id
         * @return
         */
        @Cacheable(value=DEMO_CACHE_NAME ,key="'Person_'+#id")
        public Person findById(Long id){
            return personRepository.findOne(id);
        }
    
        /**
         * 修改数据.
         * 在支持Spring Cache的环境下，与@Cacheable不同的是使用@CachePut标注的方法在执行前不会去检查缓存中是否存在之前执行过的结果，而是每次都会执行该方法，并将执行结果以键值对的形式存入指定的缓存中。
         @CachePut也可以标注在类上和方法上。使用@CachePut时我们可以指定的属性跟@Cacheable是一样的。
         */
        @CachePut(value = DEMO_CACHE_NAME,key = "'Person_'+#person.getId()")
        public Person update(Person person)  {
            Person Person = personRepository.findOne(person.getId());
            Person.setName(person.getName());
            Person.setPwd(person.getPwd());
            return Person;
        }
    
    
        /**
         * 删除数据.
         * @param id
         */
        @CacheEvict(value = DEMO_CACHE_NAME,key = "'Person_'+#id")//这是清除缓存.
        public void delete(Long id){
            personRepository.delete(id);
        }
    
        @Cacheable(value=DEMO_CACHE_NAME ,key=CACHE_KEY)
        public List<Person> listPerson() {
            return personRepository.findAll();
        }
    }

## [代码下载][Link 1] ##

![ContactAuthor][]

[WX20180320-193953_2x]: /images/20220529/31401cf49a1c4fc3b18e0bdb8b33fa66.png
[WX20180320-194420_2x]: /images/20220529/051fc20b3a2f4355ad235d3cce660e2c.png
[WX20180320-194333_2x]: /images/20220529/36d7799cac774ce6817acef345911668.png
[http_localhost_8080_setRedisObjectData_id_1]: http://localhost:8080/setRedisObjectData?id=1
[WX20180320-122358_2x]: /images/20220529/36a6aafc76664d90a308060cb570767e.png
[WX20180320-122446_2x]: /images/20220529/3ed9c52e295247c19025274b17e60d46.png
[http_localhost_8080_getRedisObjectData_key_person]: http://localhost:8080/getRedisObjectData?key=person
[WX20180320-122622_2x]: /images/20220529/c22ff7c8ab814b088b69ffc6365e6877.png
[http_localhost_8080_delRedisObjectData_key_person]: http://localhost:8080/delRedisObjectData?key=person
[WX20180320-122846_2x]: /images/20220529/06fd98fc06ef4f84b85f4df8e25cf885.png
[WX20180320-122931_2x]: /images/20220529/27b0094ca4444149afe2b74ce1cb0e05.png
[http_localhost_8080_setListRedisObjectData_id_1]: http://localhost:8080/setListRedisObjectData?id=1
[WX20180320-123152_2x]: /images/20220529/e74d1cb625ad44d99d0fbaaeb183291e.png
[WX20180320-123233_2x]: /images/20220529/d9f3ffa951c74a27b2f2c7687095f7d9.png
[http_localhost_8080_getListRedisObjectData_key_persons]: http://localhost:8080/getListRedisObjectData?key=persons
[WX20180320-123356_2x]: /images/20220529/eafc0e86333840a58c5d806f17df0f7b.png
[http_localhost_8080_set_id_1]: http://localhost:8080/set?id=1
[WX20180320-131826_2x]: /images/20220529/06b05db1b95f46968550fcf0384c9301.png
[WX20180320-131858_2x]: /images/20220529/c5ba0b04fb4d430a9e524c6ab89d595f.png
[WX20180320-132003_2x]: /images/20220529/dfbfcb4927674530b1195389d864b4a6.png
[Link 1]: https://gitee.com/HealerJean/CodeDownLoad/raw/master/2018_03_20_1_redis%E4%BD%BF%E7%94%A8%E5%B7%A5%E5%85%B7%E7%B1%BB%E8%BF%9B%E8%A1%8C%E4%BF%9D%E5%AD%98%E6%95%B0%E6%8D%AE%E5%92%8CEhcache%E6%B3%A8%E8%A7%A3%E7%BC%93%E5%AD%98%E7%B1%BB%E5%AE%9E%E7%8E%B0%E7%BC%93%E5%AD%98value/com-hlj-ddkj-redis-ehcache.zip
[ContactAuthor]: /images/20220529/869413a72dde43c38330f57c557b2c71.png