初识Redis
Redis是一种nosql(非关系型数据库) ,redis是一个开源的、使用C语言编写的、支持网络交互的、可基于内存也可持久化的Key-Value数据库。既然是数据库 ,重点在于crud
Redis的安装
大多数企业都是基于Linux服务器来部署项目，而且Redis官方也没有提供Windows版本的安装包。因此课程中我们会基于Linux系统来安装Redis.(我这里使用的是个人服务器)
此处选择的Linux版本为CentOS 8…
Redis的官方网站地址：https://redis.io/
1.安装Redis依赖
Redis是基于C语言编写的，因此首先需要安装Redis所需要的gcc依赖：
yum install -y gcc tcl
2.上传安装包并解压
然后将下载的Redis安装包上传到虚拟机的任意目录(这里我放在我自己服务器的统一目录)：
解压缩：
tar -xzf redis-7.0.5.tar.gz
进入redis目录：
cd redis-版本
运行编译命令：
make && make install
如果没有出错，应该就安装成功了。
默认的安装路径是在 **/usr/local/bin**目录下：
此时可以在安装的目录下看到几个redis相关
1.redis-servser //redis服务器
2.redis-sentinel //redis哨兵
3.redis-cli //redis命令行
这些文件是安装默认配置到linux环境变量中的 ,所以打redis按tab会补全选项
docker 安装
ubutu 安装docker
`sudo apt update
sudo apt install apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
sudo apt update
sudo apt install docker-ce
docker 安装redis和运行
拉取镜像
docker pull redis
编写配置文件
mkdir -p ~/redis/config
vim ~/redis/config/redis.conf
配置文件内容
bind 0.0.0.0
protected-mode no
port 6379
tcp-backlog 511
timeout 0
tcp-keepalive 300
daemonize no
supervised no
pidfile /var/run/redis_6379.pid
loglevel notice
logfile ""
databases 16
always-show-logo yes
docker 启动!
运行Redis容器并挂载配置文件
使用以下命令运行Redis容器，并将宿主机上的配置文件挂载到容器中
docker run -d --name redis-server -p 6379:6379 -v ~/redis/config/redis.conf:/usr/local/etc/redis/redis.conf redis redis-server /usr/local/etc/redis/redis.conf
解释：
- -d：后台运行容器。
- –name redis-server：指定容器名称为redis-server。
- -p 6379:6379：将宿主机的6379端口映射到容器的6379端口。
- -v ~/redis/config/redis.conf:/usr/local/etc/redis/redis.conf：将宿主机上的redis.conf文件挂载到容器的指定位置。
验证Redis运行状态
使用以下命令查看Redis容器的运行状态：
docker ps
出现下面内容
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
123456789abc redis "docker-entrypoint.s…" 30 seconds ago Up 29 seconds 0.0.0.0:6379->6379/tcp redis-server
- 连接到Redis容器
可以使用Redis CLI连接到Redis容器进行测试：
docker exec -it redis-server redis-cli
3.启动
redis的启动方式有很多种，例如：
- 默认启动
- 指定配置启动
- 开机自启
3.1.默认启动
安装完成后，在任意目录输入redis-server命令即可启动Redis：
redis-server
如图：
这种启动属于前台启动，会阻塞整个会话窗口，窗口关闭或者按下CTRL + C则Redis停止。不推荐使用。
3.2.指定配置启动
如果要让Redis以后台方式启动，则必须修改Redis配置文件，就在我们之前解压的redis安装包下（/usr/local/src/redis-7.0.5），名字叫redis.conf：
我们先将这个配置文件备份一份：
cp redis.conf redis.conf.bck
执行复制操作后 文件目录如下:
然后修改redis.conf文件中的一些配置：
# 允许访问的地址，默认是127.0.0.1，会导致只能在本地访问。修改为0.0.0.0则可以在任意IP访问，生产环境不要设置为0.0.0.0
bind 0.0.0.0
# 守护进程，修改为yes后即可后台运行
daemonize yes
# 密码，设置后访问Redis必须输入密码
requirepass 123321
Redis的其它常见配置：
# 监听的端口
port 6379
# 工作目录，默认是当前目录，也就是运行redis-server时的命令，日志、持久化等文件会保存在这个目录
dir .
# 数据库数量，设置为1，代表只使用1个库，默认有16个库，编号0~15
databases 1
# 设置redis能够使用的最大内存
maxmemory 512mb
# 日志文件，默认为空，不记录日志，可以指定日志文件名
logfile "redis.log"
启动Redis：
# 进入redis安装目录
cd /usr/local/src/redis-7.0.5
# 启动
redis-server redis.conf //服务端
// win10 在运行redis6 redis-server.exe redis.windows.conf
redis-cli.exe //-h 远程连接 -p 6379端口远程连接
auth 密码
3.3.开机自启
我们也可以通过配置来实现开机自启。
首先，新建一个系统服务文件：
vi /etc/systemd/system/redis.service
内容如下：
[Unit]
Description=redis-server
After=network.target
[Service]
Type=forking
ExecStart=/usr/local/bin/redis-server /root/Redis/redis-7.0.5/redis.conf
PrivateTmp=true
[Install]
WantedBy=multi-user.target
然后重载系统服务：
systemctl daemon-reload
现在，我们可以用下面这组命令来操作redis了：
# 启动
systemctl start redis
# 停止
systemctl stop redis
# 重启
systemctl restart redis
# 查看状态
systemctl status redis
执行下面的命令，可以让redis开机自启：
systemctl enable redis
**注意：**停止服务 以及其他服务：
# 利用redis-cli来执行 shutdown 命令，即可停止 Redis 服务，
# 因为之前配置了密码，因此需要通过 auth 认证 来指定密码
#没有认证的话 所有操作会提示
(error) NOAUTH Authentication required.
redis-cli #进入命令行
auth 你的密码#进行认证
shutdown #关闭redis服务
当然也可以用线程的形式
PS -ef |grep redis #查找redis进程
然后使用
kill -9 进程号
杀死进程
以上就是redis的基本安装操作 接下来提供基本使用和springboot整合
4.基本数据类型和操作
因为redis是一nosql 非关系型数据库 不存在关系一说(数据表) 因此只是 KV,有 set 和get 操作
4.1Spring Data Redis 操作 Redis。
1、创建 Maven 工程。
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.5.RELEASE</version>
</parent>
<dependencies>
<dependency><!--redis缓存技术更多的是基于mvc的开发-->
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency><!--springboot2.0使用客户端链接redis数据库-->
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
<dependency><!--简化开放-->
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
2、创建实体类，实现序列化接口
可以参考这个大佬的文章
了解Serializable序列化接口
package com.southwind.entity;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
@Data
public class Student implements Serializable {//实体类实现 Serializable 完成实列化
private Integer id;
private String name;
private Double score;
private Date birthday;
}
3、创建控制器。
package com.southwind.controller;
import com.southwind.entity.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;
@RestController
public class StudentHandler {
@Autowired
private RedisTemplate redisTemplate;
@PostMapping("/set")
public void set(@RequestBody Student student){
redisTemplate.opsForValue().set("student",student);
}
@GetMapping("/get/{key}")
public Student get(@PathVariable("key") String key){
return (Student) redisTemplate.opsForValue().get(key);
}
@DeleteMapping("/delete/{key}")
public boolean delete(@PathVariable("key") String key){
redisTemplate.delete(key);
return redisTemplate.hasKey(key);
}
}
返回类型是json需要解析
其次和mybatis通过sqlsession一样的
必须获取操作对象opsforvalue对象来操做redis数据库
import org.springframework.data.redis.core.RedisTemplate;//通过该对象操作数据库 类似mybatis通过sqlsession操作mysql
4、创建配置文件 application.yml
spring:
redis:
database: 0
host: localhost
port: 6379
5、创建启动类
package com.southwind;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class,args);
}
}
存入内存中会变成序列化
取出数据的时候 会自动序列化回来
4.2 Redis 5 种数据类型
字符串
@GetMapping("/string")
public String stringTest(){
redisTemplate.opsForValue().set("str","Hello World");
String str = (String) redisTemplate.opsForValue().get("str");
return str;
}
列表(对应java的list)
@GetMapping("/list")
public List<String> listTest(){
ListOperations<String,String> listOperations = redisTemplate.opsForList();
listOperations.leftPush("list","Hello");
listOperations.leftPush("list","World");
listOperations.leftPush("list","Java");
List<String> list = listOperations.range("list",0,2);
return list;
}
集合
@GetMapping("/set")
public Set<String> setTest(){
SetOperations<String,String> setOperations = redisTemplate.opsForSet();
setOperations.add("set","Hello");
setOperations.add("set","Hello");
setOperations.add("set","World");
setOperations.add("set","World");
setOperations.add("set","Java");
setOperations.add("set","Java");
Set<String> set = setOperations.members("set");
return set;
}
有序集合
@GetMapping("/zset")
public Set<String> zsetTest(){
ZSetOperations<String,String> zSetOperations = redisTemplate.opsForZSet();
zSetOperations.add("zset","Hello",1);
zSetOperations.add("zset","World",2);
zSetOperations.add("zset","Java",3);
Set<String> set = zSetOperations.range("zset",0,2);
return set;
}
哈希
HashMap key value
HashOperations key hashkey value
key 是每一组数据的 ID，hashkey 和 value 是一组完整的 HashMap 数据，通过 key 来区分不同的 HashMap。
HashMap hashMap1 = new HashMap();
hashMap1.put(key1,value1);
HashMap hashMap2 = new HashMap();
hashMap2.put(key2,value2);
HashMap hashMap3 = new HashMap();
hashMap3.put(key3,value3);
HashOperations<String,String,String> hashOperations = redisTemplate.opsForHash();
hashOperations.put(hashMap1,key1,value1);
hashOperations.put(hashMap2,key2,value2);
hashOperations.put(hashMap3,key3,value3);
Springboot中的redis的各个数据类型操作api
@SpringBootTest
public class RedisTest {
@Autowired
StringRedisTemplate redisTemplate;
@Resource
DsihMapper dishMapper;
List<Dish> dishList;
private final String listPrex = "List:";
private final String mapPrex = "Map:";
private final String setPrex = "Set:";
private final String zSetPrex = "ZSet:";
private final String stringPrex = "String:";
@BeforeEach
public void insertList() {
// 从数据库中选择所有Dish数据
dishList = dishMapper.selectList(Wrappers.<Dish>lambdaQuery());
}
@Test
@DisplayName("redis 操作字符串")
public void redisOpForString() {
// 将dishList转换为JSON字符串并存储在Redis中
redisTemplate.opsForValue().set(stringPrex + "dishes", JSON.toJSONString(dishList));
// 从Redis中获取存储的JSON字符串并转换回List<Dish>
String jsonString = redisTemplate.opsForValue().get(stringPrex + "dishes");
List<Dish> list = JSON.parseArray(jsonString, Dish.class);
System.out.println(list); // 打印list中的各个元素
}
@Test
@DisplayName("redis 操作列表")
public void redisOpForList() {
redisOpForString(); // 先进行字符串操作，存储数据
// 从Redis中获取存储的JSON字符串并转换回List<Dish>
String jsonString = redisTemplate.opsForValue().get(stringPrex + "dishes");
List<Dish> list = JSON.parseArray(jsonString, Dish.class);
// 将dishList中的每个Dish对象转换为JSON字符串，并存储在Redis的列表中
redisTemplate.opsForList().leftPushAll(listPrex + "list",
list.stream()
.map(JSON::toJSONString)
.collect(Collectors.toList())
);
// 根据索引从Redis列表中获取元素
String element = redisTemplate.opsForList().index(listPrex + "list", 0);
System.out.println(element);
// 从左侧弹出一个元素（第一个元素）
String popElement = redisTemplate.opsForList().leftPop(listPrex + "list");
System.out.println(element.equals(popElement)); // 验证弹出的元素是否与第一个元素相同
// 移除列表中指定值的元素
redisTemplate.opsForList().remove(listPrex + "list", 0, JSON.toJSONString(list.get(0)));
// 设置列表中指定索引的值
redisTemplate.opsForList().set(listPrex + "list", 1, JSON.toJSONString(list.get(1)));
// 删除Redis中的键
String[] keys = {listPrex + "list"};
redisTemplate.delete(Arrays.asList(keys));
}
@Test
@DisplayName("redis 操作hash映射")
public void redisOpForMap() {
redisOpForString(); // 先进行字符串操作，存储数据
// 从Redis中获取存储的JSON字符串并转换回List<Dish>
String jsonString = redisTemplate.opsForValue().get(stringPrex + "dishes");
List<Dish> list = JSON.parseArray(jsonString, Dish.class);
// 使用Redis的哈希操作存储Dish对象
redisTemplate.opsForHash().put(mapPrex + "dishes", "测试菜品1", JSON.toJSONString(list.get(0)));
redisTemplate.opsForHash().put(mapPrex + "dishes", "测试菜品2", JSON.toJSONString(list.get(1)));
// 从Redis的哈希中获取所有键值对
Map<Object, Object> entries = redisTemplate.opsForHash().entries(mapPrex + "dishes");
Object o = entries.get("测试菜品1");
System.out.println(o); // 打印获取的值
// 从哈希中删除一个键值对
redisTemplate.opsForHash().delete(mapPrex + "dishes", "测试菜品2");
}
@Test
@DisplayName("redis 操作集合")
public void redisOpForSet() {
redisOpForString(); // 先进行字符串操作，存储数据
// 从Redis中获取存储的JSON字符串并转换回List<Dish>
String jsonString = redisTemplate.opsForValue().get(stringPrex + "dishes");
List<Dish> list = JSON.parseArray(jsonString, Dish.class);
// 使用Redis的集合操作存储Dish对象
redisTemplate.opsForSet().add(setPrex + "dishes", JSON.toJSONString(list.get(0)), JSON.toJSONString(list.get(1)));
//添加所有菜品
list.forEach(dish -> redisTemplate.opsForSet().add("dishesAll",JSON.toJSONString(dish)));
// 检查集合中是否存在某个元素
Boolean isMember = redisTemplate.opsForSet().isMember(setPrex + "dishes", JSON.toJSONString(list.get(0)));
System.out.println(isMember); // 打印是否存在
// 获取集合中的所有元素
Set<String> members = redisTemplate.opsForSet().members(setPrex + "dishes");
System.out.println(members);
// 从集合中删除一个元素
redisTemplate.opsForSet().remove(setPrex + "dishes", JSON.toJSONString(list.get(1)));
}
@Test
@DisplayName("redis 操作有序集合")
public void redisOpForZSet() {
redisOpForString(); // 先进行字符串操作，存储数据
// 从Redis中获取存储的JSON字符串并转换回List<Dish>
String jsonString = redisTemplate.opsForValue().get(stringPrex + "dishes");
List<Dish> list = JSON.parseArray(jsonString, Dish.class);
// 使用Redis的有序集合操作存储Dish对象 有序集合是通过socre第三个参数是新的
redisTemplate.opsForZSet().add(zSetPrex + "dishes", JSON.toJSONString(list.get(0)), 1);
redisTemplate.opsForZSet().add(zSetPrex + "dishes", JSON.toJSONString(list.get(1)), 2);
// 获取有序集合中的元素及其分数
Set<String> range = redisTemplate.opsForZSet().range(zSetPrex + "dishes", 0, -1);
System.out.println(range);
// 获取某个元素的分数
Double score = redisTemplate.opsForZSet().score(zSetPrex + "dishes", JSON.toJSONString(list.get(0)));
System.out.println(score);
// 从有序集合中删除一个元素
redisTemplate.opsForZSet().remove(zSetPrex + "dishes", JSON.toJSONString(list.get(1)));
}
}
实际开发中使用StringRedisTemplate,并且每种数据类型都可以使用Stirng存储和取出,如果只是需要多次读取的数据就可以直接json化后用String保存,如果需要多次修改,还是根据不同类型api操作
1679
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
