redis程序客户端操作

java

jedis

maven依赖

 <dependency>
     <groupId>redis.clients</groupId>
     <artifactId>jedis</artifactId>
     <version>3.6.3</version>
</dependency>

简单操作

第一个超简单的程序

public class RedisOpt {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.connect();

        // -- 字符串操作 ----
        System.out.println("-- 字符串操作 ----");
        jedis.set("count", "1");
        // 自增
        jedis.incr("count");
        System.out.println(jedis.get("count"));
        // setnx 命令
        if(jedis.setnx("count","100") > 0){
            System.out.println("setnx:count >>> " + jedis.get("count"));
        } else {
            System.out.println("key:count >>> redis中已经存在");
        }

        //  ---- hash ----
        System.out.println("-- hash操作 ----");
        jedis.hset("user", "name", "非鸽传书");
        jedis.hset("user", "wish", "每天进步一点点");
        jedis.hset("user", "maxim", "坚持是一种品格");
        jedis.hset("user", "age", "18");
        //输出结果 : {f1=v1, f2=v2}
        System.out.println(jedis.hgetAll("user"));
        jedis.hincrBy("user", "age", 2);
        // jedis.hsetnx(...) 和字符串的setnx命令类似，
        System.out.println("after incr >>> " + jedis.hgetAll("user"));

        // ---- set -----
        System.out.println("-- set操作 ----");
        jedis.sadd("mafei", "出城剿匪");
        jedis.sadd("mafei", "公平");
        jedis.sadd("mafei", "公平");
        jedis.sadd("mafei", "还是公平");
        System.out.println(jedis.smembers("mafei"));

        jedis.sadd("shiye", "出城剿匪");
        jedis.sadd("shiye", "吃着火锅");
        jedis.sadd("shiye", "唱着歌");
        jedis.sadd("shiye", "忽然被马匪给劫~了");
        System.out.println(jedis.smembers("shiye"));

        System.out.println("交集 >>> " + jedis.sinter("mafei","shiye"));
        System.out.println("差集 >>> " + jedis.sdiff("mafei","shiye"));
        System.out.println("并集 >>> " + jedis.sunion("mafei","shiye"));

        // ---- zset -----
        System.out.println("-- zset操作 ----");
        jedis.zadd("meals", 5, "breakfast");
        jedis.zadd("meals", 20, "lunch");
        jedis.zadd("meals", 18, "supper");

        // 正序
        System.out.println(jedis.zrangeWithScores("meals", 0, -1));
        // 倒序
        System.out.println(jedis.zrevrangeWithScores("meals", 0, -1));

// ---- list ----
        System.out.println("-- list操作 ----");
        jedis.del("reqList");
        jedis.rpush("reqList", "再次暗示：");
        jedis.rpush("reqList", "点赞、");
        jedis.rpush("reqList", "关注");

        jedis.del("please");
        jedis.rpush("please", "连续暗示：");
        jedis.rpush("please", "收藏、");
        jedis.rpush("please", "评论");

        List<String> reqList = jedis.lrange("reqList", 0, -1);
        reqList.forEach(s -> System.out.print(s));
        System.out.println();
        List<String> please = jedis.lrange("please", 0, -1);
        please.forEach(s -> System.out.print(s));

        jedis.close();
    }
}
// 输出结果
-- 字符串操作 ----
2
key:count >>> redis中已经存在
-- hash操作 ----
{name=非鸽传书, wish=每天进步一点点, maxim=坚持是一种品格, age=18}
after incr >>> {name=非鸽传书, wish=每天进步一点点, maxim=坚持是一种品格, age=20}
-- set操作 ----
[吃着火锅, 出城剿匪, 忽然被马匪给劫~了, 还是公平, 公平, 唱着歌]
[吃着火锅, 出城剿匪, 忽然被马匪给劫~了, 唱着歌]
交集 >>> [吃着火锅, 出城剿匪, 忽然被马匪给劫~了, 唱着歌]
差集 >>> [公平, 还是公平]
并集 >>> [吃着火锅, 出城剿匪, 忽然被马匪给劫~了, 还是公平, 公平, 唱着歌]
-- zset操作 ----
[[breakfast,5.0], [supper,18.0], [lunch,20.0]]
[[lunch,20.0], [supper,18.0], [breakfast,5.0]]
-- list操作 ----
再次暗示：点赞、关注
连续暗示：收藏、评论

jedis连接池

redis其实也是数据库，仅使用jedis来处理的话需要频繁的创建和关闭链接，因此可以采用jedis连接池来创建链接。

