百度360必应搜狗淘宝本站头条
mqtt服务器xftp6mybatiscollectionkeyerrorc#var
当前位置：网站首页 > 热门文章 > 正文

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

bigegpt 2024-11-21 10:41 4 浏览

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


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

相关推荐

悠悠万事，吃饭为大（悠悠万事吃饭为大,什么意思）

新媒体编辑：杜岷赵蕾初审：程秀娟审核：汤小俊审签：周星...

高铁扒门事件升级版!婚宴上‘冲喜’老人团:我们抢的是社会资源

凌晨两点改方案时，突然收到婚庆团队发来的视频——胶东某酒店宴会厅，三个穿大红棉袄的中年妇女跟敢死队似的往前冲，眼瞅着就要扑到新娘的高额钻石项链上。要不是门口小伙及时阻拦，这婚礼造型团队熬了三个月的方案...

微服务架构实战:商家管理后台与sso设计，SSO客户端设计

SSO客户端设计下面通过模块merchant-security对SSO客户端安全认证部分的实现进行封装，以便各个接入SSO的客户端应用进行引用。安全认证的项目管理配置SSO客户端安全认证的项目管理使...

还在为 Spring Boot 配置类加载机制困惑?一文为你彻底解惑

在当今微服务架构盛行、项目复杂度不断攀升的开发环境下，SpringBoot作为Java后端开发的主流框架，无疑是我们手中的得力武器。然而，当我们在享受其自动配置带来的便捷时，是否曾被配置类加载...

Seata源码—6.Seata AT模式的数据源代理二

大纲1.Seata的Resource资源接口源码2.Seata数据源连接池代理的实现源码3.Client向Server发起注册RM的源码4.Client向Server注册RM时的交互源码5.数据源连接...

30分钟了解K8S（30分钟了解微积分）

微服务演进方向o面向分布式设计(Distribution):容器、微服务、API驱动的开发;o面向配置设计(Configuration):一个镜像，多个环境配置;o面向韧性设计(Resista...

SpringBoot条件化配置(@Conditional)全面解析与实战指南

一、条件化配置基础概念1.1什么是条件化配置条件化配置是Spring框架提供的一种基于特定条件来决定是否注册Bean或加载配置的机制。在SpringBoot中，这一机制通过@Conditional...

一招解决所有依赖冲突（克服依赖）

背景介绍最近遇到了这样一个问题，我们有一个jar包common-tool，作为基础工具包，被各个项目在引用。突然某一天发现日志很多报错。一看是NoSuchMethodError，意思是Dis...

你读过Mybatis的源码?说说它用到了几种设计模式

学习设计模式时，很多人都有类似的困扰——明明概念背得滚瓜烂熟，一到写代码就完全想不起来怎么用。就像学了一堆游泳技巧，却从没下过水实践，很难真正掌握。其实理解一个知识点，就像看立体模型，单角度观察总...

golang对接阿里云私有Bucket上传图片、授权访问图片

1、为什么要设置私有bucket公共读写：互联网上任何用户都可以对该Bucket内的文件进行访问，并且向该Bucket写入数据。这有可能造成您数据的外泄以及费用激增，若被人恶意写入违法信息还可...

spring中的资源的加载（spring加载原理）

最近在网上看到有人问@ContextConfiguration("classpath:/bean.xml")中除了classpath这种还有其他的写法么，看他的意思是想从本地文件...

Android资源使用（android资源文件）

Android资源管理机制在Android的开发中，需要使用到各式各样的资源，这些资源往往是一些静态资源，比如位图，颜色，布局定义，用户界面使用到的字符串，动画等。这些资源统统放在项目的res/独立子...

如何深度理解mybatis?（如何深度理解康乐服务质量管理的5个维度）

深度自定义mybatis回顾mybatis的操作的核心步骤编写核心类SqlSessionFacotryBuild进行解析配置文件深度分析解析SqlSessionFacotryBuild干的核心工作编写...

@Autowired与@Resource原理知识点详解

springIOCAOP的不多做赘述了，说下IOC：SpringIOC解决的是对象管理和对象依赖的问题，IOC容器可以理解为一个对象工厂，我们都把该对象交给工厂，工厂管理这些对象的创建以及依赖关系...

java的redis连接工具篇（java redis client）

在Java里，有不少用于连接Redis的工具，下面为你介绍一些主流的工具及其特点：JedisJedis是Redis官方推荐的Java连接工具，它提供了全面的Redis命令支持，且...

一周热门
最近发表
标签列表