Springboot+Jedis+Ehcache整合

项目结构概览：

1. 导包

      <parent> 
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.8.RELEASE</version>
        <relativePath/> 
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>
    
    <dependencies>
        <!--web场景启动器，包含 Tomcat 和 spring-mvc restful  aop jackjson支持。 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 热加载 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- ehcache缓存 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <!-- redis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>
        <!-- 热加载 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- commons-lang3工具类 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.7</version>
        </dependency>
    </dependencies>
  
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>  

2.1 application.properties配置文件

# 运行端口
server.port=8084
# 项目访问路径前缀
server.context-path=/cache

# 服务名称
spring.application.name=springbootTest
# ehcache配置文件
spring.cache.ehcache.config=classpath:ehcacheproduct.xml

2.2 redis.properties配置参数

# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
#spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=1024
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=10000
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=200
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=10000
#flase:超时就报错,   true:阻塞到超时
spring.redis.block-when-exhausted=true

2.3 ehcacheproduct.xml配置问价

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="ehcache.xsd">
    
    <!-- 磁盘缓存位置 -->
    <diskStore path="java.io.tmpdir" />
    
    <!-- 
        name: 缓存名称
        maxElementsInMemory: 缓存最大个数
        maxEntriesLocalHeap: 在内存创建对象的最大数量,0=无限制。
        maxEntriesLocalDisk: 硬盘上存储的对象的最大数量。默认0,即无限制
        eternal: 对象是否永久有效,一但设置了, timeout将不起作用
        timeToIdleSeconds: 当缓存闲置n秒后销毁 ,默认是0,也就是对象存活时间无穷大。当eternal=false时有效!
        timeToLiveSeconds: 当缓存存活n秒后销毁 ,默认是0,也就是对象存活时间无穷大。当eternal=false时有效!
        overflowToDisk: 达到缓存maxElementsInMemory个数后,将数据存入磁盘,默认大小为30mb
        diskPersistent: 是否缓存虚拟机重启期数据 
        diskExpiryThreadIntervalSeconds: 磁盘失效线程运行时间间隔，默认是120秒。达到缓存最大个数,会按照磁盘清理策略去清理磁盘。
        memoryStoreEvictionPolicy: 磁盘清理策略, 默认策略LRU（最近最少使用）你可以设置为FIFO（先进先出）或是LFU（较少使用）。
        clearOnFlush: 内存数量最大时是否清除
     -->
    <!-- 默认缓存 -->
    <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            maxElementsOnDisk="10000000"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">

        <persistence strategy="localTempSwap" />
    </defaultCache>

    <!-- 自定义缓存 -->
    <cache name="userchache"
           eternal="false"
           timeToIdleSeconds="2400"
           timeToLiveSeconds="2400"
           maxEntriesLocalHeap="10000"
           maxEntriesLocalDisk="10000000"
           diskExpiryThreadIntervalSeconds="120"
           overflowToDisk="false"
           memoryStoreEvictionPolicy="LRU">
    </cache>
</ehcache>

3. RedisConfig配置文件

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
 
@Configuration
@PropertySource("classpath:redis.properties")
public class RedisConfig {
    private final Logger log = LoggerFactory.getLogger(this.getClass());
    
    @Value("${spring.redis.host}")
    private String host;
 
    @Value("${spring.redis.port}")
    private int port;
 
    @Value("${spring.redis.timeout}")
    private int timeout;
 
    @Value("${spring.redis.jedis.pool.max-idle}")
    private int maxIdle;
 
    @Value("${spring.redis.jedis.pool.max-wait}")
    private long maxWaitMillis;
 
    //@Value("${spring.redis.password}")
    //private String password;
    private String password;
    
    @Value("${spring.redis.block-when-exhausted}")
    private boolean  blockWhenExhausted;
 
    @Bean
    public JedisPool redisPoolFactory()  throws Exception{
        log.info("-------------JedisPool注入成功！！----------------");
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
        // 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true
        jedisPoolConfig.setBlockWhenExhausted(blockWhenExhausted);
        // 是否启用pool的jmx管理功能, 默认true
        jedisPoolConfig.setJmxEnabled(true);
        JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, password);
        
        return jedisPool;
    }
}

4. Redis工具类

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
@Component
public class RedisUtil{
    private final Logger log = LoggerFactory.getLogger(this.getClass());
    @Autowired
    private JedisPool jedisPool;
 
    
    public String get(String key) {
        Jedis jedis = null;
        String value = null;
        try {
            jedis = jedisPool.getResource();
            value = jedis.get(key);
            log.info(value);
        } catch (Exception e) {
 
            log.error(e.getMessage());
        } finally {
            returnResource(jedis);
        }
        return value;
    }    
    
    public String set(String key, String value) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.set(key, value);
        } catch (Exception e) {
 
            log.error(e.getMessage());
            return "0";
        } finally {
            returnResource(jedis);
        }
    }
    
    /**
     * 关闭连接
     */
    public static void returnResource(Jedis jedis) {
        try {
            jedis.close();
        } catch (Exception e) {
        }
    }
}    

5. 测试业务逻辑

import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import com.wulei.model.User;
import com.wulei.utils.RedisUtil;
@Service
// 指定ehcache缓存规则
@CacheConfig(cacheNames = "userchache")
public class UserService {
    @Autowired
    RedisUtil redisUtil;
    
    public List<User> testRedis() {
        redisUtil.set("name", "吴磊");
        System.out.println(redisUtil.get("name"));
        return this.getDataSource();
    }
    
    @Cacheable(key="'testEhcaheCacheable'")
    public List<User> testEhcaheCacheable(){
        // 只会查询一次
        System.out.println("Cacheable查询缓存数据");
        return this.getDataSource();
    }
    
    //键为"userId:"字符串加上userId值，如 'userId:1'
    @CacheEvict(key="'userId:' + #userId")
    public List<User> testEhcaheCacheEvict(int userId){
        // 每次请求都会删除指定key
        System.out.println("清除userchache中指定key的缓存");
        List<User> list = this.getDataSource();
        list.remove(userId-1);
        return list;
    }
    
    @CacheEvict(allEntries=true)  
    public List<User> testEhcaheCacheEvictAll(){
        // 每次请求都会删除所有key
        System.out.println("清除userchache中所有key的缓存");
        return new ArrayList<User>();
    }
    
    public List<User> getDataSource(){
        List<User> list = new ArrayList<User>();
        list.add(new User(1, "jay", 21));
        list.add(new User(2, "join", 22));
        list.add(new User(3, "eason", 23));
        list.add(new User(4, "jj", 24));
        return list;
    }
}

6. controller入口

@RestController
public class UserController {

    @Autowired
    private UserService userService;
    
    @RequestMapping("/testRedis")
    public List<User> testRedis() {
        return userService.testRedis();
    }
    @RequestMapping("/testEhcahe")
    public List<User> testEhcahe(int type){
        if(type==1) {
            return userService.testEhcaheCacheable();
        }else if(type==2) {
            return userService.testEhcaheCacheEvict(type);
        }else if(type==3) {
            return userService.testEhcaheCacheEvictAll();
        }
        return null;
    }
}

7. 主函数

@SpringBootApplication
@EnableCaching // 启用ehcache缓存注解
public class Application {

     private static Logger log = Logger.getLogger(Application.class);
     
     public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
            log.info("SpringBoot Start Success");
        }
}