redis的使用场景和配置环境

redis-liunx安装
https://zhuanlan.zhihu.com/p/527828627

@Autowired(required=false)
RedisUtil redisUtil;

(required=false)=====没有这个方法时返回不报错

redis是什么

redis是一个高性能的key-value数据库，它是完全开源免费的，而且redis是一个NOSQL类型数据库，是为了解决高并发、高扩展，大数据存储等一系列的问题而产生的数据库解决方案，是一个非关系型的数据库。但是，它也是不能替代关系型数据库，只能作为特定环境下的扩充。

redis是一个以key-value存储的数据库结构型服务器，它支持的数据结构类型包括：字符串（String）、链表（lists）、哈希表（hash）、集合（set）、有序集合（Zset）等。为了保证读取的效率，redis把数据对象都存储在内存当中，它可以支持周期性的把更新的数据写入磁盘文件中。而且它还提供了交集和并集，以及一些不同方式排序的操作。

redis的优势和特点：

1、redis数据读写速度非常快，因为它把数据都读取到内存当中操作，而且redis是用C语言编写的，是最“接近“”操作系统的语言，所以执行速度相对较快。

2、redis虽然数据的读取都存在内存当中，但是最终它是支持数据持久化到磁盘当中。

3、redis提供了丰富的数据结构。

4、redis的所有操作都是原子性，支持事务，所谓的原子性就是对数据的更改要么全部执行，要么全部不执行。

5、redis支持主从复制，主机会自动将数据同步到从机，可以进行读写分离。
redis的应用场景：
1、redis由于数据的读取和操作都在内存当中操作，读写的效率较高，所以经常被用来做数据的缓存。把一些需要频繁访问的数据，而且在短时间之内不会发生变化的，放入redis中进行操作。从而提高用户的请求速度和降低网站的负载，降低数据库的读写次数，就把这些数据放到缓存中。

2、一些常用的实时计算的功能。需要实时变化和展示的功能，就可以把相关数据放在redis中进行操作。大大提高效率。

3、消息队列，经常用来构建类似实时聊天系统的功能，大大提高应用的可用性。

在applicationContext.xml中配置

<!-- 引入配置文件 -->
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:config.properties</value>
                <value>classpath:redis.properties</value>
            </list>
        </property>
    </bean>



//最底下
<import resource="classpath*:redis.xml" />

    <bean id="redisUtil" class="com.aspire.util.RedisUtil" />

还需在resou’rces中添加以下一个文件
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"
       xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
   ">
    
    
    <!-- redis连接池配置-->    
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig" >    
        <!--最大空闲数-->    
        <property name="maxIdle" value="${redis.maxIdle}" />    
        <!--连接池的最大数据库连接数  -->  
        <property name="maxTotal" value="${redis.maxTotal}" />  
        <!--最大建立连接等待时间-->    
        <property name="maxWaitMillis" value="${redis.maxWaitMillis}" />    
        <!--逐出连接的最小空闲时间 默认1800000毫秒(30分钟)-->  
        <property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}" />   
        <!--每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3-->  
        <property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}" />   
        <!--逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1-->  
        <property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}" />   
        <!--是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个-->    
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />    
        <!--在空闲时检查有效性, 默认false  -->  
        <property name="testWhileIdle" value="${redis.testWhileIdle}" />    
    </bean >  
      

    <bean id = "jedisPool" class="redis.clients.jedis.JedisPool">
        <constructor-arg index="0" ref="jedisPoolConfig"/>
        <constructor-arg index="1" value="${redis.hostName}" type="java.lang.String"/>
        <constructor-arg index="2" value="${redis.port}" type="int"/>
        <constructor-arg index="3" value="${redis.timeout}" type="int"/>
        <constructor-arg index="4" value="${redis.password}" type="java.lang.String"/>
    </bean>



</beans>

配置redis环境

