redis使用入门介绍

最新推荐文章于 2024-06-18 10:57:14 发布
最新推荐文章于 2024-06-18 10:57:14 发布
阅读量195 收藏
点赞数
分类专栏： Redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/slj821/article/details/106782100
版权

redis使用入门介绍

本文以IDEA为例简单介绍redis及jedis的配置及使用说明。

一、IDEA导入相关依赖

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

二、配置文件中配置redis

本例配置文件为application.properties

redis.host=127.0.0.1
redis.port=6379
redis.timeout=10
redis.poolMaxTotal=1000
redis.poolMaxIdle=500
redis.poolMaxWait=500

三、在实体类中读取配置文件中redis的配置信息

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * 读取配置文件中关于redis的配置信息
 */

@Component
@ConfigurationProperties(prefix = "redis")      // 在application.properties中，读取前缀”redis“的配置信息
public class RedisConfig {
    private String host;
    private int port;
    private int timeout;
    private String password;
    private int poolMaxTotal;
    private int poolMaxIdle;
    private int poolMaxWait;

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public int getTimeout() {
        return timeout;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getPoolMaxTotal() {
        return poolMaxTotal;
    }

    public void setPoolMaxTotal(int poolMaxTotal) {
        this.poolMaxTotal = poolMaxTotal;
    }

    public int getPoolMaxIdle() {
        return poolMaxIdle;
    }

    public void setPoolMaxIdle(int poolMaxIdle) {
        this.poolMaxIdle = poolMaxIdle;
    }

    public int getPoolMaxWait() {
        return poolMaxWait;
    }

    public void setPoolMaxWait(int poolMaxWait) {
        this.poolMaxWait = poolMaxWait;
    }
}

四、自定义redis连接池

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * 自定义redis连接池JedisPool，并注入spring容器
 */
@Service
public class RedisPoolFactory {

    @Autowired
    RedisConfig  redisConfig;

    /**
     * 将redis连接池注入spring容器
     * @return
     */
    @Bean
    public JedisPool JedisPoolFactory(){
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxIdle(redisConfig.getPoolMaxIdle());
        config.setMaxTotal(redisConfig.getPoolMaxTotal());
        config.setMaxWaitMillis(redisConfig.getPoolMaxWait() * 1000);
        // 连接池参数设置
        JedisPool jp = new JedisPool(config, redisConfig.getHost(), redisConfig.getPort(),
                redisConfig.getTimeout()*1000, redisConfig.getPassword(), 0);
        return jp;
    }
}

五、redis过期时间及前缀的定义

  1. 先定义一个接口
/**
 *包含方法：
 *      有效期
 *      获取前缀
 */
public interface KeyPrefix {

    /**
     * 有效期
     * @return
     */
    public int expireSeconds();

    /**
     * 前缀
     * @return
     */
    public String getPrefix();
}
  1. 实现接口
public abstract class BasePrefix implements KeyPrefix {

    private int expireSeconds;  //过期时间

    private String prefix;      //前缀

    public BasePrefix(String prefix){
        this(0, prefix);//默认0代表永不过期
    }

    public BasePrefix(int expireSeconds, String prefix){
        this.expireSeconds = expireSeconds;
        this.prefix = prefix;
    }

    @Override
    public int expireSeconds() {
        return expireSeconds;
    }

    @Override
    public String getPrefix() {
        String className = getClass().getSimpleName();//拿到参数类类名
        return className + ":" + prefix;
    }
}

六、自定义redis的服务

import com.alibaba.fastjson.JSON;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

/**
 * redis服务
 */
@Service
public class RedisService {

    @Autowired
    JedisPool jedisPool;

