百度360必应搜狗淘宝本站头条
当前位置:网站首页 > 技术教程 > 正文

redis实战之基础,程序简单操作redis

mhr18 2024-11-18 14:38 28 浏览 0 评论

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 -------
['再次暗示:', '点赞、', '关注']


封面图,侵权删(各位老爷,看在图的份上给个三连吧)

相关推荐

【推荐】一个开源免费、AI 驱动的智能数据管理系统,支持多数据库

如果您对源码&技术感兴趣,请点赞+收藏+转发+关注,大家的支持是我分享最大的动力!!!.前言在当今数据驱动的时代,高效、智能地管理数据已成为企业和个人不可或缺的能力。为了满足这一需求,我们推出了这款开...

Pure Storage推出统一数据管理云平台及新闪存阵列

PureStorage公司今日推出企业数据云(EnterpriseDataCloud),称其为组织在混合环境中存储、管理和使用数据方式的全面架构升级。该公司表示,EDC使组织能够在本地、云端和混...

对Java学习的10条建议(对java课程的建议)

不少Java的初学者一开始都是信心满满准备迎接挑战,但是经过一段时间的学习之后,多少都会碰到各种挫败,以下北风网就总结一些对于初学者非常有用的建议,希望能够给他们解决现实中的问题。Java编程的准备:...

SQLShift 重大更新:Oracle→PostgreSQL 存储过程转换功能上线!

官网:https://sqlshift.cn/6月,SQLShift迎来重大版本更新!作为国内首个支持Oracle->OceanBase存储过程智能转换的工具,SQLShift在过去一...

JDK21有没有什么稳定、简单又强势的特性?

佳未阿里云开发者2025年03月05日08:30浙江阿里妹导读这篇文章主要介绍了Java虚拟线程的发展及其在AJDK中的实现和优化。阅前声明:本文介绍的内容基于AJDK21.0.5[1]以及以上...

「松勤软件测试」网站总出现404 bug?总结8个原因,不信解决不了

在进行网站测试的时候,有没有碰到过网站崩溃,打不开,出现404错误等各种现象,如果你碰到了,那么恭喜你,你的网站出问题了,是什么原因导致网站出问题呢,根据松勤软件测试的总结如下:01数据库中的表空间不...

Java面试题及答案最全总结(2025版)

大家好,我是Java面试陪考员最近很多小伙伴在忙着找工作,给大家整理了一份非常全面的Java面试题及答案。涉及的内容非常全面,包含:Spring、MySQL、JVM、Redis、Linux、Sprin...

数据库日常运维工作内容(数据库日常运维 工作内容)

#数据库日常运维工作包括哪些内容?#数据库日常运维工作是一个涵盖多个层面的综合性任务,以下是详细的分类和内容说明:一、数据库运维核心工作监控与告警性能监控:实时监控CPU、内存、I/O、连接数、锁等待...

分布式之系统底层原理(上)(底层分布式技术)

作者:allanpan,腾讯IEG高级后台工程师导言分布式事务是分布式系统必不可少的组成部分,基本上只要实现一个分布式系统就逃不开对分布式事务的支持。本文从分布式事务这个概念切入,尝试对分布式事务...

oracle 死锁了怎么办?kill 进程 直接上干货

1、查看死锁是否存在selectusername,lockwait,status,machine,programfromv$sessionwheresidin(selectsession...

SpringBoot 各种分页查询方式详解(全网最全)

一、分页查询基础概念与原理1.1什么是分页查询分页查询是指将大量数据分割成多个小块(页)进行展示的技术,它是现代Web应用中必不可少的功能。想象一下你去图书馆找书,如果所有书都堆在一张桌子上,你很难...

《战场兄弟》全事件攻略 一般事件合同事件红装及隐藏职业攻略

《战场兄弟》全事件攻略,一般事件合同事件红装及隐藏职业攻略。《战场兄弟》事件奖励,事件条件。《战场兄弟》是OverhypeStudios制作发行的一款由xcom和桌游为灵感来源,以中世纪、低魔奇幻为...

LoadRunner(loadrunner录制不到脚本)

一、核心组件与工作流程LoadRunner性能测试工具-并发测试-正版软件下载-使用教程-价格-官方代理商的架构围绕三大核心组件构建,形成完整测试闭环:VirtualUserGenerator(...

Redis数据类型介绍(redis 数据类型)

介绍Redis支持五种数据类型:String(字符串),Hash(哈希),List(列表),Set(集合)及Zset(sortedset:有序集合)。1、字符串类型概述1.1、数据类型Redis支持...

RMAN备份监控及优化总结(rman备份原理)

今天主要介绍一下如何对RMAN备份监控及优化,这里就不讲rman备份的一些原理了,仅供参考。一、监控RMAN备份1、确定备份源与备份设备的最大速度从磁盘读的速度和磁带写的带度、备份的速度不可能超出这两...

取消回复欢迎 发表评论: