#添加元素 //ex:秒级过期时间,nx:键不存在时才能设置成功,xx键存在时才能设置成功
set key value [ex seconds] [px milliseconds] [nx|xx]
# 获取元素 基于key
get key
# 批量设置值
mset key value key value
#批量获取值
mget key1 key2
#Redis Incr 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误
incr key
# edis Incrby 命令将 key 中储存的数字加上指定的增量值。
incrby key 30 
#Redis Decr 命令将 key 中储存的数字值减一
decr key
#Redis Decrby 命令将 key 所储存的值减去指定的减量值。
decrby key 20
#对值得追加
append key value
#获取字符串的长度
strlen key

 set it_user:userid:1:name  name_value

 set it_user:1 it_user的序列化
 #java实现
 //  定义键
userRedisKey = "it_user:" + id;
//  从 Redis 获取值
value = redis.get(userRedisKey);
if (value != null) {
    //  将值进行反序列化为 UserInfo 并返回结果
    userInfo = deserialize(value);
    return userInfo;
}

 incr命令
 #java实现
 long incrVideoCounter(long id) {
     key = "video:playCount:" + id;
     return redis.incr(key);
}	

#设置值
hset key field value
#获取值
hget key field
#删除field
hdel key field1 field2
#计算field的个数
hlen key
#批量设置
hmset key field1 value1 field2 value2 
hmget key field1 field2 
#判断field是否存在
hexists key field
#获取所有的field
hkeys key
#获取所有的values
hvals key

#从右边插入
rpush key value
#从左边插入
lpush key value
获取指定范围内的元素列表
lrange key start end
#获取列表中指定索引下表的元素
lindex key index
#获取列表的长度
llen key
#从左侧弹出
lpop key
#从右侧弹出
rpop key
#阻塞弹出
blpop key1 key2 timeout
brpop key1 key2 timeout

#添加元素
sadd key elements 
sadd key values1 values2
#删除元素
srem key elements
#计算元素的个数
scard key
#判断元素是否在集合中
simember key values
#随机从集合中返回指定个数元素
srandmember key count
#从集合中随机弹出元素
spop key
#列出所有的元素
smember key
#求元素的交接
sinter key1 key2
# 多个集合求并集
suinon key1 key2
# 多个集合的差集
sdiff key1 key2

#添加用户
zadd key score member
#计算成员个数
zcard key
#计算某一个成员的分数，
zscore key member
#列出成员的排名
zrank key member
zrevrank key member
#删除成员
zrem key member
#增加某个成员的分数
zincrby key increment member
#返回指定排名范围内成员
zrange key start end
zrevrange key start end （从高到低）
#返回指定分数范围内的成员个数
zcount key min max

config get dbfilename
config get dir

config get appendonly
config set appendonly yes
# 同步到配置文件 不用重启redis  AOF就可以直接生效
config rewrite

import redis.clients.jedis.Jedis;
public class RedisJava {
    public static void main(String[] args) {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        System.out.println("连接成功");
        //查看服务是否运行
        System.out.println("服务正在运行: "+jedis.ping());
    }
}

import redis.clients.jedis.Jedis;
public class RedisStringJava {
    public static void main(String[] args) {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        System.out.println("连接成功");
        //设置 redis 字符串数据
        jedis.set("runoobkey", "www.runoob.com");
        // 获取存储的数据并输出
        System.out.println("redis 存储的字符串为: "+ jedis.get("runoobkey"));
    }
}

import java.util.List;
import redis.clients.jedis.Jedis;
 
public class RedisListJava {
    public static void main(String[] args) {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        System.out.println("连接成功");
        //存储数据到列表中
        jedis.lpush("site-list", "Runoob");
        jedis.lpush("site-list", "Google");
        jedis.lpush("site-list", "Taobao");
        // 获取存储的数据并输出
        List<String> list = jedis.lrange("site-list", 0 ,2);
        for(int i=0; i<list.size(); i++) {
            System.out.println("列表项为: "+list.get(i));
        }
    }
}

public class RedisUtil {
    //服务器IP地址
    private static String ADDR = "ip";
    //端口
    private static int PORT = 6379;
    //密码
    private static String AUTH = "123456";
    //连接实例的最大连接数
    private static int MAX_ACTIVE = 1024;
    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
    private static int MAX_IDLE = 200;
    //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException
    private static int MAX_WAIT = 10000;
    //连接超时的时间　　
    private static int TIMEOUT = 10000;
    // 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
    private static boolean TEST_ON_BORROW = true;

    private static JedisPool jedisPool = null;
    //数据库模式是16个数据库 0~15 
    public static final int DEFAULT_DATABASE = 0;
    /**
     * 初始化Redis连接池
     */
    static {
        try {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(MAX_ACTIVE);
            config.setMaxIdle(MAX_IDLE);
            config.setMaxWaitMillis(MAX_WAIT);
            config.setTestOnBorrow(TEST_ON_BORROW);
            jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT,AUTH,DEFAULT_DATABASE);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 获取Jedis实例
     */
    public synchronized static Jedis getJedis() {
        try {
            if (jedisPool != null) {
                Jedis resource = jedisPool.getResource();
                System.out.println("redis--服务正在运行: "+resource.ping());
                return resource;
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    /***
     * 
     * 释放资源
     */
    public static void returnResource(final Jedis jedis) {
            if(jedis != null) {
                jedisPool.returnResource(jedis);
            }
    }
}

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.1.8.RELEASE</version>
</dependency>

#redis配置
#Redis服务器地址
spring.redis.host=127.0.0.1
#Redis服务器连接端口
spring.redis.port=6379
#Redis数据库索引（默认为0）
spring.redis.database=0  
#连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=50
#连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=3000
#连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=20
#连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=2
#连接超时时间（毫秒）
spring.redis.timeout=5000

package com.xcbeyond.springboot.redis;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class RedisUtils {
	@Autowired
	private RedisTemplate<String, String> redisTemplate;
	/**
	 * 读取缓存
	 * 
	 * @param key
	 * @return
	 */
	public String get(final String key) {
		return redisTemplate.opsForValue().get(key);
	}
	/**
	 * 写入缓存
	 */
	public boolean set(final String key, String value) {
		boolean result = false;
		try {
			redisTemplate.opsForValue().set(key, value);
			result = true;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
	/**
	 * 更新缓存
	 */
	public boolean getAndSet(final String key, String value) {
		boolean result = false;
		try {
			redisTemplate.opsForValue().getAndSet(key, value);
			result = true;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
	/**
	 * 删除缓存
	 */
	public boolean delete(final String key) {
		boolean result = false;
		try {
			redisTemplate.delete(key);
			result = true;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
}