public class RedisJedisPool {
    public static void main(String[] args) {
        // 连接池配置对象,包含了很多默认配置
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        JedisPool jedisPool = new JedisPool(poolConfig, "127.0.0.1", 6379);
        Jedis jedis = null;
        try {
            // 从连接池获取jedis对象
            jedis = jedisPool.getResource();
            // 执行操作
            System.out.println(jedis.smembers("shiye"));
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally{
            // 如果使用JedisPool，那么close操作不是关闭连接，代表归还连接池
            if(jedis != null){
                jedis.close();
            }
        }
    }
}

// 输出结果：
[吃着火锅, 出城剿匪, 唱着歌, 忽然被马匪给劫~了]

Spring Boot 集成 Redis

只是简单的集成，具体使用需要优化的地方很多。

maven

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.5.4</version>
</dependency>

配置文件（.property, yml自行转换）

## redis
spring.redis.host=127.0.0.1
#Redis服务器连接端口
spring.redis.port=6379
#Redis服务器连接密码（默认为空）
spring.redis.password=
#连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
#连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.pool.max-idle=8
#连接池中的最小空闲连接
spring.redis.pool.min-idle=0
#连接超时时间（毫秒）
spring.redis.timeout=30000

配置类

@Configuration
public class RedisCfg {

    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.timeout}")
    private int timeout;
    @Value("${spring.redis.password}")
    private String password;
    @Value("${spring.redis.pool.max-active}")
    private int maxActive;
    @Value("${spring.redis.pool.max-wait}")
    private int maxWait;
    @Value("${spring.redis.pool.max-idle}")
    private int maxIdle;
    @Value("${spring.redis.pool.min-idle}")
    private int minIdle;

    @Bean
    public JedisConnectionFactory redisConnectionFactory() {
        JedisConnectionFactory factory = new JedisConnectionFactory();
        factory.setHostName(host);
        factory.setPort(port);
        factory.setTimeout(timeout); //设置连接超时时间
        factory.setPassword(password);
        factory.getPoolConfig().setMaxIdle(maxIdle);
        factory.getPoolConfig().setMinIdle(minIdle);
        factory.getPoolConfig().setMaxTotal(maxActive);
        factory.getPoolConfig().setMaxWaitMillis(maxWait);
        return factory;
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate(factory);
        //设置序列化工具，这样ReportBean不需要实现Serializable接口
        setSerializer(template);
        template.afterPropertiesSet();
        return template;
    }

    private void setSerializer(StringRedisTemplate template) {
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setValueSerializer(jackson2JsonRedisSerializer);
    }
}

工具类

@Component
public class RedisUtils {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 写入缓存
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            redisTemplate.opsForValue().set(key, value);
            result = true;
        } catch (Exception e) {
            System.out.println("ex" + e);
        }
        return result;
    }
    /**
     * 写入缓存设置时效时间
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime , TimeUnit timeUnit) {
        boolean result = false;
        try {
            redisTemplate.opsForValue().set(key, value);
            redisTemplate.expire(key, expireTime, timeUnit);
            result = true;
        } catch (Exception e) {
            System.out.println("ex" + e);
        }
        return result;
    }
    /**
     * 批量删除对应的value
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }
    /**
     * 批量删除key
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0){
            redisTemplate.delete(keys);
        }
    }
    /**
     * 删除对应的value
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }
    /**
     * 判断缓存中是否有对应的value
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }
    /**
     * 读取缓存
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        result = redisTemplate.opsForValue().get(key);
        return result;
    }
    /**
     * 哈希 添加
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value){
        redisTemplate.opsForHash().put(key,hashKey,value);
    }
    /**
     * 哈希获取数据
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey){
        return redisTemplate.opsForHash().get(key,hashKey);
    }
    /**
     * 列表添加
     * @param k
     * @param v
     */
    public void lPush(String k,Object v){
        redisTemplate.opsForList().rightPush(k,v);
    }
    /**
     * 列表获取
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> lRange(String k, long l, long l1){
        return redisTemplate.opsForList().range(k,l,l1);
    }
    /**
     * 集合添加
     * @param key
     * @param value
     */
    public void add(String key,Object value){
        redisTemplate.opsForSet().add(key,value);
    }
    /**
     * 集合获取
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key){
        return redisTemplate.opsForSet().members(key);
    }
    /**
     * 有序集合添加
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key,Object value,double scoure){
        redisTemplate.opsForZSet().add(key,value,scoure);
    }
    /**
     * 有序集合获取
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key, double scoure, double scoure1){
        return redisTemplate.opsForZSet().rangeByScore(key, scoure, scoure1);
    }

}

测试类

@RestController
public class RedisTestController {

    @Autowired
    private RedisUtils redisUtils;

    @GetMapping("/test/redis/getRedisCache/{key}")
    public String getRedisCache(@PathVariable(value = "key")String key){
        return redisUtils.get(key).toString();
    }

}

启动 spring boot 访问 localhost:8080/test/redis/getRedisCache/count结果如下:

python操作redis

版本：3.8

首先需要引入redis包

pip install redis

import redis

# host是redis主机，需要redis服务端和客户端都启动 redis默认端口是6379
r = redis.Redis(host='localhost', port=6379, decode_responses=True)
r.smembers("shiye")
print(r.smembers("shiye"))

print('----- pool -------')

# redis 连接池
pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)
list = r.lrange("reqList", 0, -1)
print(list)

# 输出
{'吃着火锅', '忽然被马匪给劫~了', '出城剿匪', '唱着歌'}
----- pool -------
['再次暗示：', '点赞、', '关注']

封面图，侵权删（各位老爷，看在图的份上给个三连吧）