spring-data-redis的使用/redis缓存

1.导入依赖

<properties>
        <junit.version>4.12</junit.version>
        <spring.version>4.2.4.RELEASE</spring.version>
    </properties>

    <dependencies>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.9</version>
        </dependency>
        <!--Redis依赖-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.8.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.7.2.RELEASE</version>
        </dependency>
    </dependencies>

2.在resources文件夹下添加配置文件

redis-config.properties

redis.host=192.168.200.128
redis.port=6379
#redis有验证添加，无验证不添加
redis.pass=
redis.database=0
redis.maxIdle=300
redis.maxWait=3000
redis.testOnBorrow=true

applicationContext-redis.xml

<?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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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/context
            http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/mvc
            http://www.springframework.org/schema/mvc/spring-mvc.xsd
            http://www.springframework.org/schema/cache
            http://www.springframework.org/schema/cache/spring-cache.xsd">

    <context:property-placeholder location="classpath*:redis-config.properties" />

    <!-- redis 相关配置 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}" />
        <property name="maxWaitMillis" value="${redis.maxWait}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean>

    <bean id="JedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
          p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}" p:pool-config-ref="poolConfig"/>

    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="JedisConnectionFactory" />
    </bean>

</beans>

3.测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:/spring/applicationContext-redis.xml")
public class RedisTest {
    @Autowired
    private RedisTemplate redisTemplate;

    //1.redis简单数据类型
    @Test
    public void test01(){

        redisTemplate.opsForValue().set("key1", "华为");                  //向redis中添加数据
        String key1 = (String) redisTemplate.opsForValue().get("key1");    //获取redis中的数据
        System.out.println(key1);

        redisTemplate.delete("key1");                           //删除redis中的数据
        Object key2 = redisTemplate.opsForValue().get("key1");       //获取redis中的数据
        System.out.println(key2);                                      //若redis中无对应的值，则返回null
    }
    //2.redis值类型操作
    @Test
    public void test02(){
        redisTemplate.boundValueOps("key").set("spring-data-redis");        //向redis中添加数据
        Object key = redisTemplate.boundValueOps("key").get();          //获取redis中的数据
        System.out.println(key);

        redisTemplate.delete("key");                                //删除redis中的数据
        Object key1 = redisTemplate.boundValueOps("key").get();     //获取redis中的数据
        System.out.println(key1);                                          //若redis中无对应的值，则返回null
    }

    //3.redis Set类型操作
    @Test
    public void test03(){
        redisTemplate.boundSetOps("set").add("华为");
        redisTemplate.boundSetOps("set").add("苹果");
        redisTemplate.boundSetOps("set").add("三星");
        redisTemplate.boundSetOps("set").add("小米");
        redisTemplate.boundSetOps("set").add("vivo");
        redisTemplate.boundSetOps("set").add("魅族");

        Set set = redisTemplate.boundSetOps("set").members();
        System.out.println(set);

        //redisTemplate.boundSetOps("set").remove("魅族");
        redisTemplate.delete("set");
        Set set1 = redisTemplate.boundSetOps("set").members();
        System.out.println(set1);
    }
    //4.redis List类型操作
    @Test
    public void test04(){
        redisTemplate.boundListOps("list").leftPush("a");           //从左边添加数据
        redisTemplate.boundListOps("list").leftPush("b");
        redisTemplate.boundListOps("list").leftPush("c");
        redisTemplate.boundListOps("list").rightPush("1");          //从右边添加数据
        redisTemplate.boundListOps("list").rightPush("2");
        redisTemplate.boundListOps("list").rightPush("3");

        List list = redisTemplate.boundListOps("list").range(0, -1);
        System.out.println(list);

        redisTemplate.delete("list");
        List list1 = redisTemplate.boundListOps("list").range(0, -1);
        System.out.println(list1);

    }
    //5.Hash类型操作
    @Test
    public void test05(){
        redisTemplate.boundHashOps("hash").put("name", "张三");
        redisTemplate.boundHashOps("hash").put("sex", "男");
        redisTemplate.boundHashOps("hash").put("age", "18");

        Map map = redisTemplate.boundHashOps("hash").entries();
        for (Object key : map.keySet()) {
            System.out.println(key +" : " + map.get(key) );
        }
        redisTemplate.boundHashOps("hash").delete("sex");
        Map map1 = redisTemplate.boundHashOps("hash").entries();
        for (Object o : map1.entrySet()) {
            Map.Entry entry = (Map.Entry) o;
            System.out.println(entry.getKey()+":"+entry.getValue());
        }

    }
}

4.项目中的使用

先从redis中查询数据，若为null，则表示redis中无数据，然后从mysql数据库中查找数据，再将数据存入redis缓存中。数据库进行增删改操作之后都要清除redis缓存，以防数据不一致。

public class ContentServiceImpl implements ContentService {
    @Autowired
    private ContentMapper contentMapper;
    @Autowired
    private RedisTemplate redisTemplate;
    @Override
    public void insert(Content content) {       //redis缓存
        contentMapper.insertSelective(content);
        //清楚缓存
        redisTemplate.boundHashOps(RedisConst.CONTENT).delete(content.getCategoryId());
    }

    @Override
    public void delete(Long[] ids) {
        //清空缓存
        for (Long id : ids) {
            Long categoryId = contentMapper.selectByPrimaryKey(id).getCategoryId();
            redisTemplate.boundHashOps(RedisConst.CONTENT).delete(categoryId);
        }

        //从数据库删除记录
        List<Long> list = Arrays.asList(ids);
        ContentExample example = new ContentExample();
        example.createCriteria().andIdIn(list);
        contentMapper.deleteByExample(example);
    }

    @Override
    public void update(Content content) {
        //查询修改前的分类id
        Long oldCategoryId = contentMapper.selectByPrimaryKey(content.getId()).getCategoryId();
        redisTemplate.boundHashOps(RedisConst.CONTENT).delete(oldCategoryId);       //清除缓存
        contentMapper.updateByPrimaryKeySelective(content);

        //如果修改后的分类id发生修改，清除修改后的分类id的缓存
        if(oldCategoryId.longValue() != content.getCategoryId().longValue()){
            redisTemplate.boundHashOps(RedisConst.CONTENT).delete(content.getCategoryId());
        }
    }
    //根据广告分类id查询广告列表
    @Override
    public List<Content> findByCategoryId(long categoryId) {        //redis缓存机制
        //1.从redis中取数据
        List<Content> contents = (List<Content>) redisTemplate.boundHashOps(RedisConst.CONTENT).get(categoryId);
        //2.判断redis中是否有数据
        if(contents == null){
            //3.从mysql数据库中查找数据
            ContentExample example = new ContentExample();
            ContentExample.Criteria criteria = example.createCriteria();
            criteria.andCategoryIdEqualTo(categoryId);
            criteria.andStatusEqualTo("1");//开启状态
            example.setOrderByClause("sort_order");
            contents = contentMapper.selectByExample(example);
            //4.将查询到的数据库保存到Redis数据库中
            redisTemplate.boundHashOps(RedisConst.CONTENT).put(categoryId, contents);
        }
        return contents;
    }

}