下载地址：

win版：https://github.com/microsoftarchive/redis/releases

Linux版：https://download.redis.io/releases/

安装方式：解压安装

默认端口号：6379

推荐版本：3.2.1

推荐可视化工具：Another Redis

推荐驱动工具：SpringData Redis

基础操作：

服务端：

运行操作：

redis-server.exe redis.windows.conf

结束操作：

ctrl + c

客户端：

连接操作：

redis-cli.exe （默认连接本地服务端）redis-cli.exe -h 服务端地址 -p 端口号 -a 密码

退出操作：

exit

密码设置：

在redis.windows.conf文件中解开requirepass foobared （foobared为密码）

驱动工具：SpringData Redis

基础配置：

配置方式：导入maven坐标->配置Redis数据源->编写配置类->创建RedisTemplate对象->通过对象操作Redis

导入maven坐标：

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

配置Redis数据源：

spring:
 redis:
  host: localhost
  port: 6379
  password: 123456
  database: 0

基础类型：

操作命令：

字符串：

SET key value          设置指定key的值        
​
GET key                获取指定key的值
​
SETEX key second value  设置指定key的值，并将key的过期时间设置为seconds
​
SETNX key value         只有在key不存在时才能设置key的值

哈希：

HSET key field value     将哈希表key中的字段field的值设为value      
​
HSET key field           获取存储在哈希表中的指定字段
​
HDEL key field          删除存储在 哈希表中的指定字段
​
HKEYS key               获取哈希表中的所有字段
​
HVALS key               获取哈希表中的所有值

字符串：

LPUSH key value1 [value2]	  将一个或多个值插入到列表头部

LRANG key start stop	      获取列表指定范围内的元素（stop=-1为返回全部）

RPOP key				   	 移除并获取列表最后一个元素

LLEN key					 获取列表长度

集合：

SADD key member1 [member2]	  向集合添加一个或多个成员

SMEMBERS key				 返回集合中的所有成员

SCARD key					 返回给定所有集合的交集

SINTER key1 [key2]			  返回所有给定集合的并集

SUNION key1 [key2]			  返回所有给定集合的并集

SREM key member1 [member2]	   删除集合中的一个或多个成员

 

有序集合：

ZADD key score1 member1 [score2 member2] 	 向有序集合添加一个或多个成员

ZRANGE key start stop [WITHSCORES] 			通过索引区间返回有序集合中指定区间的成员

ZINCRBY key increment member 			    有序集合中对指定成员的分数加上增量increment

ZREM key member1 [member2] 				    移除有序集合中的一个或多个成员

通用命令：

KEYS pattern							  查找所有符合给定模式（pattern）的key

EXISTS key							 	  检查给定key是否存在

TYPE key								  返回key所存储的值的类型

DEL key									  该命令用于在key存在时删除key

使用方法：

字符串 String：

//存入对象
redisTemplate.opsForValue().set("user:" + user.getId(), user, Duration.ofMinutes(30));  
//获取对象
redisTemplate.opsForValue().get("user:" + id);

哈希 hash：

redisTemplate.opsForHash().put("user:1001", "name", "Alice");
redisTemplate.opsForHash().put("user:1001", "age", 25);
​
String name = (String) redisTemplate.opsForHash().get("user:1001", "name");

列表 list：