    /**
     * 从redis连接池获取redis实例
     */
    public <T> T get(KeyPrefix prefix, String key, Class<T> clazz) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();        // 从连接池中获取一个jedis连接
            //对key增加前缀，即可用于分类，也避免key重复
            String realKey = prefix.getPrefix() + key;  // 类名+key
            String str = jedis.get(realKey);
            T t = stringToBean(str, clazz);
            return t;
        } finally {
            returnToPool(jedis);
        }

    }

    /**
     * 存储对象
     */
    public <T> Boolean set(KeyPrefix prefix, String key, T value) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            String str = beanToString(value);
            if (str == null || str.length() <= 0) {
                return false;
            }
            String realKey = prefix.getPrefix() + key;
            int seconds = prefix.expireSeconds();//获取过期时间
            if (seconds <= 0) {
                jedis.set(realKey, str);
            } else {
                jedis.setex(realKey, seconds, str);
            }

            return true;
        } finally {
            returnToPool(jedis);    //使用结束，将jedis返回连接池
        }

    }

    /**
     * 删除
     */
    public boolean delete(KeyPrefix prefix, String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            //生成真正的key
            String realKey = prefix.getPrefix() + key;
            long ret = jedis.del(realKey);          // 如果删除了一个或多个键，则为大于0的整数，如果指定的键不存在，则为0
            return ret > 0;         // 测试是否删除成功，删除成功返回true
        } finally {
            returnToPool(jedis);    // 使用结束，将jedis返回连接池
        }
    }

    /**
     * 判断key是否存在
     */
    public <T> boolean exists(KeyPrefix prefix, String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            //生成真正的key
            String realKey = prefix.getPrefix() + key;
            return jedis.exists(realKey);       // 判断是否已经存在key
        } finally {
            returnToPool(jedis);                // 使用结束，将jedis返回连接池
        }
    }

    /**
     * 增加值
     * Redis Incr 命令将 key 中储存的数字值增一。    如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作
     */
    public <T> Long incr(KeyPrefix prefix, String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            //生成真正的key
            String realKey = prefix.getPrefix() + key;
            return jedis.incr(realKey);
        } finally {
            returnToPool(jedis);
        }
    }

    /**
     * 减少值
     */
    public <T> Long decr(KeyPrefix prefix, String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            //生成真正的key
            String realKey = prefix.getPrefix() + key;
            return jedis.decr(realKey);
        } finally {
            returnToPool(jedis);
        }
    }


    public static <T> String beanToString(T value) {
        if (value == null) {
            return null;
        }
        Class<?> clazz = value.getClass();
        if (clazz == int.class || clazz == Integer.class) {
            return String.valueOf(value);
        } else if (clazz == long.class || clazz == Long.class) {
            return String.valueOf(value);
        } else if (clazz == String.class) {
            return (String) value;
        } else {
            return JSON.toJSONString(value);
        }

    }

    public static <T> T stringToBean(String str, Class<T> clazz) {
        if (str == null || str.length() <= 0 || clazz == null) {
            return null;
        }
        if (clazz == int.class || clazz == Integer.class) {
            return (T) Integer.valueOf(str);
        } else if (clazz == long.class || clazz == Long.class) {
            return (T) Long.valueOf(str);
        } else if (clazz == String.class) {
            return (T) str;
        } else {
            return JSON.toJavaObject(JSON.parseObject(str), clazz);
        }
    }

    /**
     * 作用：//将jedis返回到连接池中，目的是节省jedis资源
     * @param jedis
     */
    private void returnToPool(Jedis jedis) {
        if (jedis != null) {
            jedis.close();
        }
    }
}

七、使用示例

import com.alibaba.druid.util.StringUtils;
import com.jesper.seckill.bean.User;
import com.jesper.seckill.exception.GlobalException;
import com.jesper.seckill.mapper.UserMapper;
import com.jesper.seckill.redis.RedisService;
import com.jesper.seckill.redis.UserKey;
import com.jesper.seckill.result.CodeMsg;
import com.jesper.seckill.util.MD5Util;
import com.jesper.seckill.util.UUIDUtil;
import com.jesper.seckill.vo.LoginVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;

/**
 * 关于用户的操作
 */
@Service
public class UserService {

    @Autowired
    UserMapper userMapper;

    @Autowired
    RedisService redisService;