接下来因为短信服务运用到redis缓存技术，所以在做短信服务之前要先把redis环境给配置起来。因为本人也是刚开始跳入这个行业的坑，我把我配置的环境给大家展示出来，做得多就容易记得。
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"
       xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
   ">
    
    
    <!-- redis连接池配置-->    
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig" >    
        <!--最大空闲数-->    
        <property name="maxIdle" value="50" />
        <!--连接池的最大数据库连接数  -->  
        <property name="maxTotal" value="${redis.maxTotal}" />  
        <!--最大建立连接等待时间-->    
        <property name="maxWaitMillis" value="${redis.maxWaitMillis}" />    
        <!--逐出连接的最小空闲时间 默认1800000毫秒(30分钟)-->  
        <property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}" />   
        <!--每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3-->  
        <property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}" />   
        <!--逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1-->  
        <property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}" />   
        <!--是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个-->    
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />    
        <!--在空闲时检查有效性, 默认false  -->  
        <property name="testWhileIdle" value="${redis.testWhileIdle}" />    
    </bean >  
      

    <bean id = "jedisPool" class="redis.clients.jedis.JedisPool">
        <constructor-arg index="0" ref="jedisPoolConfig"/>
        <constructor-arg index="1" value="${redis.hostName}" type="java.lang.String"/>
        <constructor-arg index="2" value="${redis.port}" type="int"/>
        <constructor-arg index="3" value="${redis.timeout}" type="int"/>
        <constructor-arg index="4" value="${redis.password}" type="java.lang.String"/>
    </bean>



</beans>

redis.properties

#ip\u5730\u5740  
#redis.hostName=47.107.150.185
redis.hostName=127.0.0.1
#\u7AEF\u53E3\u53F7 //18472
redis.port=  redis端口号
#\u5982\u679C\u6709\u5BC6\u7801
redis.password=  redis密码
#\u5BA2\u6237\u7AEF\u8D85\u65F6\u65F6\u95F4\u5355\u4F4D\u662F\u6BEB\u79D2 \u9ED8\u8BA4\u662F2000
redis.timeout=10000
  
  
#\u6700\u5927\u7A7A\u95F2\u6570 
redis.maxIdle=50
#\u8FDE\u63A5\u6C60\u7684\u6700\u5927\u6570\u636E\u5E93\u8FDE\u63A5\u6570\u3002\u8BBE\u4E3A0\u8868\u793A\u65E0\u9650\u5236,\u5982\u679C\u662Fjedis 2.4\u4EE5\u540E\u7528redis.maxTotal  
#redis.maxActive=600  
#\u63A7\u5236\u4E00\u4E2Apool\u53EF\u5206\u914D\u591A\u5C11\u4E2Ajedis\u5B9E\u4F8B,\u7528\u6765\u66FF\u6362\u4E0A\u9762\u7684redis.maxActive,\u5982\u679C\u662Fjedis 2.4\u4EE5\u540E\u7528\u8BE5\u5C5E\u6027  
redis.maxTotal=200
#\u6700\u5927\u5EFA\u7ACB\u8FDE\u63A5\u7B49\u5F85\u65F6\u95F4\u3002\u5982\u679C\u8D85\u8FC7\u6B64\u65F6\u95F4\u5C06\u63A5\u5230\u5F02\u5E38\u3002\u8BBE\u4E3A-1\u8868\u793A\u65E0\u9650\u5236\u3002  
redis.maxWaitMillis=5000
#\u8FDE\u63A5\u7684\u6700\u5C0F\u7A7A\u95F2\u65F6\u95F4 \u9ED8\u8BA41800000\u6BEB\u79D2(30\u5206\u949F)  
redis.minEvictableIdleTimeMillis=300000
#\u6BCF\u6B21\u91CA\u653E\u8FDE\u63A5\u7684\u6700\u5927\u6570\u76EE,\u9ED8\u8BA43  
redis.numTestsPerEvictionRun=1024
#\u9010\u51FA\u626B\u63CF\u7684\u65F6\u95F4\u95F4\u9694(\u6BEB\u79D2) \u5982\u679C\u4E3A\u8D1F\u6570,\u5219\u4E0D\u8FD0\u884C\u9010\u51FA\u7EBF\u7A0B, \u9ED8\u8BA4-1  
redis.timeBetweenEvictionRunsMillis=30000
#\u662F\u5426\u5728\u4ECE\u6C60\u4E2D\u53D6\u51FA\u8FDE\u63A5\u524D\u8FDB\u884C\u68C0\u9A8C,\u5982\u679C\u68C0\u9A8C\u5931\u8D25,\u5219\u4ECE\u6C60\u4E2D\u53BB\u9664\u8FDE\u63A5\u5E76\u5C1D\u8BD5\u53D6\u51FA\u53E6\u4E00\u4E2A  
redis.testOnBorrow=true
#\u5728\u7A7A\u95F2\u65F6\u68C0\u67E5\u6709\u6548\u6027, \u9ED8\u8BA4false
redis.testWhileIdle=true
  