//添加元素
//从左边插入一个元素
redisTemplate.opsForList().leftPush("users:list", user);
//从左边批量插入多个元素
redisTemplate.opsForList().leftPushAll("users:list", user1, user2);
//从右边插入一个元素
redisTemplate.opsForList().rightPush("users:list", user);
//从右边批量插入多个元素
redisTemplate.opsForList().rightPushAll("users:list", user1, user2);
​
//获取列表范围
//获取整个列表（0 到 -1 表示全部）
List<Object> users = redisTemplate.opsForList().range("users:list", 0, -1);
//获取前3个元素
List<Object> firstThree = redisTemplate.opsForList().range("users:list", 0, 2);
//获取最后一个元素
List<Object> lastOne = redisTemplate.opsForList().range("users:list", -1, -1);
//获取列表长度
Long size = redisTemplate.opsForList().size("users:list");
​
// 弹出元素（移除并返回）
// 从左边弹出一个元素
Object leftUser = redisTemplate.opsForList().leftPop("users:list");
// 从右边弹出一个元素
Object rightUser = redisTemplate.opsForList().rightPop("users:list");
// 阻塞式弹出（BLPOP / BRPOP）——如果列表为空则等待，单位：秒
Object blockedUser = redisTemplate.opsForList().leftPop("users:list", 10, TimeUnit.SECONDS);
Object blockedRight = redisTemplate.opsForList().rightPop("users:list", 5, TimeUnit.SECONDS);
​
//删除元素
//移除列表中等于 value 的前 n 个元素
//count > 0 : 从头开始删除最多 count 个匹配项
//count < 0 : 从尾开始删除最多 |count| 个匹配项
//count = 0 : 删除所有匹配项
Long removedCount = redisTemplate.opsForList().remove("users:list", 1, user); // 删除第一个匹配的 user
Long removeAll = redisTemplate.opsForList().remove("users:list", 0, user);   // 删除所有匹配的 user
​
//获取指定索引位置的元素
//获取索引为 0 的元素（第一个）
Object first = redisTemplate.opsForList().index("users:list", 0);
//获取倒数第一个元素
Object last = redisTemplate.opsForList().index("users:list", -1);
​
//设置指定索引位置的元素
//将索引 index 处的元素设置为新值（必须存在该索引）
redisTemplate.opsForList().set("users:list", 2, updatedUser);
​
//截取并保留指定范围
//只保留列表中 [0, 9] 范围内的元素，其余删除（可用于分页缓存清理）
redisTemplate.opsForList().trim("users:list", 0, 9);
//清空整个列表
redisTemplate.opsForList().trim("users:list", 1, 0); // 巧妙技巧：起始 > 结束 → 清空

无序集合 set：

//存入集合
redisTemplate.opsForSet().add("users:set", "user");
//获取集合中所有值
Set<Object> userSet = redisTemplate.opsForSet().members("users:set");
//判断是否存在该值
Boolean isLiked = redisTemplate.opsForSet().isMember("users:set", "user");
//获取集合大小
Long count = redisTemplate.opsForSet().zCard("users:set"); // 推荐写法
// 删除一个用户
redisTemplate.opsForSet().remove("users:set", "user");
// 删除多个用户
redisTemplate.opsForSet().remove("users:set", "user1", "user2");
// 删除所有匹配的值
Object[] toRemove = {"user1", "user2"};
redisTemplate.opsForSet().remove("users:set", toRemove);
//随机弹出并删除元素
Object luckyUser = redisTemplate.opsForSet().pop("users:set");
//求交集
Set<Object> commonFriends = redisTemplate.opsForSet().intersect("user:set1", "user:set2");
//求并集
Set<Object> allMembers = redisTemplate.opsForSet().union("user:set1", "user:set2");
//求差集
Set<Object> recommendUsers = redisTemplate.opsForSet().difference("user:set1", "user:set2");

有序集合 sorted set/zset：

//将值存入指定的有序集合
redisTemplate.opsForZSet().add(LEADERBOARD_KEY, userId.toString(), score); //key value 排序值
//获取第x个到第y个的该集合的所有值
//正序获得
redisTemplate.opsForZSet().rangeWithScores(LEADERBOARD_KEY, 0, topN - 1);
//逆序获得
redisTemplate.opsForZSet().reverseRangeWithScores(LEADERBOARD_KEY, 0, topN - 1);
//获取该值的存入顺序（从0开始）
redisTemplate.opsForZSet().reverseRank(LEADERBOARD_KEY, uid);
//获取排序值
redisTemplate.opsForZSet().score(LEADERBOARD_KEY, uid);
//增加排序值
redisTemplate.opsForZSet().incrementScore(LEADERBOARD_KEY, uid, increment);
//删除该值
redisTemplate.opsForZSet().remove(LEADERBOARD_KEY, uid);
//获取该有序集合存入值的数量
redisTemplate.opsForZSet().zCard(LEADERBOARD_KEY);
//获取区间内的值
redisTemplate.opsForZSet().reverseRangeByScoreWithScores(LEADERBOARD_KEY, min, max);
//删除区间内的值
redisTemplate.opsForZSet().removeRangeByScore(LEADERBOARD_KEY, min, max);

