Redis使用場景一，查詢出的數據保存到Redis中，下次查詢的時候直接從Redis中拿到數據。不用和數據庫進行交互。

maven使用：

<!--redis   jar包-->
    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-redis</artifactId>
      <version>1.6.2.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-ehcache</artifactId>
      <version>1.0.0</version>
    </dependency>

 

 

1：redis的連接信息

#訪問地址
redis.host=127.0.0.1
#訪問端口
redis.port=6379
#注意，如果沒有password，此處不設置值，但這一項要保留
redis.password=

#最大空閑數，數據庫連接的最大空閑時間。超過空閑時間，數據庫連接將被標記為不可用，然后被釋放。設為0表示無限制。
redis.maxIdle=300
#連接池的最大數據庫連接數。設為0表示無限制
redis.maxActive=600
#最大建立連接等待時間。如果超過此時間將接到異常。設為-1表示無限制。
redis.maxWait=1000
#在borrow一個jedis實例時，是否提前進行alidate操作；如果為true，則得到的jedis實例均是可用的；
redis.testOnBorrow=true

2：spring和redis的整合

<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:mvc="http://www.springframework.org/schema/mvc"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
      http://www.springframework.org/schema/util
      http://www.springframework.org/schema/util/spring-util-4.3.xsd
      http://www.springframework.org/schema/mvc
      http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd
      http://www.springframework.org/schema/aop
      http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
      http://www.springframework.org/schema/context
      http://www.springframework.org/schema/context/spring-context-4.3.xsd">


    <!-- 引入properties配置文件 -->
    <context:property-placeholder location="classpath:redis.properties" ignore-unresolvable="true"/>

    <!-- redis連接池 -->
    <bean id="jedisConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxTotal" value="${redis.maxActive}"></property>
        <property name="maxIdle" value="${redis.maxIdle}"></property>
        <property name="maxWaitMillis" value="${redis.maxWait}"></property>
        <property name="testOnBorrow" value="${redis.testOnBorrow}"></property>
    </bean>

    <!-- redis連接工廠 -->
    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="${redis.host}"></property>
        <property name="port" value="${redis.port}"></property>
        <property name="password" value="${redis.password}"></property>
        <property name="poolConfig" ref="jedisConfig"></property>
    </bean>
    <!-- redis操作模板，這里采用盡量面向對象的模板 -->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
        <property name="connectionFactory" ref="connectionFactory"/>
        <!--     如果不配置Serializer，那么存儲的時候只能使用String，如果用對象類型存儲，那么會提示錯誤 can't cast to String！！！-->
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
        </property>
        <!--開啟事務-->
        <property name="enableTransactionSupport" value="true"/>
    </bean>
</beans>

3：在業務代碼中使用

/**
     * 使用redis的緩存機制
     */
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 分頁查詢所有

     * @return
     */
    @Override
    public List<Goods> listGoods() {
        List<Goods> goods = goodsDao.listGoods();
        for(Goods goods1:goods){
            //把每一個goods對象保存到redis中的List中。
            redisTemplate.opsForList().rightPush("goodsList", goods1);
        }
        return goods;
    }

4：測試

@Test
    public void testListGoods(){
        List<Goods> goods = redisTemplate.opsForList().range(
                "goodsList", 0, -1);
        if(goods.size()==0){
            List<Goods> goods1 = goodsService.listGoods();
            for (Goods goods2:goods1){
                System.out.println(goods2);
            }
        }else {
           // System.out.println(goods);
            for(Goods goods1:goods){
                System.out.println(goods1);
            }
        }
    }

可以看到已經保存到redis的數據庫中了。

 

 5:編寫一個RedisTemplate的公用類

package com.betteryanwo.util;

import org.springframework.data.redis.core.*;

import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Create by 六
 * Date:18-7-16
 * RedisTemplate的公用類
 */
public class RedisTemplateUtil {

    private RedisTemplate redisTemplate;

    public RedisTemplateUtil(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }


    public void set(String key, Object value) {
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set(key, value);

        //BoundValueOperations的理解對保存的值做一些細微的操作
//        BoundValueOperations boundValueOperations = redisTemplate.boundValueOps(key);
    }

    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    public void setList(String key, List<?> value) {
        //Operation  操作。
        ListOperations listOperations = redisTemplate.opsForList();
        listOperations.leftPush(key, value);
    }

    public Object getList(String key) {
        return redisTemplate.opsForList().leftPop(key);
    }

    public void setSet(String key, Set<?> value) {
        SetOperations setOperations = redisTemplate.opsForSet();
        setOperations.add(key, value);
    }

    public Object getSet(String key) {
        return redisTemplate.opsForSet().members(key);
    }


    public void setHash(String key, Map<String, ?> value) {
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.putAll(key, value);
    }

    public Object getHash(String key) {
        return redisTemplate.opsForHash().entries(key);
    }


    public void delete(String key) {
        redisTemplate.delete(key);
    }

    public void clearAll() {
        redisTemplate.multi();
    }
}