操作redis的工具类 RedisUtil

package com.aspire.util;

import org.springframework.beans.factory.annotation.Autowired;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

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


/**
 * 操作redis的工具类
 */

//@Component
public class RedisUtil {
    @Autowired
    private JedisPool jedisPool;

    /**
     * 获取redis实例
     * @return
     */
    private Jedis getJedis(){
        try {
            if (jedisPool != null) {
                Jedis jedis = jedisPool.getResource();
                return jedis;
            }
            else {
                return null;
            }
        }
        catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }



    /**
     * 释放redis资源
     * @param jedis
     */
    public void releaseResource(final Jedis jedis){
        if (jedis != null) {
            jedis.close();
        }
    }

    /**
     * 根据key去redis里面获取对应的value，获取完毕之后释放资源
     * @param key
     * @return
     */
    public String get(String key) {
        Jedis jedis = null;
        String value = null;
        try {
            jedis = getJedis();
            value = jedis.get(key);
        }
        finally {
            releaseResource(jedis);
        }
        return value;
    }

    /**
     * 存入键值对，释放资源
     * @param key
     * @param value
     * @return
     */
    public String set(String key, String value){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.set(key, value);
        }
        finally {
            releaseResource(jedis);
        }
    }
    public String set(String key, String value,int times){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            String result = jedis.set(key, value);
                jedis.expire(key,times);

            return result;
        }
        finally {
            releaseResource(jedis);
        }
    }
    public String set(String key, Object value,int times){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            String result = jedis.set(key, value.toString());
                jedis.expire(key,times);

            return result;
        }
        finally {
            releaseResource(jedis);
        }
    }

    /**
     * 移除set中指定元素
     */
    public void zrem(String key, String value){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.zrem(key, value);
        }finally {
            releaseResource(jedis);
        }
    }
    /**
     * 获取集合set大小
     */
    public Long zcard(String key){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.zcard(key);
        }finally {
            releaseResource(jedis);
        }
    }
    /**
     * 返回集合元素
     * @param start 开始元素位置 0表示第一个
     * @param stop 结束元素位置 -1表示最后一个
     */
    public Set<String> zrange(String key, long start, long stop){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.zrange(key, start, stop);
        }finally {
            releaseResource(jedis);
        }
    }
    /**
     * 返回集合中指定元素的排名 即下标
     */
    public Long zrank(String key, String value){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.zrank(key, value);
        }finally {
            releaseResource(jedis);
        }
    }



    /**
     * 删除指定的key，可以是一组key
     * @param keys
     * @return 返回删除成功的个数
     */
    public Long del(String... keys){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.del(keys);
        }
        finally {
            releaseResource(jedis);
        }
    }


    /**
     * 移除set集合指定的元素，可以是一组key
     * @param keys
     * @return 返回删除成功的个数
     */
    public Long srem(String keys,String...members){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.srem(keys,members);
        }
        finally {
            releaseResource(jedis);
        }
    }

    /**
     * 通过key向指定的value值追加值
     * @param key
     * @param str
     * @return 成功返回 添加后value的长度 失败 返回 添加的 value 的长度 异常返回0L
     */
    public Long append(String key, String str) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = getJedis();
            res = jedis.append(key, str);
        }
        finally {
            releaseResource(jedis);
        }
        return res;
    }

    /**
     * 判断key是否存在
     * @param key
     * @return
     */
    public Boolean exists(String key) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.exists(key);
        }
        finally {
            releaseResource(jedis);
        }
    }
    /**
     * 判断key是否存在
     * @param key
     * @return
     */
    public Boolean hasKey(String key) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.exists(key);
        }
        finally {
            releaseResource(jedis);
        }
    }

    /**
     * 通过key同时设置 hash的多个field
     * @param key
     * @param hash
     * @return 返回OK 异常返回null
     */
    public String hmset(String key, Map<String, String> hash) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = getJedis();
            res = jedis.hmset(key, hash);
        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            releaseResource(jedis);
        }
        return res;
    }



    /**
     * 通过key 和 field 获取指定的 value
     * @param key
     * @param field
     * @return
     */
    public String hget(String key, String field) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = getJedis();
            res = jedis.hget(key, field);
        }
        finally {
            releaseResource(jedis);
        }
        return res;
    }

    /**
     * 通过批量的key获取批量的value
     * @param keys
     * @return
     */
    public List<String> mget(String... keys) {
        Jedis jedis = null;
        List<String> values = null;
        try {
            jedis = getJedis();
            values = jedis.mget(keys);
        }
        finally {
            releaseResource(jedis);
        }
        return values;
    }

    /**
     * 批量的设置key:value,可以一个,
     * @param keysvalues new String[]{"key2","value1","key2","value2"}
     * @return
     */
    public String mset(String... keysvalues) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = getJedis();
            res = jedis.mset(keysvalues);
        }
        finally {
            releaseResource(jedis);
        }
        return res;
    }

    /**
     * 设置key的过期时间
     * @param key
     * @param times
     * @return
     */
    public long expire(String key, int times){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.expire(key, times);
        }
        finally {
            releaseResource(jedis);
        }
    }

    /**
     * 通过key给field设置指定的值,如果key不存在,则先创建
     * @param key
     * @param field
     * @param value
     * @return
     */
    public Long hset(String key, String field, String value) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = getJedis();
            res = jedis.hset(key, field, value);
        }
        finally {
            releaseResource(jedis);
        }
        return res;
    }

    /**
     * 通过key 和 fields 获取指定的value,value是一个列表
     * @param key
     * @param fields
     * @return
     */
    public List<String> hmget(String key, String... fields) {
        Jedis jedis = null;
        List<String> res = null;
        try {
            jedis = getJedis();
            res = jedis.hmget(key, fields);
        }
        finally {
            releaseResource(jedis);
        }
        return res;
    }

    /**
     * 通过key返回所有和key有关的value
     * @param key
     * @return
     */
    public List<String> hvals(String key) {
        Jedis jedis = null;
        List<String> res = null;
        try {
            jedis = getJedis();
            res = jedis.hvals(key);
        }
        finally {
            releaseResource(jedis);
        }
        return res;
    }

    /**
     * 通过key返回所有的field
     * @param key
     * @return
     */
    public Set<String> hkeys(String key) {
        Jedis jedis = null;
        Set<String> res = null;
        try {
            jedis = getJedis();
            res = jedis.hkeys(key);
        }
        finally {
            releaseResource(jedis);
        }
        return res;
    }

    /**
     * 通过key获取所有的field和value
     * @param key
     * @return
     */
    public Map<String, String> hgetAll(String key) {
        Jedis jedis = null;
        Map<String, String> res = null;
        try {
            jedis = getJedis();
            res = jedis.hgetAll(key);
        }
        finally {
            releaseResource(jedis);
        }
        return res;
    }

    /**
     * 通过key向list头部添加字符串
     * @param key
     * @param strs
     * @return
     */
    public Long lpush(String key, String... strs) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = getJedis();
            res = jedis.lpush(key, strs);
        }
        finally {
            releaseResource(jedis);
        }
        return res;
    }

    /**
     * 通过key向list尾部添加字符串
     * @param key
     * @param strs
     * @return
     */
    public Long rpush(String key, String... strs) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = getJedis();
            res = jedis.rpush(key, strs);
        }
        finally {
            releaseResource(jedis);
        }
        return res;
    }

    /**
     * 通过key设置list指定下标位置的value
     * @param key
     * @param index
     * @param value
     * @return
     */
    public String lset(String key, Long index, String value) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = getJedis();
            res = jedis.lset(key, index, value);
        }
        finally {
            releaseResource(jedis);
        }
        return res;
    }

    public void sadd(String key,String val){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.sadd(key,val);
        }
        finally {
            releaseResource(jedis);
        }
    }

    public String spop(String key){
        Jedis jedis = null;
        String result=null;
        try {
            jedis = getJedis();
            result= jedis.spop(key);
        }
        finally {
            releaseResource(jedis);
        }
        return result;
    }


    public long scard(String key){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.scard(key);
        }
        finally {
            releaseResource(jedis);
        }
    }



//    public static void main(String[] args) {
//        Jedis redis = new Jedis("127.0.0.1", 6379, 400000);
//        Pipeline p = redis.pipelined();
//
//    }
}

最后还得在applicationContext.xml中引入配置文件

<!-- 引入配置文件 -->
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:config.properties</value>
                <value>classpath:redis.properties</value>
            </list>
        </property>
    </bean>```


//这个放在最后
    <import resource="classpath*:redis.xml" />

    <bean id="redisUtil" class="com.aspire.util.RedisUtil" />