设置过期时间：

redisTemplate.expire("key", 10, TimeUnit.SECONDS);
redisTemplate.expireAt("key", new Date(System.currentTimeMillis() + 60000));

返回顶部

依赖：

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

配置：

spring:  
    datasource:    
        url: jdbc:mysql://127.0.0.1:3306/mp?useUnicode=true&characterEncoding=UTF-                      8&autoReconnect=true&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true    
        driver-class-name: com.mysql.cj.jdbc.Driver    
        username: root    
        password: 123456

第一章 DDL-创建操作

DDL-数据库操作:

查询:

查询所有数据库：

SHOW DATASHOW;

查询当前数据库：

SELECT DATABASE();

创建：

CREATE DATABASE [IF NOT EXISTS] 数据库名 [DEFAULT CHARSET 字符集] [COLLATE 排序规则];

删除：

DROP DATABASE [IF EXISTS] 数据库名;

使用：

USE 数据库名;

DDL-表操作:

查询:

查询当前数据库所有表：

SHOW TABLE;

查询表结构：

DESC 表名;

查询指定表的建表语句：

SHOW CREATE TABLE 表名;

创建:

CREATE TABLE 表名( 字段名 字段类型 [COMMENT 字段注释]，字段名 字段类型 [COMMENT 字段注释]) [COMMENT 表注释];

修改:

添加字段：

ALTER TABLE 表名 ADD 字段名 类型（长度）[COMMENT 注释] [约束];

修改数据类型：

ALTER TABLE 表名 MODIFY 字段名 新数据类型（长度）；

修改字段名和字段类型：

ALTER TABLE 表名 CHANGE 旧字段名 新字段名 类型（长度）[COMMENT 注释] [约束]

删除字段：

ALTER TABLE 表名 DROP 字段名;

修改表名：

ALTER TABLE 表名 RENAME TO 新表名;

删除表：

DROP TABLE [IF EXISTS] 表名;

删除指定表，并重新创建该表：

TRUNCATE 表名;

数值类型：

字符串类型：

日期类型：

第二章 DML-更新操作

DML-添加数据:

给指定字段添加数据：

INSERT INTO 表名 （字段名1，字段名2...）VALUE（值1，值2...）;

给全部字段添加数据：

INSERT INTO 表名 VALUE（值1，值2...）;

添加批量数据： I

NSERT INTO 表名（字段名1，字段名2）VALUES（值1，值2...），（1，值2...）;

NISERT NITO 表名 VALUE（值1，值2...）（值1，值2...）;

DML-修改数据:

UPDATE 表名 SET 字段名1=值1;字段名2=值2，...[WHERE 条件];

DML-删除数据

DELETE FROM 表名 [WHERE 条件];

第三章 DQL-查询操作

语法：

SELECT 字段列表 FROM 表名列表 WHERE 条件列表 GROUP BY 分组字段列表 HAVING 分组后条件列表 ORDER BY 排序字段列表  LIMIT 分页参数

执行顺序： FROM->WHERE->GROUP BY->HAVING->SELECT->ORDER BY->LIMIT

DQL-基本查询：

查询多个字段：

SELECT 字段1，字段2...FROM 表名;

SELECT * FROM 表名;

设置别名：

SELECT 字段1[AS 别名]，字段2[AS 别名2]...FROM 表名;

去除重复记录：

SELECT DISTINCT 字段列表 FROM 表名;

DQL-条件查询：

SELECT 字段列表 FROM 表名 WHERE 条件列表;

条件：

DQL-聚合查询：

SELECT 聚合查询（字段列表） FROM 表名;

聚合函数：

DQL-分组查询：

SELECT字段列表 FROM 表名[WHERE 条件] GROUP BY 分组字段名 [HAVING 分组后过滤条件];

where: 过滤后分组，不可用聚合函数

having 分组后过滤，可用聚合函数

DQL-排序查询:

SELECT 字段列表 FROM 表名 ORDER BY 字段1 排序方式1，字段2 排序方式2;

排序方式： ASC 升序（默认值）

DESC 降序

DQL-分页查询：

SELECT 字段列表 FROM 表名 LIMIT 起始索引，查询记录数;(起始索引为0，不同数据库略有不同，如查询为第一页，则起始索引可省略)

