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

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

mhr18 2024-11-18 14:38 29 浏览 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 -------
['再次暗示:', '点赞、', '关注']


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

相关推荐

如何检查 Linux 服务器是物理服务器还是虚拟服务器?

在企业级运维、故障排查和性能调优过程中,准确了解服务器的运行环境至关重要。无论是物理机还是虚拟机,都存在各自的优势与限制。在很多场景下,尤其是当你继承一台服务器而不清楚底层硬件细节时,如何快速辨识它是...

第四节 Windows 系统 Docker 安装全指南

一、Docker在Windows上的运行原理(一)架构限制说明Docker本质上依赖Linux内核特性(如Namespaces、Cgroups等),因此在Windows系统上无法直...

C++ std:shared_ptr自定义allocator引入内存池

当C++项目里做了大量的动态内存分配与释放,可能会导致内存碎片,使系统性能降低。当动态内存分配的开销变得不容忽视时,一种解决办法是一次从操作系统分配一块大的静态内存作为内存池进行手动管理,堆对象内存分...

Activiti 8.0.0 发布,业务流程管理与工作流系统

Activiti8.0.0现已发布。Activiti是一个业务流程管理(BPM)和工作流系统,适用于开发人员和系统管理员。其核心是超快速、稳定的BPMN2流程引擎。Activiti可以...

MyBatis动态SQL的5种高级玩法,90%的人只用过3种

MyBatis动态SQL在日常开发中频繁使用,但大多数开发者仅掌握基础标签。本文将介绍五种高阶技巧,助你解锁更灵活的SQL控制能力。一、智能修剪(Trim标签)应用场景:动态处理字段更新,替代<...

Springboot数据访问(整合Mybatis Plus)

Springboot整合MybatisPlus1、创建数据表2、引入maven依赖mybatis-plus-boot-starter主要引入这个依赖,其他相关的依赖在这里就不写了。3、项目结构目录h...

盘点金州勇士在奥克兰13年的13大球星 满满的全是...

见证了两个月前勇士与猛龙那个史诗般的系列赛后,甲骨文球馆正式成为了历史。那个大大的红色标志被一个字母一个字母地移除,在周四,一切都成为了过去式。然而这座,别名为“Roaracle”(译注:Roar怒吼...

Mybatis入门看这一篇就够了(mybatis快速入门)

什么是MyBatisMyBatis本是apache的一个开源项目iBatis,2010年这个项目由apachesoftwarefoundation迁移到了googlecode,并且改名为M...

Springboot数据访问(整合druid数据源)

Springboot整合druid数据源基本概念SpringBoot默认的数据源是:2.0之前:org.apache.tomcat.jdbc.pool.DataSource2.0及之后:com.z...

Linux 中的 &quot;/etc/profile.d&quot; 目录有什么作用 ?

什么是/etc/profile.d/目录?/etc/profile.d/目录是Linux系统不可或缺的一部分保留配置脚本。它与/etc/profile文件相关联,这是一个启动脚本,该脚...

企业数据库安全管理规范(企业数据库安全管理规范最新版)

1.目的为规范数据库系统安全使用活动,降低因使用不当而带来的安全风险,保障数据库系统及相关应用系统的安全,特制定本数据库安全管理规范。2.适用范围本规范中所定义的数据管理内容,特指存放在信息系统数据库...

Oracle 伪列!这些隐藏用法你都知道吗?

在Oracle数据库中,有几位特殊的“成员”——伪列,它们虽然不是表中真实存在的物理列,但却能在数据查询、处理过程中发挥出意想不到的强大作用。今天给大家分享Oracle伪列的使用技巧,无论...

Oracle 高效处理数据的隐藏神器:临时表妙用

各位数据库搬砖人,在Oracle的代码世界里闯荡,处理复杂业务时,是不是总被数据“搅得头大”?今天给大家安利一个超实用的隐藏神器——临时表!当你需要临时存储中间计算结果,又不想污染正式数据表...

Oracle 数据库查询:多表查询(oracle多表关联查询)

一、多表查询基础1.JOIN操作-INNERJOIN:返回两个表中满足连接条件的匹配行,不保留未匹配数据。SELECTa.emp_id,b.dept_nameFROMempl...

一文掌握怎么利用Shell+Python实现多数据源的异地备份程序

简介:在信息化时代,数据安全和业务连续性已成为企业和个人用户关注的焦点。无论是网站数据、数据库、日志文件,还是用户上传的文档、图片等,数据一旦丢失,损失难以估量。尤其是当数据分布在多个不同的目录、服务...

取消回复欢迎 发表评论: