redis 在spring中的使用(配置与使用)

redis 在spring中的使用

1. redis配置

安装地址： 点击官网下载

1、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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">
    <!--设置jedisPool链接池的配置-->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxTotal" value="${redis.maxTotal}"/>
        <property name="maxIdle" value="${redis.maxIdle}"/>
        <property name="minIdle" value="${redis.minIdle}"></property>
        <property name="maxWaitMillis" value="${redis.maxWait}"/>
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
    </bean>
    <!--密码对象-->
    <bean id="password" class="org.springframework.data.redis.connection.RedisPassword">
        <constructor-arg name="thePassword" value="${redis.password}"></constructor-arg>
    </bean>

    <!--spring-data-redis2.0以上的配置-->
    <bean id="redisStandaloneConfiguration" class="org.springframework.data.redis.connection.RedisStandaloneConfiguration">
        <property name="hostName" value="${redis.host}"/>
        <property name="port" value="${redis.port}"/>
        <property name="password" ref="password" />
        <property name="database" value="0"/> // redis有16个数据库，默认选择0
    </bean>
    <!-- redis连接 spring-data-redis2.0以上建议获取的方式-->
    <bean id="connectionFactory"
          class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <constructor-arg name="standaloneConfig" ref="redisStandaloneConfiguration"></constructor-arg>
    </bean>
    <!--
        Spring 封装了 RedisTemplate 来操作 Redis，它支持所有的 Redis 原生的 API。
        在 RedisTemplate 中定义了对5种数据结构的操作方法。

        opsForValue()：操作字符串。
        opsForList()：操作列表。
        opsForHash()：操作哈希。
        opsForSet()：操作集合。
        opsForZSet()：操作有序集合。
    -->

</beans>

2、依赖

     <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>2.4.1</version>
        </dependency>
        <!-- java redis 客户端 -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.3.0</version>
        </dependency>

3.关联redis配置

4.properties配置

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/db0926
jdbc.username=root
jdbc.password=lzq123

#连接端口
redis.port=6379
#连接地址
redis.host=127.0.0.1
#超时时间：单位ms
redis.timeout=3000
#授权密码
redis.password=
#最大连接数：能够同时建立的“最大链接个数”
redis.maxTotal=200
#最大空闲数：空闲链接数大于maxIdle时，将进行回收
redis.maxIdle=20
#最小空闲数：低于minIdle时，将创建新的链接
redis.minIdle=5
#最大等待时间：单位ms
redis.maxWait=3000
#使用连接时，检测连接是否成功
redis.testOnBorrow=true

5.序列化器配置 (redis-config)

package com.zking.config;

@Configuration // 等同xml文件
public class RedisConfig {
    /**
     * 等同xml中的bean标签
     * 如果要指定组件在容器中的id： @Bean（id）
     * RedisTemplate   可以自定义存储的序列化器类型
     * StringRedisTemplate  只能存储String类型的数据
     *
     */
//    @Bean("rt")
    @Bean
    public RedisTemplate<String ,Object> redisTemplate(JedisConnectionFactory jcf) {
        RedisTemplate<String ,Object>  redis = new RedisTemplate<>();
//        设置连接对象
        redis.setConnectionFactory(jcf);
//        1.jdk序列化器，必须实现序列化接口，可读性差
        JdkSerializationRedisSerializer jdk = new JdkSerializationRedisSerializer();
//        2. String序列化器，存储数据必须是String数据类型
        StringRedisSerializer string = new StringRedisSerializer();
        // 3.GenericJackson2Json 不需要实现序列化 可以存储任意对象 自动转换
        GenericJackson2JsonRedisSerializer gjj = new GenericJackson2JsonRedisSerializer();

//        设置String 数据类型和hash数据类型的key和value使用那儿种序列化器
        redis.setKeySerializer(string);
        redis.setValueSerializer(gjj);
        redis.setHashKeySerializer(string);
        redis.setHashValueSerializer(gjj);

        return redis;
    }
}

2.redis测试

开启redis服务，在bin文件中，双击 redis服务端.bat ，是一个bat文件打开试试就知道了

安装redis图形化界面, 现在要钱，在码云上找到一个免费版本，需要的自行下载

AnotherRedisDesktopManager下载地址

1.运行代码，将数据存入redis

 // 注入redis通用工具类

    @Autowired
    RedisTemplate redisTemplate;

	@Test
    public void 存储redis2() {
        Emp emp = em.selectByPrimaryKey(9507);
        List<Emp> list = em.selectAll();
        redisTemplate.opsForValue().set("emp:9507", emp);
        redisTemplate.opsForValue().set("emps", list);
    }

运行结果

• 可以看到，将查询结果存储在redis缓存中

