SpringBoot使用Redis缓存的实现方法

（1）pom.xml引入jar包，如下：

									<dependency>

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

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

									  </dependency>

　　（2）修改项目启动类，增加注解@EnableCaching，开启缓存功能，如下：

									package springboot;

									import org.springframework.boot.SpringApplication;

									import org.springframework.boot.autoconfigure.SpringBootApplication;

									import org.springframework.cache.annotation.EnableCaching;

									import org.springframework.scheduling.annotation.EnableScheduling;

									@SpringBootApplication

									@EnableScheduling

									@EnableCaching

									public class SpringbootApplication{

									  public static void main(String[] args) {

									    SpringApplication.run(SpringbootApplication.class, args);

									  }

									}

　　（3）application.properties中配置Redis连接信息，如下：

									# Redis数据库索引（默认为0）

									spring.redis.database=0

									# Redis服务器地址

									spring.redis.host=172.31.19.222

									# Redis服务器连接端口

									spring.redis.port=6379

									# Redis服务器连接密码（默认为空）

									spring.redis.password=

									# 连接池最大连接数（使用负值表示没有限制）

									spring.redis.pool.max-active=8

									# 连接池最大阻塞等待时间（使用负值表示没有限制）

									spring.redis.pool.max-wait=-1

									# 连接池中的最大空闲连接

									spring.redis.pool.max-idle=8

									# 连接池中的最小空闲连接

									spring.redis.pool.min-idle=0

									# 连接超时时间（毫秒）

									spring.redis.timeout=0

　　（4）新建Redis缓存配置类RedisConfig，如下：

									package springboot.config;

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

									import org.springframework.cache.CacheManager;

									import org.springframework.cache.annotation.CachingConfigurerSupport;

									import org.springframework.cache.annotation.EnableCaching;

									import org.springframework.context.annotation.Bean;

									import org.springframework.context.annotation.Configuration;

									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.core.StringRedisTemplate;

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

									import com.fasterxml.jackson.annotation.JsonAutoDetect;

									import com.fasterxml.jackson.annotation.PropertyAccessor;

									import com.fasterxml.jackson.databind.ObjectMapper;

									/**

									 * Redis缓存配置类

									 * @author szekinwin

									 *

									 */

									@Configuration

									@EnableCaching

									public class RedisConfig extends CachingConfigurerSupport{

									  @Value("${spring.redis.host}")

									  private String host;

									  @Value("${spring.redis.port}")

									  private int port;

									  @Value("${spring.redis.timeout}")

									  private int timeout;

									  //自定义缓存key生成策略

									//  @Bean

									//  public KeyGenerator keyGenerator() {

									//    return new KeyGenerator(){

									//      @Override

									//      public Object generate(Object target, java.lang.reflect.Method method, Object... params) {

									//        StringBuffer sb = new StringBuffer();

									//        sb.append(target.getClass().getName());

									//        sb.append(method.getName());

									//        for(Object obj:params){

									//          sb.append(obj.toString());

									//        }

									//        return sb.toString();

									//      }

									//    };

									//  }

									  //缓存管理器

									  @Bean

									  public CacheManager cacheManager(@SuppressWarnings("rawtypes") RedisTemplate redisTemplate) {

									    RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);

									    //设置缓存过期时间 

									    cacheManager.setDefaultExpiration(10000);

									    return cacheManager;

									  }

									  @Bean

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

									    StringRedisTemplate template = new StringRedisTemplate(factory);

									    setSerializer(template);//设置序列化工具

									    template.afterPropertiesSet();

									    return template;

									  }

									   private void setSerializer(StringRedisTemplate template){

									      @SuppressWarnings({ "rawtypes", "unchecked" })

									      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.setValueSerializer(jackson2JsonRedisSerializer);

									   }

									}

　　（5）新建UserMapper，如下：

									package springboot.dao;

									import org.apache.ibatis.annotations.Delete;

									import org.apache.ibatis.annotations.Insert;

									import org.apache.ibatis.annotations.Mapper;

									import org.apache.ibatis.annotations.Param;

									import org.apache.ibatis.annotations.Select;

									import org.apache.ibatis.annotations.Update;

									import org.springframework.cache.annotation.CacheConfig;

									import org.springframework.cache.annotation.CacheEvict;

									import org.springframework.cache.annotation.CachePut;

									import org.springframework.cache.annotation.Cacheable;

									import springboot.domain.User;

									@Mapper

									@CacheConfig(cacheNames = "users")

									public interface UserMapper {

									  @Insert("insert into user(name,age) values(#{name},#{age})")

									  int addUser(@Param("name")String name,@Param("age")String age);

									  @Select("select * from user where id =#{id}")

									  @Cacheable(key ="#p0") 

									  User findById(@Param("id") String id);

									  @CachePut(key = "#p0")

									  @Update("update user set name=#{name} where id=#{id}")

									  void updataById(@Param("id")String id,@Param("name")String name);

									  //如果指定为 true，则方法调用后将立即清空所有缓存

									  @CacheEvict(key ="#p0",allEntries=true)

									  @Delete("delete from user where id=#{id}")

									  void deleteById(@Param("id")String id);

									}

　　@Cacheable将查询结果缓存到redis中，（key="#p0"）指定传入的第一个参数作为redis的key。

　　@CachePut，指定key，将更新的结果同步到redis中

　　@CacheEvict，指定key，删除缓存数据，allEntries=true,方法调用后将立即清除缓存

　　（6）service层与controller层跟上一篇整合一样，启动redis服务器，redis服务器的安装与启动可以参考之前的博客，地址如下：

　　　　http://www.cnblogs.com/gdpuzxs/p/6623171.html

　　（7）配置log4j日志信息，如下：

									## LOG4J配置

									log4j.rootCategory=DEBUG,stdout

									## 控制台输出

									log4j.appender.stdout=org.apache.log4j.ConsoleAppender

									log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

									log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n