    public static final String COOKIE_NAME_TOKEN = "token";

    /**
     * 由id获取对应的用户
     * @param id
     * @return
     */
    public User getById(long id) {
        //先从redis缓存中获取用户对象
        User user = redisService.get(UserKey.getById, "" + id, User.class);
        if (user != null) {
            return user;
        }

        // redis缓存中不存在用户对象，从数据库中取
        user = userMapper.getById(id);
        //再存入缓存
        if (user != null) {
            redisService.set(UserKey.getById, "" + id, user);
        }
        return user;
    }
}
在云端821
关注
专栏目录
Redis从入门到精通
06-19
《Redis从入门到精通》是一门综合性的课程，旨在帮助初学者和有经验的开发者深入理解和熟练运用Redis这一流行的缓存中间件。Redis是Remote Dictionary Server（远程字典服务器）的缩写，它是一个开源的、基于内存的...
redis从入门到精通
06-12
**Redis入门** Redis，全名Remote Dictionary Server，是一款开源的高性能键值对存储系统，它支持数据的持久化，可以作为数据库、缓存和消息中间件使用。在Windows平台上安装Redis，一般通过下载官方的预编译二进制...
redis使用入门
whxwkb的博客
05-24 208
使用入门 获得一个符合匹配规则的键名列表 keys pattern [? / * /[]] keys mic:hobby 判断一个键是否存在 ， EXISTS key type key 去获得这个key的数据结构类型 各种数据结构的使用 字符类型 一个字符类型的key默认存储的最大容量是512M 赋值和取值 SET key value GET key 递增数字 ...
Redis使用入门
渔闻520的博客
03-07 146
现在GitHub上下载：https://github.com/MicrosoftArchive/redis/releases/tag/win-3.0.504 下载完后解压： 在这个目录下新建立一个startup.cmd文件，写入： redis-server redis.windows.conf 双击这个文件，再打开redis-cli.exe，这样就可以连接到他的服务器了。 ...
redis的入门使用
qq_44407617的博客
04-25 305
1.nosql的了解 –nosql表示not only sql,泛指非关系型数据库，主要用在高并发 ，大数据环境中 –nosql的数据库有很多，比较出名的有redis和memcached 2.redis的认识 –redis是一个 key-value类型的nosql数据库，特点是数据保存在内存之中，读写速度快，支持持久化操作，支持的数据类型多，可以设置数据的过期时间、支持在集群环境中使用 –redi...
redis基本使用(入门一)
Echo的博客
06-15 352
Redis入门一redis简介以及安装和配置Jedis连接docker-compose.yml配置引入依赖配置基本命令的使用字符串(String)列表(list)哈希(hash) redis简介以及安装和配置 查看我网易云笔记 文档：6-Redis安装与配置.note 链接：http://note.youdao.com/noteshare?id=e41016b553359acd0b4d97a4a62fa538&sub=89A0AF7F3DDF477096CC0B5C290196A6 如果是采用do
Redis入门教程
weixin_45072119的博客
06-18 559
Redis是一种键值型的NoSql数据库，这里有两个关键字：键值型NoSql其中键值型，是指Redis中存储的数据都是以key.value对的形式存储，而value的形式多种多样，可以是字符串.数值.甚至json：而NoSql则是相对于传统关系型数据库而言，有很大差异的一种数据库。对于存储的数据，没有类似Mysql那么严格的约束，比如唯一性，是否可以为null等等，所以我们把这种松散结构的数据库，称之为NoSQL数据库。
Redis从入门到精通2024版 视频教程 下载 百度网盘链接4.zip
最新发布
06-19
Redis从入门到精通2024版 视频教程 下载 ├─第 01 章 开篇 │ 001.Redis 录制计划.mp4 │ 002.Redis 介绍.mp4 │ 003.Redis 安装.mp4 │ ├─第 02 章 基本数据类型 │ 01.在后台启动 Redis.mp4 │ 02....
Redis实战_Redis实战中文完整版_Redis快速入门_Redis数据类型及操作_Redis常用
03-09
1. **Redis快速入门**：这部分通常会介绍如何安装Redis，包括在各种操作系统（如Linux、Windows、macOS）上的安装步骤。还会讲解Redis服务器的启动与停止，以及配置文件的基本设置。此外，客户端工具的使用，如`...
Redis从入门到精通（深入剖析）【55集完整资料】54-redis-Jedis的使用.mp4
02-06
Redis从入门到精通高清，迅雷播放器组件可顺利播放
Redis快速入门
hing_ren的博客
11-03 888
Redis的常见命令（简单总结B站黑马程序员的Redis教程）
redis入门（一）：redis基本操作
haleycat的博客
04-09 2377
redis已经成为了主流的内存数据库，如果你正在寻找可靠的内存数据库的话，redis是一个很不错的选择。 如果你之前有接触过内存数据就会了解大部分的内存数据库都是以key-value的形式存在的，一个键对应一个值，而值 可以有哪些数据结果呢？ redis支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。 同时也支持原子操作，大大的方便的数据统计。 支持不同方式的排序 redis
Redis的入门及使用
ruozhuliufeng的博客
12-24 738
Redis的入门及使用 NoSQL NoSQL = Not Only SQL,意即“不仅仅是SQL” **泛指非关系型数据库。**随着互联网web2.0网站的星期，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决...
Redis超详细入门教程（基础篇）
热门推荐
黄团团的个人博客
07-25 1万+
Redis是一个性能极高的内存数据库，支持丰富数据结构，提供持久化、事务等功能，非常适合缓存、消息队列等场景，被广泛应用于各种大型系统中。它的高性能、丰富功能使其成为非关系型数据库的重要选择之一。
【Redis】Redis 的学习教程（一）入门基础
sco5282的博客
08-17 325
是一款开源的，遵守 BSD 协议，使用 C 语言开发的 key-value 存储系统。简单的说，它是一款跨平台的非关系型数据库，支持优先内存存储，在分布式的架构环境下，Redis 基本上是缺一不可的缓存中间件，它能很好的解决服务与服务之间数据共享的问题，并且性能不受影响。
Redis入门-基础知识
weixin_69229325的博客
04-02 1345
Redis是一个基于内存的key-value结构数据库。Redis 是互联网技术领域使用最为广泛的存储中间件。RedisRedis中文网key-value结构存储：基于内存存储，读写性能高适合存储热点数据（热点商品、资讯、新闻）企业应用广泛Redis是用C语言开发的一个开源的高性能键值对(key-value)数据库，官方提供的数据是可以达到100000+的QPS（每秒内查询次数）。它存储的value类型比较丰富，也被称为结构化的NoSql数据库。
Redis基础知识入门
小yu别错过的博客
11-08 1992
关系型数据库是基于关系表的数据库，最终会将数据持久化到磁盘上，而nosql数据库是基于特殊的结构，并将数据存储到内存的数据库。从性能上而言，nosql数据库要优先于关系型数据库，从安全性上来讲，关系型数据库要优先于nosql数据库，所以在实际开发中一个项目中nosql和关系型数据库会一起使用，达到性能和安全性的双保证。NOSQL产品: redis，mongodb，memcached...Redis就是一款NoSQLs'sNoSQL -> 非关系型数据库 -> Not Only SQL。
Redis使用教程
静静是我女朋友
11-04 885
Redis：基本用法1 以下示例是基本示例，您可以在官方网站上查看更多命令。 ⇒ http://redis.io/commands [root@vdevops ~]# redis-cli -a password #认证连接redis-server 127.0.0.1:6379> quit [root@vdevops ~]# redis-cli #
一篇详文带你入门 Redis
腾讯技术工程
02-18 1789
作者：QQ 音乐前端团队本文将会从：Redis 使用场景与介绍 -> 数据结构与简单使用 -> 小功能大用处 -> 持久化、主从同步与缓存设计 -> 知识拓展 来书...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值