2.运行代码，将数据从redis中取出

      @Autowired
    RedisTemplate redisTemplate;
	
	@Test
    public void 取出redis() {
        Emp e = (Emp) redisTemplate.opsForValue().get("emp:9507");
        System.out.println(e);
        System.out.println("----------");

        List<Emp> list = (List<Emp>) redisTemplate.opsForValue().get("emps");
        list.forEach(System.out::println);
    }

3.配置自定义的工具类

• 通过redisTemplate 进行自定方法，调用方法方便，提高效率
• RedisUtil

package com.zking.util;
@Component
public class RedisUtil {

    @Autowired
    RedisTemplate<String,Object> redisTemplate;

    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key,long time){
        try {
            if(time>0){
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    public void del(String ... key){
        if(key!=null&&key.length>0){
            if(key.length==1){
                redisTemplate.delete(key[0]);
            }else{
                redisTemplate.delete(Arrays.asList(key));
            }
        }
    }

    /**
     * 获取缓存
     * @param key 键
     * @return 值
     */
    public Object get(String key){
        return key==null?null:redisTemplate.opsForValue().get(key);
    }

    /**
     * 添加缓存
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key,Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 添加缓存并设置过期时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key,Object value,long time){
        try {
            if(time>0){
                redisTemplate.opsForValue().
                        set(key, value, time, TimeUnit.SECONDS);
            }else{
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashGet
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key,String item){
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object,Object> hmget(String key){
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String,Object> map){
        try {
            redisTemplate.opsForHash().
                    putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /*
    * 有序结合Sorted Set(Zset)
    * */
//    *如果元素存在会替换分数
    public boolean zSet(String key, double score, Object item) {
         return  redisTemplate.opsForZSet().add(key, item, score);
    }
//    按照对象删除
    public boolean zRemove(String key,String ... item) {
       return redisTemplate.opsForZSet().remove(key,item)>0;
    }
//    按照下标删除
public Long zRemoveIndex(String key,int index) {
    return redisTemplate.opsForZSet().removeRange(key,index,index);
}

//    获取
    public Set zGet(String key, int begin , int end) {
        return redisTemplate.opsForZSet().reverseRange(key, begin, end);
    }
//    为指定元素加分数
    public double zIncr(String key, double score, Object item) {
        double s= 0;
        try {
            s= redisTemplate.opsForZSet().incrementScore(key,item,score);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return  s;
    }

//    根据对象查询suoyin
    public Long zGetINdex(String key, Object item) {
        return redisTemplate.opsForZSet().rank(key,item);
    }
//    根据对象查询分数
    public Double zGetScore(String key , Object item) {
        return  redisTemplate.opsForZSet().score(key,item);
    }

    /**
     * 添加一个元素, zset与set最大的区别就是每个元素都有一个score，因此有个排序的辅助功能;  zadd
     *
     * @param key
     * @param value
     * @param score
     */
    public void add(String key, String value, double score) {
        redisTemplate.opsForZSet().add(key, value, score);
    }

    /**
     * 删除元素 zrem
     *
     * @param key
     * @param value
     */
    public void remove(String key, String value) {
        redisTemplate.opsForZSet().remove(key, value);
    }

    /**
     * score的增加or减少 zincrby
     *
     * @param key
     * @param value
     * @param score
     */
    public Double incrScore(String key, String value, double score) {
        return redisTemplate.opsForZSet().incrementScore(key, value, score);
    }

    /**
     * 查询value对应的score   zscore
     *
     * @param key
     * @param value
     * @return
     */
    public Double score(String key, String value) {
        return redisTemplate.opsForZSet().score(key, value);
    }

    /**
     * 判断value在zset中的排名  zrank
     *
     * 积分小的在前面
     *
     * @param key
     * @param value
     * @return
     */
    public Long rank(String key, String value) {
        return redisTemplate.opsForZSet().rank(key, value);
    }

    /**
     * 查询集合中指定顺序的值， 0 -1 表示获取全部的集合内容  zrange
     *
     * 返回有序的集合，score小的在前面
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<Object> range(String key, long start, long end) {
        return redisTemplate.opsForZSet().range(key, start, end);
    }

    /**
     * 查询集合中指定顺序的值和score，0, -1 表示获取全部的集合内容
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<ZSetOperations.TypedTuple<Object>> rangeWithScore(String key, long start, long end) {
        return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
    }

    /**
     * 查询集合中指定顺序的值  zrevrange
     *
     * 返回有序的集合中，score大的在前面
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<Object> revRange(String key, long start, long end) {
        return redisTemplate.opsForZSet().reverseRange(key, start, end);
    }

    /**
     * 根据score的值，来获取满足条件的集合  zrangebyscore
     *
     * @param key
     * @param min
     * @param max
     * @return
     */
    public Set<Object> sortRange(String key, long min, long max) {
        return redisTemplate.opsForZSet().rangeByScore(key, min, max);
    }

    /**
     * 返回集合的长度
     *
     * @param key
     * @return
     */
    public Long size(String key) {
        return redisTemplate.opsForZSet().zCard(key);
    }

}