第四章 DCL-管理数据库

DCL-管理用户：

查询用户：

USE mysql;
SELECT * FROM user;

创建用户：

CREATE USER '用户名'@'主机名' IDENTIFIED BY '密码';

修改用户密码：

ALTER USER '用户名'@'主机名' IDENTIFIED WITH mysql_native_password BY '新密码';

删除用户：

DROP USER '用户名'@'主机名';

DCL-权限控制：

查询权限：

SHOW GRANTS FOR '用户名'@'主机名';

授予权限:

GRANT 权限列表 ON 数据库名.表名 TO '用户名'@'主机名';

撤销权限：

REVOKE 权限列表 ON 数据库名.表名 FROM '用户名'@'主机名';

第五章 函数

字符串函数：

数值函数：

日期函数：

流程函数：

第六章 约束

基础约束：

说明：约束作用于表中字段上，可以在创建表/修改表的时候添加约束

外键约束：

语法：

添加外键：

#创建表时添加
CREATE TABLE 表名(
    字段名 数据类型
    ...
    [CONSTRAINT] [外键名称] FOREIGN KEY(外键字段名) REFERENCES 主表(主表列名);
)

#创建表后添加
ALTER TABLE 表名 ADD CONSTRAINT 外键名称 FOREIGN KEY(外键字段名) REFERENCES 主表(主表列名);

删除外键：

ALTER TABLE 表名 DROP FOREIGN KEY 外键名称;

更新删除行为：

#设置更新/删除行为
ALTER TABLE 表名 ADD CONSTRAINT 外键名称 FOREIGN KEY(外键字段名) REFERENCES 主表名(主表字段名) ON UPDATE CASCADE ON DELETE CASCADE;

第七章 多表查询

内连接：

说明：连接结果为两表交集部分

隐式内连接：

SELECT 字段列表 FROM 表1，表2 WHERE 条件...;

显示内连接：

SELECT 字段列表 FROM 表1 [INNER] JOIN 表2 ON 连接条件 ...;

外连接：

说明：查询左/右表全部数据，包含两表交集部分

左连接：

SELECT 字段列表 FROM 表1 LEFT [OUTER] JOIN 表2 ON 条件...;

右外连接：

SELECT 字段列表 FROM 表1 RIGHT [OUTER] JOIN 表2 ON 条件...;

自连接：

说明：可以是内连接查询，也可是外连接查询

SELECT 字段列表 FROM 表A 别名A JOIN 表A 别名B ON 条件...;

联合查询：

说明：联合查询需要保证各表查询列数与字段类型保持一致，union会将合并后的数据去重，union all则不会

SELECT 字段列表 FROM 表A ...
UNION [ALL]
SELECT 字段列表 FROM 表B ...;

子查询：

说明：在sql语句中嵌套SELECT语句，称为嵌套查询或子查询

SELECT * FROM t1 WHERE column1 = (SELECT column1 FROM t2);

子查询外部语句可以是INSERT/UPDATE/SELECT的任何一个

根据子查询的查询结果不同，分为：

• 标量子查询(查询结果为单个值) 常用操作符：=, <>, >, >=, <, <=
• 列子查询(查询结果为一列) 常用操作符：IN, NOT, IN ANY, SOME, ALL
• 行子查询(查询结果为一行) 常用操作符：=, <>, IN, NOT, IN
• 表子查询(查询结果为多行多列) 常用操作符：IN

子查询位置：

• WHERE之后
• FROM之后
• SELECT之后

第八章 事务

事务操作：

查看/设置事务提交方式：

SELECT @@autocommit; #查看事务提交方式
SET @@autocommit=0;  #设置事务提交方式

开启事务：

START TRANSACTION 或 BEGIN

提交事务：

COMMIT;

回滚事务：

ROLLBACK;

事务隔离级别：

查看事务隔离级别：

SELECT @@TRANSACTION_ISOLATION;

设置事务隔离级别：

SET [SESSION|GLOBAL] TRANSACTION ISOLATION LEVEL {READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE} #隔离级别依次为：读未提交 | 读已提交-解决脏读 | 可重复读-解决不可重复读 | 串行化-解决幻读

返回顶部