k-on-forever's Blog

Redis学习笔记之高级篇

2026-04-04T02:00:00.000Z

分布式缓存

Redis持久化

RDB持久化

① 介绍

RDB全称Redis Database Backup file（Redis数据备份文件），也被叫做Redis数据快照。简单来说就是把内存中的所有数据都记录到磁盘中。当Redis实例故障重启后，从磁盘读取快照文件，恢复数据。快照文件称为RDB文件，默认是保存在当前运行目录。

② 执行时机

save命令

执行下面的命令，可以立即执行一次RDB：

save命令会导致主进程执行RDB，这个过程中其它所有命令都会被阻塞。只有在数据迁移时可能用到。

bgsave命令

下面的命令可以异步执行RDB：

这个命令执行后会开启独立进程完成RDB，主进程可以持续处理用户请求，不受影响。

停机时

Redis停机时会执行一次save命令，实现RDB持久化。

触发RDB条件

Redis内部有触发RDB的机制，可以在redis.conf文件中找到，格式如下：

# 900秒内，如果至少有1个key被修改，则执行bgsave ， 如果是save "" 则表示禁用RDB
save 900 1  
save 300 10  
save 60 10000

RDB的其它配置也可以在redis.conf文件中设置：

# 是否压缩 ,建议不开启，压缩也会消耗cpu，磁盘的话不值钱
rdbcompression yes

# RDB文件名称
dbfilename dump.rdb  

# 文件保存的路径目录
dir ./

③ RDB原理

bgsave开始时会fork主进程得到子进程，子进程共享主进程的内存数据。完成fork后读取内存数据并写入 RDB 文件。
fork采用的是copy-on-write技术：

当主进程执行读操作时，访问共享内存；
当主进程执行写操作时，则会拷贝一份数据，执行写操作。

当主进程要修改某块数据（比如图里的「数据 B」）时：

操作系统发现这块数据是只读的，先在物理内存里拷贝一份新副本（「数据 B 副本」）
主进程更新页表，让自己指向这个新副本，然后在副本上执行写操作
原来的「数据 B」保持不变，继续给子进程读（保证子进程看到的是 fork 那一刻的完整数据，不会被主进程的修改打乱）

AOF持久化

① 介绍

AOF全称为Append Only File（追加文件）。Redis处理的每一个写命令都会记录在AOF文件，可以看做是命令日志文件。

② AOF配置

AOF默认是关闭的，需要修改redis.conf配置文件来开启AOF：

# 是否开启AOF功能，默认是no
appendonly yes
# AOF文件的名称
appendfilename "appendonly.aof"

AOF的命令记录的频率也可以通过redis.conf文件来配：

# 表示每执行一次写命令，立即记录到AOF文件
appendfsync always 
# 写命令执行完先放入AOF缓冲区，然后表示每隔1秒将缓冲区数据写到AOF文件，是默认方案
appendfsync everysec 
# 写命令执行完先放入AOF缓冲区，由操作系统决定何时将缓冲区内容写回磁盘
appendfsync no

AOF文件重写

因为是记录命令，AOF文件会比RDB文件大的多。而且AOF会记录对同一个key的多次写操作，但只有最后一次写操作才有意义。通过执行bgrewriteaof命令，可以让AOF文件执行重写功能，用最少的命令达到相同效果。

如图，AOF原本有三个命令，但是set num 123 和 set num 666都是对num的操作，第二次会覆盖第一次的值，因此第一个命令记录下来没有意义。所以重写命令后，AOF文件内容就是：mset name jack num 666

Redis主从

主从数据同步原理

① 全量同步

主从第一次建立连接时，会执行全量同步，将master节点的所有数据都拷贝给slave节点，流程如下：

核心概念

Replication ID（replid）

每个 master 都有一个唯一的 replid，它是当前数据集的 “身份证”，代表这一套完整数据。
slave 会继承 master 的 replid，所以同一套数据集的 master 和 slave，replid 一定是一致的。

offset（偏移量）

master 每执行一条写命令，offset 就会递增，同时把命令记录到 repl_backlog 缓冲区。
slave 同步完成后，也会记录自己当前同步到的 offset。
如果 slave 的 offset < master 的 offset，说明 slave 数据落后，需要补同步。
master 如何判断 slave 是「第一次连接」？

判断逻辑非常简单：看 replid 是否一致

当它第一次执行 replicaof 变成 slave，连接 master 时，会把自己原来的 replid 和 offset 发给 master。

master 检查：

如果 slave 的 replid ≠ 自己的 replid → 判定这是全新的 slave（第一次连接），需要做全量同步。
如果 slave 的 replid = 自己的 replid → 判定这是重连的 slave，只需要做增量同步（补 offset 之后的命令）。
完整主从同步流程

第一步：连接协商（psync 阶段）

slave 执行 replicaof，和 master 建立连接，发送 psync 。
master 发现 slave 的 replid 和自己不一致 → 拒绝增量同步，返回自己的 replid 和当前 offset。
slave 保存 master 的 replid 和 offset，之后它的 replid 就和 master 一致了。

第二步：全量同步（RDB 阶段）

master 后台执行 bgsave，生成 RDB 快照（把当前内存里的所有数据导出成文件）。
生成 RDB 的同时，master 会把这段时间收到的所有写命令，记录到 repl_backlog 缓冲区（避免这段时间的数据丢失）。
RDB 生成后，master 把文件发送给 slave。
slave 清空本地所有数据，加载 RDB 文件，恢复到 master 生成 RDB 时的状态。

第三步：增量同步（命令回放阶段）

master 把 repl_backlog 里记录的、RDB 生成期间的所有写命令，逐条发给 slave。
slave 接收并执行这些命令，把 RDB 之后的操作全部补上，最终和 master 数据完全一致。
之后，master 每收到一条写命令，都会实时同步给所有 slave，slave 执行命令，保持持续同步。

② repl_backlog原理

repl_backlog 是 master 节点上的一个固定大小的环形数组缓冲区：

环形结构：数组下标走到末尾后，会从 0 重新开始读写，旧数据会被新数据覆盖。
存储内容：保存 master 最近处理过的写命令日志，以及每条命令对应的 offset（偏移量）。
核心作用：通过对比 master 和 slave 的 offset，精准定位两者的数据差异，实现高效增量同步。

2) 正常同步流程

offset 标记差异

master 维护自己的当前 offset（红色标记），slave 维护自己已同步到的 offset（绿色标记）。两者之间的差值，就是 slave 缺失的、需要增量同步的命令数据。

同步追赶

随着 master 不断写入新数据，它的 offset 持续增大；slave 不断从 master 拉取命令并执行，自己的 offset 也在追赶 master 的 offset，绿色（已同步）区域逐渐扩大。

安全覆盖

当缓冲区被写满后，新写入的命令会覆盖最旧的数据：

被覆盖的如果是绿色（已同步到 slave）的数据，完全没有影响，因为这些数据已经不需要再同步了；
未同步的只有红色（master 与 slave 之间）的部分，只要这部分还在缓冲区里，就能继续增量同步。

3) 异常场景：网络阻塞

当 slave 出现网络阻塞、长时间无法同步时，流程会发生变化：

差距拉大

master 持续写入，offset 快速增长，而 slave 的 offset 停滞不前，两者的差距（红色未同步区域）越来越大。

缓冲区覆盖危机

棕色框中的红色部分，就是尚未同步，但是却已经被覆盖的数据。此时如果slave恢复，需要同步，却发现自己的offset都没有了，无法完成增量同步了。只能做全量同步。

主从同步优化

可以从以下几个方面来优化Redis主从就集群：

在master中配置repl-diskless-sync yes启用无磁盘复制，避免全量同步时的磁盘IO。
Redis单节点上的内存占用不要太大，减少RDB导致的过多磁盘IO
适当提高repl_baklog的大小，发现slave宕机时尽快实现故障恢复，尽可能避免全量同步
限制一个master上的slave节点数量，如果实在是太多slave，则可以采用主-从-从链式结构，减少master压力

Redis哨兵

哨兵原理

① 集群结构和作用

哨兵的作用如下：

监控：Sentinel 会不断检查您的master和slave是否按预期工作
自动故障恢复：如果master故障，Sentinel会将一个slave提升为master。当故障实例恢复后也以新的master为主
通知：Sentinel充当Redis客户端的服务发现来源，当集群发生故障转移时，会将最新信息推送给Redis的客户端

② 集群监控原理

Sentinel基于心跳机制监测服务状态，每隔1秒向集群的每个实例发送ping命令：

主观下线：如果某sentinel节点发现某实例未在规定时间响应，则认为该实例主观下线。
客观下线：若超过指定数量（quorum）的sentinel都认为该实例主观下线，则该实例客观下线。quorum值最好超过Sentinel实例数量的一半。

③ 集群故障恢复原理

一旦发现master故障，sentinel需要在salve中选择一个作为新的master，选择依据是这样的：

首先会判断slave节点与master节点断开时间长短，如果超过指定值（down-after-milliseconds * 10）则会排除该slave节点
然后判断slave节点的slave-priority值，越小优先级越高，如果是0则永不参与选举
如果slave-prority一样，则判断slave节点的offset值，越大说明数据越新，优先级越高
最后是判断slave节点的运行id大小，越小优先级越高。

④ 如何实现故障转移

sentinel给备选的slave1节点发送slaveof no one命令，让该节点成为master
sentinel给所有其它slave发送slaveof 192.168.150.101 7002 命令，让这些slave成为新master的从节点，开始从新的master上同步数据。
最后，sentinel将故障节点标记为slave，当故障节点恢复后会自动成为新的master的slave节点

RedisTemplate

① 配置Redis地址

spring:
  redis:
    sentinel:
      master: mymaster
      nodes:
        - 192.168.150.101:27001
        - 192.168.150.101:27002
        - 192.168.150.101:27003

② 配置读写分离

@Bean
public LettuceClientConfigurationBuilderCustomizer clientConfigurationBuilderCustomizer(){
    return clientConfigurationBuilder -> clientConfigurationBuilder.readFrom(ReadFrom.REPLICA_PREFERRED);
}

这个bean中配置的就是读写策略，包括四种：

MASTER：从主节点读取
MASTER_PREFERRED：优先从master节点读取，master不可用才读取replica
REPLICA：从slave（replica）节点读取
REPLICA _PREFERRED：优先从slave（replica）节点读取，所有的slave都不可用才读取master

Redis分片集群

散列插槽

① 插槽的 “分配规则”：16384 个插槽分给所有 master 节点

Redis 集群总共有 0~16383 这 16384 个插槽（相当于 16384 个 “数据格子”），这些插槽会平均分给集群里的所有 master 节点。

② 数据的 “寻址规则”：key→插槽号→节点

Redis 存数据时，会先给 key 算一个插槽号，再找这个插槽号对应的节点，步骤如下：

步骤 1：确定 key 的 “有效部分”（计算的依据）

情况 1：key 里没有{} → 整个 key 都是有效部分（比如num、a，就用完整的num/a计算）；
情况 2：key 里有{} → 只算{}里的内容（比如{itcast}num，只算itcast，不管外面的num）；

步骤 2：计算插槽号（固定算法）

用「有效部分」通过 CRC16 算法 算出一个数字，再对 16384 取余数（余数范围 0~16383），结果就是插槽号。

集群伸缩

① 需求分析

需求：向集群中添加一个新的master节点，并向其中存储 num = 10

启动一个新的redis实例，端口为7004
添加7004到之前的集群，并作为一个master节点
给7004节点分配插槽，使得num这个key可以存储到7004实例

② 创建新的redis实例

做什么：创建 7004 的工作目录、修改配置、启动实例

# 1. 创建7004目录
mkdir 7004
# 2. 复制通用配置文件到7004
cp redis.conf 7004/
# 3. 把配置里的6379全替换为7004（端口、目录、pid等）
sed -i 's/6379/7004/g' 7004/redis.conf
# 4. 启动7004实例（后台运行）
redis-server 7004/redis.conf

③ 添加新节点到redis

做什么：用add-node把 7004 接入集群，此时 7004 是 master，但0 个哈希槽，存不了数据

1 2	# 语法：redis-cli --cluster add-node 新节点IP:端口集群任意已有节点IP:端口 redis-cli --cluster add-node 192.168.238.138:7004 192.168.238.138:7001

④ 添加新节点到redis

做什么：算出num这个 key 对应的槽位，确认它在哪个旧主节点的槽区间里

1 2	# 计算num的哈希槽号 redis-cli --cluster keyslot 192.168.238.138:7001 --key num

✅ 结果：num对应槽位2765，属于 7001 的0-5460槽区间，因此要从 7001 移槽。

⑤ 转移插槽

做什么：交互式把0-3000的槽（包含 2765）从 7001 迁移到 7004，数据会跟着槽自动迁移

1 2	# 启动reshard，指定集群任意节点 redis-cli --cluster reshard 192.168.238.138:7001

故障转移

① 自动故障转移

# 1. 直接杀掉7002进程（模拟宕机）
redis-cli -p 7002 shutdown

# 2. 查看集群状态（会看到7002状态变为master,fail? 或 disconnected）
redis-cli -p 7001 cluster nodes

✅ 结果：过几秒后，7002 的从节点（比如 8002）会自动变成 Master。

② 手动故障转移

利用cluster failover命令可以手动让集群中的某个master宕机，切换到执行cluster failover命令的这个slave节点，实现无感知的数据迁移。其流程如下：

这种failover命令可以指定三种模式：

缺省：默认的流程，如图1~6歩
force：省略了对offset的一致性校验
takeover：直接执行第5歩，忽略数据一致性、忽略master状态和其它master的意见
实操步骤

连接到 7002 的从节点（比如 8002）

1	redis-cli -p 8002

执行故障转移命令

1 2	127.0.0.1:8002> CLUSTER FAILOVER # 输出 OK

Redis学习笔记之实战篇

2026-03-29T03:00:00.000Z

实战篇

短信登录

思路分析

发送验证码：

用户在提交手机号后，会校验手机号是否合法，如果不合法，则要求用户重新输入手机号。如果手机号合法，后台此时生成对应的验证码，同时将验证码进行保存，然后再通过短信的方式将验证码发送给用户。

短信验证码登录、注册：

用户将验证码和手机号进行输入，后台从session中拿到当前验证码，然后和用户输入的验证码进行校验，如果不一致，则无法通过校验，如果一致，则后台根据手机号查询用户，如果用户不存在，则为用户创建账号信息，保存到数据库，无论是否存在，都会将用户信息保存到session中，方便后续获得当前登录信息。

校验登录状态：

用户在请求时候，会从cookie中携带者JsessionId到后台，后台通过JsessionId从session中拿到用户信息，如果没有session信息，则进行拦截，如果有session信息，则将用户信息保存到threadLocal中，并且放行。

实现发送短信验证码功能

发送验证码

@Override
public Result sendCode(String phone, HttpSession session) {
    // 1.校验手机号
    if (RegexUtils.isPhoneInvalid(phone)) {
        // 2.如果不符合，返回错误信息
        return Result.fail("手机号格式错误！");
    }
    // 3.符合，生成验证码
    String code = RandomUtil.randomNumbers(6);

    // 4.保存验证码到 session
    session.setAttribute("code",code);
    // 5.发送验证码
    log.debug("发送短信验证码成功，验证码：{}", code);
    // 返回ok
    return Result.ok();
}

说明：

① session.setAttribute("code", code)：核心是「保存校验凭证，实现用户绑定」

当用户输入手机号 + 验证码提交登录时，后端会执行 session.getAttribute("code")，取出这里存的验证码，和用户输入的对比 ——没有这行存储，后续登录就没有 “基准值” 可校验。

② log.debug("发送短信验证码成功，验证码：{}", code)：核心是「调试排查，记录运行状态」

{}：SLF4J 的占位符，会自动把后面的 code 变量值替换到这个位置（比如最终打印：发送短信验证码成功，验证码：123456）。

@Override
public Result login(LoginFormDTO loginForm, HttpSession session) {
    // 1.校验手机号
    String phone = loginForm.getPhone();
    if (RegexUtils.isPhoneInvalid(phone)) {
        // 2.如果不符合，返回错误信息
        return Result.fail("手机号格式错误！");
    }
    // 3.校验验证码
    Object cacheCode = session.getAttribute("code");
    String code = loginForm.getCode();
    if(cacheCode == null || !cacheCode.toString().equals(code)){
         //3.不一致，报错
        return Result.fail("验证码错误");
    }
    //一致，根据手机号查询用户
    User user = query().eq("phone", phone).one();

    //5.判断用户是否存在
    if(user == null){
        //不存在，则创建
        user =  createUserWithPhone(phone);
    }
    //7.保存用户信息到session中
    session.setAttribute("user",user);

    return Result.ok();
}

说明：

① 为什么校验的时候，要将cacheCode.toString()，不能直接比较？

session.getAttribute("code") 的返回值是 Object 类型（这是 HttpSession API 的设计），所以变量 cacheCode 被声明为 Object。
loginForm.getCode() 返回的是 String 类型，变量 code 是 String。

② User user = query().eq(“phone”, phone).one(); query()的作用是什么？

这是 MyBatis-Plus 提供的一个方法，通常在继承了 ServiceImpl 的 Service 层类中使用。
它的作用是：创建并返回一个 QueryWrapper 查询条件构造器。

实现登录拦截功能

拦截器代码

public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
       //1.获取session
        HttpSession session = request.getSession();
        //2.获取session中的用户
        Object user = session.getAttribute("user");
        //3.判断用户是否存在
        if(user == null){
              //4.不存在，拦截，返回401状态码
              response.setStatus(401);
              return false;
        }
        //5.存在，保存用户信息到Threadlocal
        UserHolder.saveUser((User)user);
        //6.放行
        return true;
    }
}

说明：

在 LoginInterceptor 的 preHandle 方法中，当判断用户已登录后，会调用 UserHolder.saveUser(...)，将用户信息存入当前处理请求的线程的 ThreadLocal 中。

让拦截器生效

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 登录拦截器
        registry.addInterceptor(new LoginInterceptor())
                .excludePathPatterns(
                        "/shop/**",
                        "/voucher/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/blog/hot",
                        "/user/code",
                        "/user/login"
                ).order(1);
        // token刷新的拦截器
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);
    }
}

Redis代替session的业务流程

思路分析

当注册完成后，用户去登录会去校验用户提交的手机号和验证码，是否一致。如果一致，则根据手机号查询用户信息，不存在则新建，最后将用户数据保存到redis，并且生成token作为redis的key。当我们校验用户是否登录时，会去携带着token进行访问，从redis中取出token对应的value，判断是否存在这个数据，如果没有则拦截，如果存在则将其保存到threadLocal中，并且放行。

代码实现

UserServiceImpl代码

@Override
public Result login(LoginFormDTO loginForm, HttpSession session) {
    // 1.校验手机号
    String phone = loginForm.getPhone();
    if (RegexUtils.isPhoneInvalid(phone)) {
        // 2.如果不符合，返回错误信息
        return Result.fail("手机号格式错误！");
    }
    // 3.从redis获取验证码并校验
    String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
    String code = loginForm.getCode();
    if (cacheCode == null || !cacheCode.equals(code)) {
        // 不一致，报错
        return Result.fail("验证码错误");
    }

    // 4.一致，根据手机号查询用户 select * from tb_user where phone = ?
    User user = query().eq("phone", phone).one();

    // 5.判断用户是否存在
    if (user == null) {
        // 6.不存在，创建新用户并保存
        user = createUserWithPhone(phone);
    }

    // 7.保存用户信息到 redis中
    // 7.1.随机生成token，作为登录令牌
    String token = UUID.randomUUID().toString(true);
    // 7.2.将User对象转为HashMap存储
    UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
    Map userMap = BeanUtil.beanToMap(userDTO, new HashMap<>(),
            CopyOptions.create()
                    .setIgnoreNullValue(true)
                    .setFieldValueEditor((fieldName, fieldValue) -> fieldValue.toString()));
    // 7.3.存储
    String tokenKey = LOGIN_USER_KEY + token;
    stringRedisTemplate.opsForHash().putAll(tokenKey, userMap);
    // 7.4.设置token有效期
    stringRedisTemplate.expire(tokenKey, LOGIN_USER_TTL, TimeUnit.MINUTES);

    // 8.返回token
    return Result.ok(token);
}

说明：

1). UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);

作用：把数据库查出来的 User 实体（包含密码等敏感字段），复制为 UserDTO（只保留 id、nickName、icon 等非敏感字段）。
核心意义：避免敏感信息（比如密码）泄露到前端 / Redis 中，保证数据安全。

2). Map userMap = BeanUtil.beanToMap(userDTO);

作用：把 UserDTO 对象转换成 Map 集合（键是字段名，值是字段值）。
核心意义：Redis 的 Hash 结构只能接收「键值对」形式的数据，所以必须把对象转成 Map 才能存入。

3). setFieldValueEditor(...)：强制把所有字段值转成字符串

Redis 的 Hash 结构有个「死规矩」：键和值都必须是字符串类型，不支持 Long、Integer 等数字类型。
✅ 加了这个配置：fieldValueEditor 是个「编辑器」，它会遍历所有字段值，把不管是 Long、Integer 还是其他类型的值，都强制转成字符串 —— 比如 Long 的 10086 会变成字符串 "10086"，存入 Redis 后完全符合 Redis 的字符串要求，后续取值转换也不会报错。

4), stringRedisTemplate.expire(…)

给 Redis 中指定的 Key 设置「自动删除倒计时」，时间一到，Redis 就自动把这个 Key 和它对应的所有数据删掉。

登录刷新问题

思路分析

之前的拦截器无法对不需要拦截的路径生效，那么我们可以添加一个拦截器，在第一个拦截器中拦截所有的路径，把第二个拦截器做的事情放入到第一个拦截器中，同时刷新令牌，因为第一个拦截器有了threadLocal的数据，所以此时第二个拦截器只需要判断拦截器中的user对象是否存在即可，完成整体刷新功能。

代码实现

① RefreshTokenInterceptor：做 “数据准备 + Token 续期”（永远放行）

@Override
public boolean preHandle(...) {
    // 1. 从请求头拿Token（比如前端传的authorization: xxx）
    String token = request.getHeader("authorization");
    if (StrUtil.isBlank(token)) {
        return true; // 没Token也放行，交给LoginInterceptor判断
    }
    // 2. 去Redis查用户信息（根据TokenKey查Hash）
    String key = LOGIN_USER_KEY + token;
    Map userMap = stringRedisTemplate.opsForHash().entries(key);
    // 3. 没查到用户（Token过期/无效），放行（交给LoginInterceptor拦截）
    if (userMap.isEmpty()) {
        return true;
    }
    // 4. 查到用户，转成UserDTO存入ThreadLocal（给LoginInterceptor用）
    UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
    UserHolder.saveUser(userDTO);
    // 5. 关键：刷新Token有效期（用户发请求就续期，避免使用中过期）
    stringRedisTemplate.expire(key, LOGIN_USER_TTL, TimeUnit.MINUTES);
    // 6. 永远放行（它只做准备，不拦人）
    return true;
}

@Override
public void afterCompletion(...) {
    UserHolder.removeUser(); // 请求结束，清空ThreadLocal，防内存泄漏
}

② LoginInterceptor：只做 “权限拦截”（只判断，不干活）

@Override
public boolean preHandle(...) {
    // 只看ThreadLocal里有没有用户（RefreshTokenInterceptor存的）
    if (UserHolder.getUser() == null) {
        response.setStatus(401); // 没用户，返回401
        return false; // 拦截
    }
    return true; // 有用户，放行
}

商户查询缓存

添加商户缓存

思路分析

标准的操作方式就是查询数据库之前先查询缓存，如果缓存数据存在，则直接从缓存中返回，如果缓存数据不存在，再查询数据库，然后将数据存入redis。

代码实现

@Override
public Result queryById(Long id) {
    String key = "cache:shop:" + id;
    // 1. 从redis查询商铺缓存
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    // 2. 判断是否存在
    if (StrUtil.isNotBlank(shopJson)) {
        // 3. 存在，直接返回
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
        return Result.ok(shop);
    }
    // 4. 不存在，根据id查询数据库
    Shop shop = getById(id);
    // 5. 不存在，返回错误
    if (shop == null) {
        return Result.fail("店铺不存在！");
    }
    // 6. 存在，写入redis
    stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop));
    // 7. 返回
    return Result.ok(shop);
}

说明：

① @Resource 能成功注入 StringRedisTemplate，核心原因是：Spring 容器中已经存在一个类型为 StringRedisTemplate 的 Bean，而 @Resource 注解可以根据名称或类型来查找并注入这个 Bean。Spring Boot 有一套「自动配置」逻辑，当你在项目中引入 spring-boot-starter-data-redis 依赖后，Spring 会自动加载 RedisAutoConfiguration 类（这个类是 Spring 框架自带的，不是你写的），里面会自动创建 StringRedisTemplate 和 RedisTemplate 两个 Bean。

② Shop shop = JSONUtil.toBean(shopJson, Shop.class); 为什么要转化类型？

Redis 的存储限制：Redis 是一个键值对数据库，它只能存储字符串、数字等基础类型，不能直接存储 Java 对象。所以你在把 Shop 存进 Redis 时，必须先用 JSONUtil.toJsonStr(shop) 把它转成 JSON 字符串（文本）才能存。
Java 的业务需求：从 Redis 取出来后，必须把 JSON 字符串还原成 Shop 对象，才能在 Java 代码里正常使用。

缓存更新策略

三种策略

**① 内存淘汰：**redis自动进行，当redis内存达到咱们设定的max-memery的时候，会自动触发淘汰机制，淘汰掉一些不重要的数据(可以自己设置策略方式)

**② 超时剔除：**当我们给redis设置了过期时间ttl之后，redis会将超时的数据进行删除，方便咱们继续使用缓存

**③ 主动更新：**我们可以手动调用方法把缓存删掉，通常用于解决缓存和数据库不一致问题

先操作缓存还是先操作数据库？

答案：应该先操作数据库。

左边「先删缓存，再更数据库」的并发问题（旧值 10、新值 20）

① 初始状态

数据库中值：10（旧值）
Redis 缓存中值：10（旧值）

② 并发时序

时间顺序	线程 1（更新操作：把值改成 20）	线程 2（查询操作）
1	删除 Redis 缓存（缓存变为空）	-
2	-	发起查询，缓存未命中
3	-	去数据库读取，拿到旧值 10
4	-	把旧值 10 写入 Redis 缓存
5	执行数据库更新，把值改成 20	-

③ 最终结果

数据库值：20（新值）
Redis 缓存值：10（旧值）
后续所有查询都会直接读缓存的 10，直到缓存过期 / 被删除 —— 这就是缓存与数据库的数据不一致，本质是「缓存脏读」。

实现商铺和缓存与数据库双写一致

@Override
@Transactional
public Result update(Shop shop) {
    Long id = shop.getId();
    if (id == null) {
        return Result.fail("店铺id不能为空");
    }
    // 1. 更新数据库
    updateById(shop);
    // 2. 删除缓存
    stringRedisTemplate.delete(CACHE_SHOP_KEY + id);
    return Result.ok();
}

说明：

@Transactional 事务注解

作用：将整个方法包裹在一个数据库事务中，确保 “更新数据库” 和 “删除缓存” 这两个操作要么全部成功，要么全部失败（回滚）。

缓存穿透问题的解决思路

① 缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，这些请求都会打到数据库。

② 常见的解决方案有两种：

1). 缓存空对象

当我们客户端访问不存在的数据时，先请求redis，但是此时redis中没有数据，此时会访问到数据库，但是数据库中也没有数据，这个数据穿透了缓存，直击数据库，我们都知道数据库能够承载的并发不如redis这么高，如果大量的请求同时过来访问这种不存在的数据，这些请求就都会访问到数据库，简单的解决方案就是哪怕这个数据在数据库中也不存在，我们也把这个数据存入到redis中去。这样，下次用户过来访问这个不存在的数据，那么在 redis 中也能找到这个数据，就不会进入到数据库了。

2). 布隆过滤

布隆过滤器其实采用的是哈希思想来解决这个问题，通过一个庞大的二进制数组，走哈希思想去判断当前这个要查询的这个数据是否存在，如果布隆过滤器判断存在，则放行，这个请求会去访问redis，哪怕此时redis中的数据过期了，但是数据库中一定存在这个数据，在数据库中查询出来这个数据后，再将其放入到redis中。

缺点：不存在一定不存在，存在可能不存在

编码解决商品查询的缓存穿透问题

重点代码

1
2
3

if (shopJson != null) {
    return Result.fail("店铺信息不存在");
}

说明：

① 先明确两个前置条件：

StrUtil.isNotBlank(shopJson)：判断字符串非空且非空白（即 shopJson 不是 null、不是 ""、不是全空格）；
前一行已经判定 StrUtil.isNotBlank(shopJson) == false，说明 shopJson 只有两种可能：null 或 ""（空字符串）。

② 这行 if (shopJson != null)：说明 shopJson 是 ""（空字符串）—— 这个 "" 是你之前主动存入 Redis 的「空对象标记」（对应代码里 stringRedisTemplate.opsForValue().set(key, "", ...)）。

③ 逻辑意义：

如果 Redis 里存的是 ""，说明之前已经查过这个 ID 的店铺，数据库里根本没有；
此时直接返回 “店铺不存在”，不用再查数据库，避免恶意请求（比如传不存在的 ID）反复穿透到数据库，这就是「缓存空对象防穿透」的核心逻辑。

缓存雪崩问题及解决思路

① 缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机，导致大量请求到达数据库，带来巨大压力。

② 解决方案：

给不同的Key的TTL添加随机值
利用Redis集群提高服务的可用性
给缓存业务添加降级限流策略
给业务添加多级缓存

缓存击穿问题及解决思路

① 缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击。

逻辑分析：假设线程1在查询缓存之后，本来应该去查询数据库，然后把这个数据重新加载到缓存的，此时只要线程1走完这个逻辑，其他线程就都能从缓存中加载这些数据了，但是假设在线程1没有走完的时候，后续的线程2，线程3，线程4同时过来访问当前这个方法，那么这些线程都不能从缓存中查询到数据，那么他们就会同一时刻来访问查询缓存，都没查到，接着同一时间去访问数据库，同时的去执行数据库代码，对数据库访问压力过大。

② 解决方案：

1). 互斥锁

假设现在线程1过来访问，它查询缓存没有命中，但是此时它获得到了锁的资源，那么线程1就会一个人去执行逻辑，假设现在线程2过来，线程2在执行过程中，并没有获得到锁，那么线程2就可以进行到休眠，直到线程1把锁释放后，线程2获得到锁，然后再来执行逻辑，此时就能够从缓存中拿到数据了。

2). 逻辑过期

我们把过期时间设置在redis的value中，注意：这个过期时间并不会直接作用于redis，而是我们后续通过逻辑去处理。假设线程1去查询缓存，然后从value中判断出来当前的数据已经过期了，此时线程1去获得互斥锁，那么其他线程会进行阻塞，获得了锁的线程他会开启一个线程去进行以前的重构数据的逻辑，直到新开的线程完成这个逻辑后，才释放锁，而线程1直接进行返回，假设现在线程3过来访问，由于线程线程2持有着锁，所以线程3无法获得锁，线程3也直接返回数据，只有等到新开的线程2把重建数据构建完后，其他线程才能走返回正确的数据。

这种方案巧妙在于，异步的构建缓存，缺点在于在构建完缓存之前，返回的都是脏数据。

利用互斥锁解决缓存击穿问题

① 思路分析

核心思路就是利用redis的setnx方法来表示获取锁，该方法含义是redis中如果没有这个key，则插入成功，返回1，在stringRedisTemplate中返回true，如果有这个key则插入失败，则返回0，在stringRedisTemplate返回false，我们可以通过true，或者是false，来表示是否有线程成功插入key，成功插入的key的线程我们认为他就是获得到锁的线程。

② 代码实现

private boolean tryLock(String key) {
    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
    return BooleanUtil.isTrue(flag);
}

private void unlock(String key) {
    stringRedisTemplate.delete(key);
}

说明：

① setIfAbsent(key, "1", 10, TimeUnit.SECONDS)：Redis 的SETNX命令（不存在则设置），实现分布式锁：

如果 key 不存在，设置 key=1，过期时间 10 秒，返回true（加锁成功）；
如果 key 已存在，返回false（加锁失败）；
注意：返回值是Boolean（包装类），可能为 null（比如 Redis 连接超时 / 异常）；

② 为什么不用直接 return flag？

直接 return 可能出现NullPointerException（比如 flag=null 时），这个工具类帮你做了空值兜底，保证返回的是 boolean（基本类型），更安全。

利用逻辑过期解决缓存击穿问题

① 思路分析

当用户开始查询redis时，判断是否命中，如果没有命中则直接返回空数据，不查询数据库，而一旦命中后，将value取出，判断value中的过期时间是否满足，如果没有过期，则直接返回redis中的数据，如果过期，则在开启独立线程后直接返回之前的数据，独立线程去重构数据，重构完成后释放互斥锁。

② 代码实现

1). 新建一个实体类

@Data
public class RedisData {
    private LocalDateTime expireTime;
    private Object data;
}

2). ShopServiceImpl

private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
public Shop queryWithLogicalExpire( Long id ) {
    String key = CACHE_SHOP_KEY + id;
    // 1.从redis查询商铺缓存
    String json = stringRedisTemplate.opsForValue().get(key);
    // 2.判断是否存在
    if (StrUtil.isBlank(json)) {
        // 3.存在，直接返回
        return null;
    }
    // 4.命中，需要先把json反序列化为对象
    RedisData redisData = JSONUtil.toBean(json, RedisData.class);
    Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
    LocalDateTime expireTime = redisData.getExpireTime();
    // 5.判断是否过期
    if(expireTime.isAfter(LocalDateTime.now())) {
        // 5.1.未过期，直接返回店铺信息
        return shop;
    }
    // 5.2.已过期，需要缓存重建
    // 6.缓存重建
    // 6.1.获取互斥锁
    String lockKey = LOCK_SHOP_KEY + id;
    boolean isLock = tryLock(lockKey);
    // 6.2.判断是否获取锁成功
    if (isLock){
        CACHE_REBUILD_EXECUTOR.submit( ()->{

            try{
                //重建缓存
                this.saveShop2Redis(id,20L);
            }catch (Exception e){
                throw new RuntimeException(e);
            }finally {
                unlock(lockKey);
            }
        });
    }
    // 6.4.返回过期的商铺信息
    return shop;
}

说明：

① RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);

核心前提：RedisData 是一个自定义的封装类（你项目里肯定有这个类），作用是把 “业务数据（Shop）” 和 “逻辑过期时间” 打包存到 Redis 里。

② JSONObject data = (JSONObject) redisData.getData();

redisData.getData() 拿到的是 RedisData 里的 data 字段（类型是 Object），但这个字段实际存的是 Shop 对象的 JSON 格式数据，所以需要强转成 JSONObject（Hutool 工具类的 JSON 对象，也可以理解成 Map）。

封装Redis工具类

通用的缓存穿透解决方案

遵循 “先查缓存 → 缓存无则查数据库 → 数据库无则缓存空值 → 数据库有则缓存数据” 的逻辑，且通过泛型实现了 “通用化”

public  R queryWithPassThrough(String keyPrefix , ID id, Class type, Function dbFallback,
                                      Long time, TimeUnit unit) {  //不太理解
    String key = keyPrefix + id;

    String json = stringRedisTemplate.opsForValue().get(key);

    if (StrUtil.isNotBlank(json)) {
        return JSONUtil.toBean(json, type);
    }

    if (json != null) {  //不太理解
        return null;
    }

    R r = dbFallback.apply(id);
    if (r == null) {
        stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
        return null;
    }

    this.set(key, r, time, unit);

    return r;
}
Shop shop = cacheClient.queryWithPassThrough(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES); //不太理解

说明：

1). 先拆解方法签名

// 泛型定义： （和上一版一致）
// R = 返回值类型（如Shop、User、Goods），ID = 主键类型（如Long、Integer）
public  R queryWithPassThrough(
    String keyPrefix,       // 缓存key前缀（如"cache:shop:"、"cache:goods:"）
    ID id,                  // 要查询的主键（如店铺id=1、商品id=2）
    Class type,          // 返回值的类类型（如Shop.class、Goods.class）
    Function dbFallback,  // 数据库查询回调（传入id，返回业务数据）
    Long time,              // 新增：缓存有效数据的过期时间（数值）
    TimeUnit unit           // 新增：过期时间的单位（如分钟、小时，和time配合）
)

R：代表返回值类型（可以是 Shop、User、Goods 等任意业务类）；
ID：代表主键类型（可以是 Long、Integer、String 等）；

2). this::getById

语法含义：等价于一个 Lambda 表达式 (Long id) -> this.getById(id)，本质是 “把查询数据库的方法作为参数传给通用方法”；

通用化、适配所有业务的缓存击穿解决方案（逻辑过期策略）

// 1. 拼接通用缓存key（比如keyPrefix=cache:shop:，id=1 → key=cache:shop:1）
String key = keyPrefix + id;

// 2. 查Redis缓存：逻辑过期的前提是缓存里有数据（只是过期），如果缓存为空，直接返回null
String json = stringRedisTemplate.opsForValue().get(key);
if (StrUtil.isBlank(json)) { // 缓存为空（没存过/被删了），不是热点key，直接返回
    return null;
}

// 3. 反序列化：把Redis里的JSON转成封装了“数据+过期时间”的RedisData对象（核心！）
// Redis里存的不是单纯的Shop/User，而是RedisData的JSON（包含业务数据+逻辑过期时间）
RedisData redisData = JSONUtil.toBean(json, RedisData.class);
// 从RedisData中拆解出业务数据（比如Shop的JSON），转成JSONObject
JSONObject data = (JSONObject) redisData.getData();
// 把JSONObject转成泛型R（比如Shop、User）
R r = JSONUtil.toBean(data, type);
// 从RedisData中拆解出逻辑过期时间（不是Redis的TTL）
LocalDateTime expireTime = redisData.getExpireTime();

// 4. 判断是否逻辑过期：没过期→直接返回缓存数据，不走数据库
if (expireTime.isAfter(LocalDateTime.now())) {
    return r;
}

// 5. 已过期→尝试获取分布式锁（保证只有1个线程更新缓存）
String lockKey = LOCK_SHOP_KEY + id; // 锁key（比如lock:shop:1）
boolean isLock = tryLock(lockKey);   // 加锁（setIfAbsent）
if (isLock) { // 只有1个线程能拿到锁
    // 6. 异步重建缓存：用线程池执行，不阻塞当前请求
    CACHE_REBUILD_EXECUTOR.submit(() -> {
        try {
            // 6.1 查数据库（调用传入的dbFallback，比如this::getById）
            R r1 = dbFallback.apply(id);
            // 6.2 把新数据封装成RedisData，存入Redis（设置新的逻辑过期时间）
            this.setWithLogicalExpire(key, r1, time, unit);
        } catch (Exception e) {
            log.error("重建缓存失败", e); // 异常只打日志，不影响主线程
        } finally {
            unlock(lockKey); // 最终释放锁，避免死锁
        }
    });
}

// 7. 不管有没有拿到锁，都返回旧数据（核心！解决缓存击穿的关键）
return r;

说明：

1). dbFallback.apply(id) 是什么？

dbFallback是你调用方法时传入的 “数据库查询逻辑”，比如：

1 2	// 调用时传入this::getById（根据id查店铺） cacheClient.queryWithLogicalExpire(CACHE_SHOP_KEY, id, Shop.class, this::getById, 20L, TimeUnit.MINUTES);

dbFallback.apply(id) 就是执行this.getById(id)，查数据库获取最新的店铺数据 —— 泛型 + 函数式接口让这个方法适配所有业务的数据库查询。

优惠券秒杀

全局唯一ID

为了增加ID的安全性，我们不直接使用Redis自增的数值，而是拼接一些其它信息：

ID的组成部分：符号位：1bit，永远为0

时间戳：31bit，以秒为单位，可以使用69年

序列号：32bit，秒内的计数器，支持每秒产生2^32个不同ID

Redis实现全局唯一Id

RedisIdWorker

@Component
public class RedisIdWorker {
    /**
     * 开始时间戳
     */
    private static final long BEGIN_TIMESTAMP = 1640995200L;
    /**
     * 序列号的位数
     */
    private static final int COUNT_BITS = 32;

    private StringRedisTemplate stringRedisTemplate;

    public RedisIdWorker(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    public long nextId(String keyPrefix) {
        // 1.生成时间戳
        LocalDateTime now = LocalDateTime.now();
        long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
        long timestamp = nowSecond - BEGIN_TIMESTAMP;

        // 2.生成序列号
        // 2.1.获取当前日期，精确到天
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
        // 2.2.自增长
        long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);

        // 3.拼接并返回
        return timestamp << COUNT_BITS | count;
    }
}

说明：

① String date = now.format(DateTimeFormatter.ofPattern(“yyyy:MM:dd”));

按日期拆分 Redis 计数器的 Key，避免单个 Key 的计数器值无限增大（比如累计到几十亿，既占内存又不方便管理）；
让每个日期的计数器从1开始，减少 ID 的长度（如果全局一个计数器，数值会快速变大）；
方便按日期统计 / 清理数据（比如删除 30 天前的计数器 Key）。

举个例子：订单业务的 Key，2026-03-11 是icr:order:2026:03:11，2026-03-12 就变成icr:order:2026:03:12，每天的计数器独立。

② return timestamp << COUNT_BITS | count.longValue();

这是核心的位运算逻辑，目的是把「相对时间戳」和「每日计数器」拼接成一个完整的 ID。

timestamp << COUNT_BITS：把timestamp（相对时间戳）左移 32 位，放到 64 位long的高位区域；比如timestamp=100，左移 32 位后变成100 * 2^32（二进制就是 100 后面跟 32 个 0）；
count.longValue()：把 Redis 返回的计数器值转为long（因为返回的是Long包装类）；
|（按位或）：把高位的时间戳和低位的计数器拼接成一个数（因为两部分的二进制位不重叠，按位或等价于拼接）。

测试类

@Test
void testIdWorker() throws InterruptedException {
    CountDownLatch latch = new CountDownLatch(300);

    Runnable task = () -> {
        for (int i = 0; i < 100; i++) {
            long id = redisIdWorker.nextId("order");
            System.out.println("id = " + id);
        }
        latch.countDown();
    };
    long begin = System.currentTimeMillis();
    for (int i = 0; i < 300; i++) {
        es.submit(task);
    }
    latch.await();
    long end = System.currentTimeMillis();
    System.out.println("time = " + (end - begin));
}

说明：

CountDownLatch 的工作原理：

你（主线程）要统计 300 个工人（子线程）完成 “每人生产 100 个零件（生成 100 个 ID）” 的总耗时；
你先给工人发了一个 “倒计时牌”（CountDownLatch (300)），初始数字是 300；
每个工人完成自己的 100 个零件后，就把倒计时牌数字减 1（latch.countDown()）；
你站在旁边等（latch.await()），直到倒计时牌数字变成 0（所有工人都完成），才开始计算从开工到收工的总时间；
如果没有这个倒计时牌，你可能刚安排完工人就看表，此时工人还在干活，统计的时间毫无意义。

实现秒杀下单

思路分析

秒杀是否开始或结束，如果尚未开始或已经结束则无法下单
库存是否充足，不足则无法下单

① 当用户开始进行下单，我们应当去查询优惠卷信息，查询到优惠卷信息，判断是否满足秒杀条件。

② 比如时间是否充足，如果时间充足，则进一步判断库存是否足够，如果两者都满足，则扣减库存，创建订单，然后返回订单id，如果有一个条件不满足则直接结束。

代码实现

VoucherOrderServiceImpl

@Override
public Result seckillVoucher(Long voucherId) {
    // 1.查询优惠券
    SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
    // 2.判断秒杀是否开始
    if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
        // 尚未开始
        return Result.fail("秒杀尚未开始！");
    }
    // 3.判断秒杀是否已经结束
    if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
        // 尚未开始
        return Result.fail("秒杀已经结束！");
    }
    // 4.判断库存是否充足
    if (voucher.getStock() < 1) {
        // 库存不足
        return Result.fail("库存不足！");
    }
    //5，扣减库存
    boolean success = seckillVoucherService.update()
            .setSql("stock= stock -1")
            .eq("voucher_id", voucherId).update();
    if (!success) {
        //扣减库存
        return Result.fail("库存不足！");
    }
    //6.创建订单
    VoucherOrder voucherOrder = new VoucherOrder();
    // 6.1.订单id
    long orderId = redisIdWorker.nextId("order");
    voucherOrder.setId(orderId);
    // 6.2.用户id
    Long userId = UserHolder.getUser().getId();
    voucherOrder.setUserId(userId);
    // 6.3.代金券id
    voucherOrder.setVoucherId(voucherId);
    save(voucherOrder);

    return Result.ok(orderId);

}

说明：

① Resource private ISeckillVoucherService seckillVoucherService;

核心解释：这是 Spring 的依赖注入，目的是引入操作「秒杀优惠券表（SeckillVoucher）」的服务类。

ISeckillVoucherService：MyBatis-Plus 自动生成的服务接口，专门用于操作SeckillVoucher（秒杀优惠券）表，包含查询、修改、删除等方法；
为什么需要它：秒杀逻辑的第一步是查询优惠券的秒杀时间、库存等信息（这些存在SeckillVoucher表），所以必须注入这个服务来操作该表。

② 扣减库存的 update 链式调用

seckillVoucherService.update()
        .setSql("stock = stock - 1")
        .eq("voucher_id", voucherId)
        .update();

这是MyBatis-Plus 的链式更新语法，目的是扣减秒杀优惠券的库存，拆解每一步：

代码片段	作用
`seckillVoucherService.update()`	初始化 MyBatis-Plus 的更新构造器（UpdateWrapper）
`.setSql("stock = stock - 1")`	设置要执行的 SQL 片段：将库存字段减 1（直接写 SQL 片段，而非 set (“stock”, 具体值)，避免多线程下覆盖）
`.eq("voucher_id", voucherId)`	添加更新条件：只更新`voucher_id`等于传入的优惠券 ID 的记录
`.update()`	执行最终的更新操作，对应 SQL：`UPDATE seckill_voucher SET stock = stock - 1 WHERE voucher_id = ?`

库存超卖问题分析

存在的问题

假设线程1过来查询库存，判断出来库存大于1，正准备去扣减库存，但是还没有来得及去扣减，此时线程2过来，线程2也去查询库存，发现这个数量一定也大于1，那么这两个线程都会去扣减库存，最终多个线程相当于一起去扣减库存，此时就会出现库存的超卖问题。

解决方案（我们采用乐观锁）

① 乐观锁：会有一个版本号，每次操作数据会对版本号+1，再提交回数据时，会去校验是否比之前的版本大1 ，如果大1 ，则进行操作成功。这套机制的核心逻辑在于：如果在操作过程中，版本号只比原来大1 ，那么就意味着操作过程中没有人对它进行过修改，它的操作就是安全的，如果不大1，则数据被修改过，乐观锁还有一些变种的处理方式比如cas

② 代码实现

boolean success = seckillVoucherService.update()
        .setSql("stock = stock - 1")
        .eq("voucher_id", voucherId)
        .gt("stock",voucher.getStock())
        .update();

说明：

.gt("stock", voucher.getStock()) ✅ 核心防超卖逻辑

gt 是 greater than 的缩写，意为大于。
这是乐观锁 / 库存校验的关键：要求数据库中当前的库存值，必须大于代码中拿到的预期库存（voucher.getStock()）。
为什么能防超卖？多线程并发请求时，只有当数据库库存确实大于预期值时，才会执行扣减；如果某线程执行时库存已不足，该条件会直接失败，避免 stock 变成负数。

一人一单

版本1.0

@Transactional
public synchronized Result createVoucherOrder(Long voucherId) {

Long userId = UserHolder.getUser().getId();
         // 5.1.查询订单
        int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
        // 5.2.判断是否存在
        if (count > 0) {
            // 用户已经购买过了
            return Result.fail("用户已经购买过一次！");
        }

        // 6.扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1") // set stock = stock - 1
                .eq("voucher_id", voucherId).gt("stock", 0) // where id = ? and stock > 0
                .update();
        if (!success) {
            // 扣减失败
            return Result.fail("库存不足！");
        }

        // 7.创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        // 7.1.订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        // 7.2.用户id
        voucherOrder.setUserId(userId);
        // 7.3.代金券id
        voucherOrder.setVoucherId(voucherId);
        save(voucherOrder);

        // 7.返回订单id
        return Result.ok(orderId);
}

说明：

synchronized 修饰整个方法 → 全局串行，性能崩溃

1	public synchronized Result createVoucherOrder(Long voucherId) {

❌ 所有用户的秒杀请求都要排队执行（比如 1000 个用户下单，只能一个接一个处理）；

❌ 本来锁的目标是 “一人一单”（只锁单个用户），结果锁了所有用户，完全违背并发设计初衷。

版本2.0

@Transactional
public  Result createVoucherOrder(Long voucherId) {
Long userId = UserHolder.getUser().getId();
synchronized(userId.toString().intern()){
         // 5.1.查询订单
        int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
        // 5.2.判断是否存在
        if (count > 0) {
            // 用户已经购买过了
            return Result.fail("用户已经购买过一次！");
        }

        // 6.扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1") // set stock = stock - 1
                .eq("voucher_id", voucherId).gt("stock", 0) // where id = ? and stock > 0
                .update();
        if (!success) {
            // 扣减失败
            return Result.fail("库存不足！");
        }

        // 7.创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        // 7.1.订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        // 7.2.用户id
        voucherOrder.setUserId(userId);
        // 7.3.代金券id
        voucherOrder.setVoucherId(voucherId);
        save(voucherOrder);

        // 7.返回订单id
        return Result.ok(orderId);
    }
}

说明：

锁在事务内 → 一人一单规则仍失效，锁的释放时机早于事务提交时机，导致 “一人一单” 规则被突破。

① @Transactional 注解的方法，其事务提交时机是「整个方法执行完毕、返回结果后」，而 synchronized 锁的释放时机是「代码块执行完毕」。

② 真实执行时序（以同一个用户的两个并发请求为例）：

线程A（用户1）执行步骤：
1. 获取用户1的锁 → 2. 查订单（count=0）→ 3. 扣库存 → 4. 创订单 → 5. 释放锁（synchronized代码块执行完）→ 6. Spring提交事务（订单真正入库）

线程B（用户1，线程A释放锁后立即执行）：
1. 获取用户1的锁 → 2. 查订单（此时线程A的事务还没提交，数据库中无订单，count=0）→ 3. 重复下单 → 4. 释放锁 → 5. Spring提交事务

最终结果：用户 1 会创建两个订单，“一人一单” 的核心规则完全失效。

版本3.0

synchronized (userId.toString().intern()) {
    // 1. 获取 Spring 的代理对象
    IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
    // 2. 通过代理对象调用
    return proxy.createVoucherOrder(voucherId);
}

说明：

保证事务生效：通过 proxy 调用，Spring 代理对象会拦截方法，开启事务、提交 / 回滚，数据一致性得到保证。
保证一人一单：锁还在外层，释放锁前事务一定提交，并发安全性得到保证。

集群环境下的并发问题

同一个用户（比如用户 100），同时发送请求到 服务器 A 和 服务器 B。

服务器 A 拿到锁，正在查库存 → 库存充足 → 准备扣减。
服务器 B 拿到锁，正在查库存 → 库存充足 → 准备扣减。
原因：服务器 A 的锁只认识服务器 A 里的线程，它根本不知道服务器 B 里还有个线程在抢同一个资源。
结果：两个服务器同时执行了扣减逻辑，导致了超卖，且同一个用户买了 两份订单（一人多单）。

分布式锁

Redis 实现分布式锁版统一

SimpleRedisLock

private static final String KEY_PREFIX="lock:"
@Override
public boolean tryLock(long timeoutSec) {
    // 获取线程标示
    long threadId = Thread.currentThread().getId()
    // 获取锁
    Boolean success = stringRedisTemplate.opsForValue()
            .setIfAbsent(KEY_PREFIX + name, threadId + "", timeoutSec, TimeUnit.SECONDS);
    return Boolean.TRUE.equals(success);
}

说明：

① .setIfAbsent(KEY_PREFIX + name, threadId + “”, timeoutSec, TimeUnit.SECONDS);

1). setIfAbsent 对应 Redis 的 SETNX 命令，核心逻辑是：如果 key 不存在，则设置值并返回 true；如果 key 已存在，则直接返回 false—— 这是实现分布式锁 “互斥性” 的核心（保证同一时间只有一个线程能拿到锁）。

2). threadId + "" 的小细节，Thread.currentThread().getId() 返回的是 long 原始类型，而 Redis 操作的 value 必须是 String 类型。拼接空字符串是最简洁的语法糖，能将 long 强制转为 String，满足 setIfAbsent 的参数类型要求。等价效果：String.valueOf(threadId)，但写法更简洁。

② 为什么自动拆箱有风险？Boolean.TRUE.equals(success) 好在哪？

1). 代码中 Boolean success = ... 定义的是包装类 Boolean 对象，如果直接写 return success;，会触发 自动拆箱（将 Boolean 转为 boolean 原始类型）。

当 Redis 操作异常 / 返回 null 时，success 会是 null；
此时拆箱过程会尝试把 null 转为 boolean，直接抛出 NullPointerException，导致程序崩溃。

2). Boolean.TRUE.equals(success) 的核心优势

Boolean.TRUE 是 Boolean 类的单例常量，调用其 equals() 方法时，内部自带 null 校验逻辑；
无论 success 是 null、Boolean.FALSE 还是 Boolean.TRUE，都能安全返回结果：

`success` 取值	`return success;`（直接拆箱）	`return Boolean.TRUE.equals(success);`
`null`	抛 `NullPointerException`	返回 `false`
`Boolean.FALSE`	抛 `NullPointerException`	返回 `false`
`Boolean.TRUE`	正常返回 `true`	返回 `true`

修改业务代码

@Override
  public Result seckillVoucher(Long voucherId) {
      // 1.查询优惠券
      SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
      // 2.判断秒杀是否开始
      if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
          // 尚未开始
          return Result.fail("秒杀尚未开始！");
      }
      // 3.判断秒杀是否已经结束
      if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
          // 尚未开始
          return Result.fail("秒杀已经结束！");
      }
      // 4.判断库存是否充足
      if (voucher.getStock() < 1) {
          // 库存不足
          return Result.fail("库存不足！");
      }
      Long userId = UserHolder.getUser().getId();
      //创建锁对象(新增代码)
      SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);
      //获取锁对象
      boolean isLock = lock.tryLock(1200);
//加锁失败
      if (!isLock) {
          return Result.fail("不允许重复下单");
      }
      try {
          //获取代理对象(事务)
          IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
          return proxy.createVoucherOrder(voucherId);
      } finally {
          //释放锁
          lock.unlock();
      }
  }

Redis分布式锁误删情况说明

存在的问题

线程 1成功获取锁，开始执行业务
线程 1 遇到阻塞（比如 JVM GC 垃圾回收、CPU 繁忙），导致业务执行超时 → Redis 锁自动过期释放。
线程 2刚好来抢锁，成功获取锁，开始执行自己的业务。
线程 1恢复执行，业务做完了，它不知道锁已经过期被线程 2 拿走了，直接执行「删除锁」逻辑 → 误删线程 2 的锁。

解决方案

① 核心逻辑：在存入锁时，放入自己线程的标识。在删除锁时，判断当前这把锁的标识是不是自己存入的，如果是，则进行删除，如果不是，则不进行删除。

② 代码实现

加锁

private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";
@Override
public boolean tryLock(long timeoutSec) {
   // 获取线程标示
   String threadId = ID_PREFIX + Thread.currentThread().getId();
   // 获取锁
   Boolean success = stringRedisTemplate.opsForValue()
                .setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
   return Boolean.TRUE.equals(success);
}

释放锁

public void unlock() {
    // 获取线程标示
    String threadId = ID_PREFIX + Thread.currentThread().getId();
    // 获取锁中的标示
    String id = stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
    // 判断标示是否一致
    if(threadId.equals(id)) {
        // 释放锁
        stringRedisTemplate.delete(KEY_PREFIX + name);
    }
}

分布式锁的原子性问题

我们结合线程 1、线程 2 的动作，一步步拆解：

时间节点	线程 1 动作	线程 2 动作	Redis 锁状态	关键变化
1	持有锁（value = 线程 1ID），执行业务	阻塞等待锁	存在（属于线程 1）	线程 1 正常拿锁
2	执行到解锁步骤，先`get`锁，发现 value 是自己的 ID，进入`if`判断	等待	存在（属于线程 1）	线程 1 完成 “验证”，还没执行 delete
3	线程 1 突然卡顿 / GC（CPU 切换）	无	锁过期自动释放	致命点！锁因为超时被 Redis 回收，线程 1 还没删
4	卡顿中	尝试抢锁，成功获取锁（value = 线程 2ID），开始执行业务	存在（属于线程 2）	线程 2 拿到了锁，业务正在跑
5	线程 1 恢复执行	执行业务中	存在（属于线程 2）	线程 1 从`if`里继续往下走，直接执行`delete`
6	完成删除	业务中	被删空	线程 1 把线程 2 的锁删了！线程 2 的业务还没做完，锁没了

核心后果：线程 1 明明做了 “验证归属” 的判断，却依然误删了线程 2 的锁 —— 因为验证和删除中间被打断了。

利用Java代码调用Lua脚本改造分布式锁

private static final DefaultRedisScript UNLOCK_SCRIPT;
    static {
        UNLOCK_SCRIPT = new DefaultRedisScript<>();
        UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
        UNLOCK_SCRIPT.setResultType(Long.class);
    }

public void unlock() {
    // 调用lua脚本
    stringRedisTemplate.execute(
            UNLOCK_SCRIPT,
            Collections.singletonList(KEY_PREFIX + name),
            ID_PREFIX + Thread.currentThread().getId());
}
经过以上代码改造后，我们就能够实现 拿锁比锁删锁的原子性动作了~

说明：

① 静态代码块：加载 Lua 脚本

static final：脚本只需要加载一次，类加载时初始化，高效复用
DefaultRedisScript：Spring Data Redis 提供的封装类，用来和 Redis 模板配合执行 Lua 脚本
脚本位置：unlock.lua 放在项目 resources 文件夹下，里面就是 “判断 + 删除” 的逻辑

② unlock () 方法：执行 Lua 脚本释放锁

参数 1：UNLOCK_SCRIPT → 刚才加载好的脚本对象
参数 2：Collections.singletonList(KEY_PREFIX + name) → 脚本里的 KEYS[1]，就是锁的 key（比如 lock:order）
参数 3：ID_PREFIX + Thread.currentThread().getId() → 脚本里的 ARGV[1]，就是当前线程的唯一标识（用来和锁里存的 value 对比）

分布式锁-redission

存在的问题

不可重入：

// 方法A加了分布式锁
public void methodA() {
    lock(); // 线程拿到锁
    methodB(); // 方法B也加了同一个分布式锁
    unlock();
}

// 方法B也加了同一个分布式锁
public void methodB() {
    lock(); // 同一个线程再次申请锁，被拒绝 → 死锁
    // ...业务
    unlock();
}

线程执行methodA拿到锁后，调用methodB时，再次尝试拿同一个锁，这时候分布式锁会认为 “锁已经被别人占了”，导致线程自己阻塞自己，形成死锁。

不可重试：

现在的setnx实现，线程尝试拿锁一次，如果失败（返回false），就直接结束了，没有 “再试一次” 的机制。但实际业务里（比如秒杀、订单创建），锁竞争往往是短暂的，线程应该可以重试几次，提高拿到锁的成功率。

超时释放：

我们给锁加了过期时间（比如 30 秒），本来是为了防止 “服务挂了锁不释放” 导致死锁，但带来了新问题：如果业务执行时间超过了锁的过期时间，锁会自动释放，这时候其他线程就能拿到锁，操作同一个资源，导致数据不一致。

主从一致性：

① Redis 主从集群的原理

主节点（Master）：负责写操作（加锁、解锁）
从节点（Slave）：负责读操作，主节点的数据会异步同步到从节点
如果主节点挂了，集群会把一个从节点升级为新的主节点

② 问题场景

线程 A 向主节点加锁成功，主节点还没把这个锁数据同步到从节点
主节点突然宕机了
集群选举一个从节点成为新主节点，但这个新主节点没有刚才的锁数据，认为锁不存在
线程 B 来拿锁，直接成功，这时候就出现了两个线程同时持有同一个锁的情况，锁失效，并发安全问题爆发。

Redission快速入门

配置Redisson客户端

@Configuration
public class RedissonConfig {

    @Bean
    public RedissonClient redissonClient(){
        // 配置
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.150.101:6379")
            .setPassword("123321");
        // 创建RedissonClient对象
        return Redisson.create(config);
    }
}

如何使用Redission的分布式锁

@Resource
private RedissionClient redissonClient;

@Test
void testRedisson() throws Exception{
    //获取锁(可重入)，指定锁的名称
    RLock lock = redissonClient.getLock("anyLock");
    //尝试获取锁，参数分别是：获取锁的最大等待时间(期间会重试)，锁自动释放时间，时间单位
    boolean isLock = lock.tryLock(1,10,TimeUnit.SECONDS);
    //判断获取锁成功
    if(isLock){
        try{
            System.out.println("执行业务");          
        }finally{
            //释放锁
            lock.unlock();
        }
        
    }
}

VoucherOrderServiceImpl

@Resource
private RedissonClient redissonClient;

@Override
public Result seckillVoucher(Long voucherId) {
        // 1.查询优惠券
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
        // 2.判断秒杀是否开始
        if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
            // 尚未开始
            return Result.fail("秒杀尚未开始！");
        }
        // 3.判断秒杀是否已经结束
        if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
            // 尚未开始
            return Result.fail("秒杀已经结束！");
        }
        // 4.判断库存是否充足
        if (voucher.getStock() < 1) {
            // 库存不足
            return Result.fail("库存不足！");
        }
        Long userId = UserHolder.getUser().getId();
        //创建锁对象 这个代码不用了，因为我们现在要使用分布式锁
        //SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);
        RLock lock = redissonClient.getLock("lock:order:" + userId);
        //获取锁对象
        boolean isLock = lock.tryLock();
       
//加锁失败
        if (!isLock) {
            return Result.fail("不允许重复下单");
        }
        try {
            //获取代理对象(事务)
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        } finally {
            //释放锁
            lock.unlock();
        }
 }

redission可重入锁原理

3 个核心参数

参数	含义	作用
`KEYS[1]`	锁的大 key（锁名称）	代表这把锁的整体，用来判断锁是否存在
`ARGV[1]`	锁的过期时间（毫秒）	防止锁死锁，即使客户端宕机也会自动释放
`ARGV[2]`	锁的小 key（持有者标识）	格式：`客户端ID + ":" + 线程ID`，用来判断锁是否属于当前线程

脚本的核心逻辑

-- 步骤1：锁不存在 → 直接加锁
if (redis.call('exists', KEYS[1]) == 0) then
    redis.call('hset', KEYS[1], ARGV[2], 1);  -- 新建hash锁，小key对应值=1（第一次持有）
    redis.call('pexpire', KEYS[1], ARGV[1]); -- 给锁设置过期时间
    return nil; -- 返回nil = 加锁成功
end;

-- 步骤2：锁存在，但属于当前线程 → 可重入
if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then
    redis.call('hincrby', KEYS[1], ARGV[2], 1); -- 重入次数+1
    redis.call('pexpire', KEYS[1], ARGV[1]);    -- 刷新过期时间
    return nil; -- 返回nil = 重入成功
end;

-- 步骤3：锁存在且不属于当前线程 → 抢锁失败
return redis.call('pttl', KEYS[1]); -- 返回锁的剩余过期时间

redission锁重试和WatchDog机制

Lua 抢锁逻辑

条件	操作	返回值	含义
锁不存在	插入锁（Hash 结构），设置过期时间	`null`	抢锁成功
锁存在且属于当前线程	重入次数 + 1，刷新过期时间	`null`	可重入成功
锁存在且不属于当前线程	无操作	锁的剩余过期时间（ttl）	抢锁失败

lock() 核心抢锁流程

long threadId = Thread.currentThread().getId();
Long ttl = tryAcquire(-1, leaseTime, unit, threadId);
// lock acquired
if (ttl == null) {
    return;
}

说明：

① Long ttl = tryAcquire(-1, leaseTime, unit, threadId);

-1：是 waitTime 的默认值（表示无限等待，直到抢到锁）；
leaseTime：锁的过期时间（无参 lock() 时默认 -1，带参 lock(10, TimeUnit.SECONDS) 时为 10）；
unit：时间单位（如 TimeUnit.MILLISECONDS）；
threadId：当前线程 ID。

② 返回值 ttl：

null → 抢锁 / 可重入成功；
非 null 数字 → 锁被其他线程持有，返回锁的剩余过期时间（比如返回 20000 代表锁还有 20 秒过期）。

WatchDog（看门狗）续约机制

RFuture ttlRemainingFuture = tryLockInnerAsync(waitTime,
                                        commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(),
                                        TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
ttlRemainingFuture.onComplete((ttlRemaining, e) -> {
    if (e != null) {
        return;
    }

    // lock acquired
    if (ttlRemaining == null) {
        scheduleExpirationRenewal(threadId);
    }
});
return ttlRemainingFuture;

说明：

① tryLockInnerAsync(...) 的第二个参数：commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout()

含义：获取 Redisson 配置的「看门狗默认超时时间」，默认值是 30 秒（30000 毫秒）；
作用：把锁的初始过期时间设为 30 秒（替代用户传入的 leaseTime）。

② if (ttlRemaining == null) { scheduleExpirationRenewal(threadId); }

逻辑：只有抢锁成功（ttlRemaining=null），才调用 scheduleExpirationRenewal(threadId)；
scheduleExpirationRenewal：核心作用是「启动看门狗续约线程」，是连接抢锁和续约的关键方法。

redission锁的MutiLock原理

存在的问题

我们去写命令，写在主机上，主机会将数据同步给从机，但是假设在主机还没有来得及把数据写入到从机去的时候，此时主机宕机，哨兵会发现主机宕机，并且选举一个slave变成master，而此时新的master中实际上并没有锁信息，此时锁信息就已经丢掉了。

解决方案

为了解决这个问题，redission提出来了MutiLock锁，使用这把锁就不使用主从了，每个节点的地位都是一样的，这把锁加锁的逻辑需要写入到每一个主丛节点上，只有所有的服务器都写入成功，此时才是加锁成功。假设现在某个节点挂了，那么它去获得锁的时候，只要有一个节点拿不到，都不能算是加锁成功，就保证了加锁的可靠性。

秒杀优化

异步秒杀思路

(1) 当用户下单之后，判断库存是否充足只需要到redis中去根据key找对应的value是否大于0即可。如果不充足，则直接结束，如果充足，继续在redis中判断用户是否可以下单，如果set集合中没有这条数据，说明它可以下单，如果set集合中没有这条记录，则将userId和优惠卷存入到redis中，并且返回0，整个过程需要保证是原子性的，我们可以使用lua来操作。

(2) 校验通过后，无需等待完整下单流程完成，直接给用户返回 “下单受理成功”（附带订单 ID），同时将下单任务丢入异步队列；后台单独线程消费异步队列中的任务，慢慢执行完整的数据库下单逻辑（创建订单、扣减库存等）；前端通过返回的订单 ID，查询异步下单的最终结果（成功 / 失败）。

Redis完成秒杀资格判断

需求

新增秒杀优惠券的同时，将优惠券信息保存到Redis中
基于Lua脚本，判断秒杀库存、一人一单，决定用户是否抢购成功
如果抢购成功，将优惠券id和用户id封装后存入阻塞队列
开启线程任务，不断从阻塞队列中获取信息，实现异步下单功能

代码实现

完整lua表达式

-- 1.参数列表
-- 1.1.优惠券id
local voucherId = ARGV[1]
-- 1.2.用户id
local userId = ARGV[2]
-- 1.3.订单id
local orderId = ARGV[3]

-- 2.数据key
-- 2.1.库存key
local stockKey = 'seckill:stock:' .. voucherId
-- 2.2.订单key
local orderKey = 'seckill:order:' .. voucherId

-- 3.脚本业务
-- 3.1.判断库存是否充足 get stockKey
if(tonumber(redis.call('get', stockKey)) <= 0) then
    -- 3.2.库存不足，返回1
    return 1
end
-- 3.2.判断用户是否下单 SISMEMBER orderKey userId
if(redis.call('sismember', orderKey, userId) == 1) then
    -- 3.3.存在，说明是重复下单，返回2
    return 2
end
-- 3.4.扣库存 incrby stockKey -1
redis.call('incrby', stockKey, -1)
-- 3.5.下单（保存用户）sadd orderKey userId
redis.call('sadd', orderKey, userId)
-- 3.6.发送消息到队列中， XADD stream.orders * k1 v1 k2 v2 ...
redis.call('xadd', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', orderId)
return 0

说明：

① Lua 里的 .. 是什么

.. 是 Lua 语言的字符串拼接运算符，作用和 Java 里用 + 拼接字符串（比如 "a" + "b"）完全一样，只是语法不同。

② if(tonumber(redis.call(‘get’, stockKey)) <= 0) then return 1 end

tonumber() 是 Lua 的内置函数，作用是把字符串类型的数字转成数值类型；

VoucherOrderServiceImpl

@Override
public Result seckillVoucher(Long voucherId) {
    //获取用户
    Long userId = UserHolder.getUser().getId();
    long orderId = redisIdWorker.nextId("order");
    // 1.执行lua脚本
    Long result = stringRedisTemplate.execute(
            SECKILL_SCRIPT,
            Collections.emptyList(),
            voucherId.toString(), userId.toString(), String.valueOf(orderId)
    );
    int r = result.intValue();
    // 2.判断结果是否为0
    if (r != 0) {
        // 2.1.不为0 ，代表没有购买资格
        return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
    }
    //TODO 保存阻塞队列
    // 3.返回订单id
    return Result.ok(orderId);
}

基于阻塞队列实现秒杀优化

//异步处理线程池
private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();

//在类初始化之后执行，因为当这个类初始化好了之后，随时都是有可能要执行的
@PostConstruct
private void init() {
   SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
}
// 用于线程池处理的任务
// 当初始化完毕后，就会去从对列中去拿信息
 private class VoucherOrderHandler implements Runnable{

        @Override
        public void run() {
            while (true){
                try {
                    // 1.获取队列中的订单信息
                    VoucherOrder voucherOrder = orderTasks.take();
                    // 2.创建订单
                    handleVoucherOrder(voucherOrder);
                } catch (Exception e) {
                    log.error("处理订单异常", e);
                }
           }
        }
     
       private void handleVoucherOrder(VoucherOrder voucherOrder) {
            //1.获取用户
            Long userId = voucherOrder.getUserId();
            // 2.创建锁对象
            RLock redisLock = redissonClient.getLock("lock:order:" + userId);
            // 3.尝试获取锁
            boolean isLock = redisLock.lock();
            // 4.判断是否获得锁成功
            if (!isLock) {
                // 获取锁失败，直接返回失败或者重试
                log.error("不允许重复下单！");
                return;
            }
            try {
//注意：由于是spring的事务是放在threadLocal中，此时的是多线程，事务会失效
                proxy.createVoucherOrder(voucherOrder);
            } finally {
                // 释放锁
                redisLock.unlock();
            }
    }
     //a
private BlockingQueue orderTasks =new  ArrayBlockingQueue<>(1024 * 1024);

    @Override
    public Result seckillVoucher(Long voucherId) {
        Long userId = UserHolder.getUser().getId();
        long orderId = redisIdWorker.nextId("order");
        // 1.执行lua脚本
        Long result = stringRedisTemplate.execute(
                SECKILL_SCRIPT,
                Collections.emptyList(),
                voucherId.toString(), userId.toString(), String.valueOf(orderId)
        );
        int r = result.intValue();
        // 2.判断结果是否为0
        if (r != 0) {
            // 2.1.不为0 ，代表没有购买资格
            return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
        }
        VoucherOrder voucherOrder = new VoucherOrder();
        // 2.3.订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        // 2.4.用户id
        voucherOrder.setUserId(userId);
        // 2.5.代金券id
        voucherOrder.setVoucherId(voucherId);
        // 2.6.放入阻塞队列
        orderTasks.add(voucherOrder);
        //3.获取代理对象
         proxy = (IVoucherOrderService)AopContext.currentProxy();
        //4.返回订单id
        return Result.ok(orderId);
    }
     
      @Transactional
    public  void createVoucherOrder(VoucherOrder voucherOrder) {
        Long userId = voucherOrder.getUserId();
        // 5.1.查询订单
        int count = query().eq("user_id", userId).eq("voucher_id", voucherOrder.getVoucherId()).count();
        // 5.2.判断是否存在
        if (count > 0) {
            // 用户已经购买过了
           log.error("用户已经购买过了");
           return ;
        }

        // 6.扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1") // set stock = stock - 1
                .eq("voucher_id", voucherOrder.getVoucherId()).gt("stock", 0) // where id = ? and stock > 0
                .update();
        if (!success) {
            // 扣减失败
            log.error("库存不足");
            return ;
        }
        save(voucherOrder);
 
    }

说明：

① private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();

这是 Java 的线程池，Executors.newSingleThreadExecutor() 会创建一个「只有 1 个工作线程」的线程池 —— 所有任务都由这 1 个线程按顺序处理。

② @PostConstruct private void init() { SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler()); }

@PostConstruct：Spring 注解，作用是「当前类被 Spring 初始化完成后（项目启动时），立即执行这个方法」；

③ private class VoucherOrderHandler implements Runnable { … }

这是一个内部线程任务类，实现了 Runnable 接口（Java 中 “可被线程执行的任务” 都要实现这个接口），里面的 run() 方法是线程要执行的核心逻辑。

Postman测试方法

发送验证码（不需要登录）

(1) 请求方式：POST

(2) 直连后端：http://localhost:8082/user/code?phone=13100000000

(3) 预期响应

1
2
3

{
  "success": true
}

登录获取 token

(1) 请求方式：POST

(2) 直连后端：http://localhost:8082/user/login

(3) Body（选择 raw，格式 JSON）：

{
  "phone": "13100000000",
  "code": "518208"
}

注意：code 是第一步发送验证码后，在控制台日志里看到的 6 位数字

(4) 预期响应

1	"1c3e03a8a5734dd1a8a5285c0d49a63c"

这个字符串就是 token，复制保存下来

测试登录状态（验证 token 是否有效）

(1) 请求方式：GET

(2) 直连后端：http://localhost:8082/user/me

(3) Headers：

authorization: 1c3e03a8a5734dd1a8a5285c0d49a63c

(4) 预期响应

{
  "success": true,
  "data": {
    "id": 1,
    "nickName": "user_xxx",
    "icon": "..."
  }
}

秒杀下单（需要登录）

(1) 请求方式：POST

(2) 直连后端：http://localhost:8082/voucher-order/seckill/10

(3) Headers：

authorization: 1c3e03a8a5734dd1a8a5285c0d49a63c

(4) Body：不需要

(5) 可能响应：

{
  "success": true,
  "data": 1234567890
}

JMeter使用方法

添加线程组

(1) 右键 “测试计划” → 添加 → 线程(用户) → 线程组

(2) 配置

线程数(用户数)：并发用户数（如 100）
Ramp-Up时间(秒)：启动时间（如 10）
循环次数：每个线程执行次数（如 1）

添加 HTTP 请求

(1) 右键 “线程组” → 添加 → 取样器 → HTTP 请求

(2) 配置：

名称：秒杀下单（自定义）
服务器名称或IP：localhost（或后端服务器IP）
端口号：8081（或你的后端端口）
方法：POST
路径：/voucher-order/seckill/10（你的秒杀接口路径）

添加 HTTP 信息头管理器

(1) 右键 “线程组” → 添加 → 配置元件 → HTTP 信息头管理器

(2) 配置：

名称：authorization
值：你的登录token（例如：1c3e03a8a5734dd1a8a5285c0d49a63c）

添加监听器（查看结果）

右键 “线程组” → 添加 → 监听器 → 选择：

察看结果树：查看每个请求的详细响应（调试用）
汇总报告：查看统计信息（吞吐量、错误率等）
聚合报告：更详细的性能报告

运行测试

点击顶部工具栏的绿色“启动”按钮

消息队列

为什么使用消息队列

阻塞队列是 JVM 内存内的本地队列，只适合「单机、简单场景」，实际项目中处处受限：

只能单机使用，不支持分布式

阻塞队列存储在单个 JVM 进程内存中，多机集群部署时队列无法共享：不同服务器的阻塞队列相互隔离，任务无法在集群间负载均衡，导致部分机器任务堆积、部分机器空闲，资源利用率极低。

消息无持久化，宕机就丢

阻塞队列的任务仅存在内存中，服务重启、宕机或 OOM 时，未处理的消息会全部丢失：在秒杀等核心业务中，这会导致用户已成功下单但订单数据丢失，引发资损和客诉。

认识消息队列

消息队列：存储和管理消息，也被称为消息代理（Message Broker）
生产者：发送消息到消息队列
消费者：从消息队列获取消息并处理消息

基于List实现消息队列（了解即可）

实现原理

队列是入口和出口不在一边，因此我们可以利用：LPUSH 结合 RPOP、或者 RPUSH 结合 LPOP来实现。当队列中没有消息时，RPOP或LPOP操作会返回null，并不像JVM的阻塞队列那样会阻塞并等待消息。因此这里应该使用BRPOP或者BLPOP来实现阻塞效果。

优缺点

① 优点：

利用Redis存储，不受限于JVM内存上限
基于Redis的持久化机制，数据安全性有保证
可以满足消息有序性

② 缺点：

无法避免消息丢失
只支持单消费者

基于PubSub的消息队列（了解即可）

实现原理

SUBSCRIBE channel [channel] ：订阅一个或多个频道

PUBLISH channel msg ：向一个频道发送消息

PSUBSCRIBE pattern[pattern] ：订阅与pattern格式匹配的所有频道

优缺点

① 优点：

采用发布订阅模型，支持多生产、多消费

② 缺点：

不支持数据持久化
无法避免消息丢失
消息堆积有上限，超出时数据丢失

基于Stream的消息队列（推荐）

发送消息：XADD 命令

1	XADD key [NOMKSTREAM] [MAXLEN\|MINID [=\|~] threshold [LIMIT count]] *\|ID field value [field value ...]

说明：

key：消息队列名称，队列不存在时默认自动创建（NOMKSTREAM 可禁止自动创建）。
MAXLEN|MINID：用于限制队列的最大消息数量。
*：让 Redis 自动生成消息 ID（格式：时间戳-递增数字，如 1644805700523-0）；也可手动指定 ID。
消息内容：由多个 field value 键值对组成（称为 Entry）。

示例：

1 2	# 创建名为 users 的队列，发送消息 {name: jack, age: 21}，自动生成 ID XADD users * name jack age 21

读取消息：XREAD 命令

1	XREAD [COUNT count] [BLOCK milliseconds] STREAMS key [key ...] ID [ID ...]

说明：

① COUNT count：每次读取的最大消息数量。

② BLOCK milliseconds：阻塞模式，无消息时阻塞等待，超时后返回 (nil)。

③ STREAMS key：指定要读取的队列名称。

④ ID：起始读取 ID，仅返回大于该 ID 的消息：

0：从队列第一个消息开始读取。
$：从队列最新消息开始读取。

示例：

① 读取历史消息：指定起始 ID 为 0，从队列第一条消息开始读取。

1	XREAD COUNT 1 STREAMS users 0

② 阻塞读取最新消息：指定起始 ID 为 $，配合 BLOCK 实现阻塞等待，无消息时超时返回 (nil)

1	XREAD COUNT 1 BLOCK 1000 STREAMS users $

关键注意点

使用 $ 读取最新消息时存在漏读风险：若处理当前消息期间，队列新增了多条消息，下次调用只会获取到最新的一条，中间新增的消息会被跳过。

基于Stream的消息队列-消费者组

创建消费者组

1	XGROUP CREATE key groupName ID [MKSTREAM]

说明：

key：队列名称
groupName：消费者组名称
ID：起始ID标示，$代表队列中最后一个消息，0则代表队列中第一个消息
MKSTREAM：队列不存在时自动创建队列

删除指定的消费者组

1	XGROUP DESTORY key groupName

给指定的消费者组添加消费者

1	XGROUP CREATECONSUMER key groupname consumername

从消费者组读取消息：

1	XREADGROUP GROUP group consumer [COUNT count] [BLOCK milliseconds] [NOACK] STREAMS key [key ...] ID [ID ...]

说明：

group：消费组名称
consumer：消费者名称，如果消费者不存在，会自动创建一个消费者
count：本次查询的最大数量
BLOCK milliseconds：当没有消息时最长等待时间
NOACK：无需手动ACK，获取到消息后自动确认（一般不要添加这个）
STREAMS key：指定队列名称
ID：获取消息的起始ID：
- “>”：从下一个未消费的消息开始
- 其它：根据指定id从pending-list中获取已消费但未确认的消息，例如0，是从pending-list中的第一个消息开始

Redis Stream 消费者组可靠消费 的核心逻辑

while(true){
    // 1. 阻塞读取消费者组g1中消费者c1的新消息（队列s1，阻塞2000ms，每次读1条）
    Object msg = redis.call("XREADGROUP GROUP g1 c1 COUNT 1 BLOCK 2000 STREAMS s1 >");
    if(msg == null){
        continue; // 无新消息，继续循环监听
    }
    
    try {
        // 2. 执行业务逻辑处理消息
        handleMessage(msg);
        
        // 【图片中省略但必须加】处理成功后调用XACK确认
        // redis.call("XACK s1 g1 " + msgId);
        
    } catch(Exception e) {
        // 3. 处理失败时，循环重试pending-list中的未确认消息
        while(true){
            // 读取pending-list中已分配但未确认的消息（从ID=0开始）
            Object msg = redis.call("XREADGROUP GROUP g1 c1 COUNT 1 STREAMS s1 0");
            if(msg == null){
                break; // 无未确认消息，退出重试循环
            }
            
            try {
                // 重新处理异常消息
                handleMessage(msg);
                
                // 【图片中省略但必须加】重试成功后ACK确认
                // redis.call("XACK s1 g1 " + msgId);
                
            } catch(Exception e) {
                // 再次失败则继续重试（也可加重试次数限制）
                continue;
            }
        }
    }
}

说明：

① 必须 ACK：处理成功后，要调用 XACK 命令告诉 Redis “这条消息我处理完了”，消息会从 pending-list（未确认消息列表）中移除。

② Object msg = redis.call(“XREADGROUP GROUP g1 c1 COUNT 1 STREAMS s1 0”);

0 代表从 pending-list 中读取已分配但未确认的消息，也就是之前处理失败的那条。
这是为了不丢失消息，保证失败的消息会被反复重试，直到处理成功。

基于Redis的Stream结构作为消息队列，实现异步秒杀下单

需求

创建一个Stream类型的消息队列，名为stream.orders
修改之前的秒杀下单Lua脚本，在认定有抢购资格后，直接向stream.orders中添加消息，内容包含voucherId、userId、orderId
项目启动时，开启一个线程任务，尝试获取stream.orders中的消息，完成下单

VoucherOrderServiceImpl

private class VoucherOrderHandler implements Runnable {

    @Override
    public void run() {
        while (true) {
            try {
                // 1.获取消息队列中的订单信息 XREADGROUP GROUP g1 c1 COUNT 1 BLOCK 2000 STREAMS s1 >
                List> list = stringRedisTemplate.opsForStream().read(
                    Consumer.from("g1", "c1"),
                    StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),
                    StreamOffset.create("stream.orders", ReadOffset.lastConsumed())
                );
                // 2.判断订单信息是否为空
                if (list == null || list.isEmpty()) {
                    // 如果为null，说明没有消息，继续下一次循环
                    continue;
                }
                // 解析数据
                MapRecord record = list.get(0);
                Map value = record.getValue();
                VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
                // 3.创建订单
                createVoucherOrder(voucherOrder);
                // 4.确认消息 XACK
                stringRedisTemplate.opsForStream().acknowledge("s1", "g1", record.getId());
            } catch (Exception e) {
                log.error("处理订单异常", e);
                //处理异常消息
                handlePendingList();
            }
        }
    }

    private void handlePendingList() {
        while (true) {
            try {
                // 1.获取pending-list中的订单信息 XREADGROUP GROUP g1 c1 COUNT 1 BLOCK 2000 STREAMS s1 0
                List> list = stringRedisTemplate.opsForStream().read(
                    Consumer.from("g1", "c1"),
                    StreamReadOptions.empty().count(1),
                    StreamOffset.create("stream.orders", ReadOffset.from("0"))
                );
                // 2.判断订单信息是否为空
                if (list == null || list.isEmpty()) {
                    // 如果为null，说明没有异常消息，结束循环
                    break;
                }
                // 解析数据
                MapRecord record = list.get(0);
                Map value = record.getValue();
                VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
                // 3.创建订单
                createVoucherOrder(voucherOrder);
                // 4.确认消息 XACK
                stringRedisTemplate.opsForStream().acknowledge("s1", "g1", record.getId());
            } catch (Exception e) {
                log.error("处理pendding订单异常", e);
                try{
                    Thread.sleep(20);
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
}

说明：

// 核心：从消息队列读取消息
List> list = stringRedisTemplate.opsForStream().read(
    Consumer.from("g1", "c1"),  // 🔴 消息队列-消费组配置：组名g1，消费者名c1
    StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),  // 🔴 消息队列-读取规则：每次读1条，没消息则阻塞等2秒
    StreamOffset.create("stream.orders", ReadOffset.lastConsumed())  // 🔴 消息队列-指定队列名+读取位置：队列名stream.orders，读未消费的新消息
);

stringRedisTemplate.opsForStream()：拿到操作 Redis 消息队列的 “工具”，所有消息队列的读写都靠它。
消费组（g1）+ 消费者（c1）：可以理解为 “客服组 g1 里的客服 c1”，多个消费者能分摊处理队列消息，避免单线程扛不住。
stream.orders：是你的消息队列名称。
block(2秒)：队列没消息时不做空循环，等 2 秒再查，节省资源。

② 为什么 list 为空就 break？

list 是从 Pending List 读取失败消息的结果，代码里设置了 count(1)（每次只读 1 条）；
如果 list == null/空，说明 Pending List 里已经没有待重试的失败消息了（所有失败订单都处理完了）；
此时再继续死循环没有意义，所以 break 跳出循环，结束本次失败消息的处理流程（等下次有新的失败消息时，这个方法会再次被调用）。

③ 为什么要 list.get(0)？

代码里 StreamReadOptions.empty().count(1) 明确指定了「每次只读取 1 条消息」，所以 list 里最多只有 1 个元素；
list.get(0) 就是取出这唯一的一条失败消息，只有拿到这条消息，才能解析里面的订单数据（用户 ID、优惠券 ID），进而重新处理订单。

④ 为什么要调用 acknowledge 确认消息？

这是 Redis Stream 的「消息确认机制」，作用是告诉 Redis：这条失败的订单消息我已经重新处理成功了，请把它从 Pending List 中移除；
如果不确认（ACK）：Redis 会一直把这条消息留在 Pending List 里，后续这个方法会反复读取这条消息，导致「同一个失败订单被重复处理」（比如用户一个订单被多次扣库存）；

⑤ 这个方法的执行流程

1. 进入死循环，准备捞取失败订单；
2. 从Pending List里读1条失败的订单消息；
3. 如果没读到（list空），说明失败订单都处理完了，跳出循环；
4. 如果读到了，解析成订单对象，重新尝试处理（加锁+扣库存+存订单）；
5. 处理成功后，告诉Redis“这条消息搞定了，你可以删了”；
6. 重复步骤2-5，直到所有失败消息都处理完。

达人探店

查看探店笔记

BlogServiceImpl

@Override
public Result queryBlogById(Long id) {
    // 1.查询blog
    Blog blog = getById(id);
    if (blog == null) {
        return Result.fail("笔记不存在！");
    }
    // 2.查询blog有关的用户
    queryBlogUser(blog);
  
    return Result.ok(blog);
}

private void queryBlogUser(Blog blog) {
    Long userId = blog.getUserId();
    com.hmdp.entity.User user = userService.getById(userId);
    blog.setName(user.getNickName());
    blog.setIcon(user.getIcon());
}

说明：

这个私有方法的核心作用是：根据博客（Blog）中的用户 ID，查询对应的用户信息，并把用户的「昵称」和「头像」两个核心字段填充到博客对象中，最终让博客对象包含发布者的展示信息（而非完整的用户对象），适配前端详情页只需要昵称 / 头像的展示需求。

点赞功能

需求

同一个用户只能点赞一次，再次点击则取消点赞
如果当前用户已经点赞，则点赞按钮高亮显示（前端已实现，判断字段Blog类的isLike属性）

实现步骤

给Blog类中添加一个isLike字段，标示是否被当前用户点赞
修改点赞功能，利用Redis的set集合判断是否点赞过，未点赞过则点赞数+1，已点赞过则点赞数-1
修改根据id查询Blog的业务，判断当前登录用户是否点赞过，赋值给isLike字段
修改分页查询Blog业务，判断当前登录用户是否点赞过，赋值给isLike字段

代码实现

① 在Blog 添加一个字段

1 2	@TableField(exist = false) private Boolean isLike;

② 修改代码

@Override
   public Result likeBlog(Long id){
       // 1.获取登录用户
       Long userId = UserHolder.getUser().getId();
       // 2.判断当前登录用户是否已经点赞
       String key = BLOG_LIKED_KEY + id;
       Boolean isMember = stringRedisTemplate.opsForSet().isMember(key, userId.toString());
       if(BooleanUtil.isFalse(isMember)){
            //3.如果未点赞，可以点赞
           //3.1 数据库点赞数+1
           boolean isSuccess = update().setSql("liked = liked + 1").eq("id", id).update();
           //3.2 保存用户到Redis的set集合
           if(isSuccess){
               stringRedisTemplate.opsForSet().add(key,userId.toString());
           }
       }else{
            //4.如果已点赞，取消点赞
           //4.1 数据库点赞数-1
           boolean isSuccess = update().setSql("liked = liked - 1").eq("id", id).update();
           //4.2 把用户从Redis的set集合移除
           if(isSuccess){
               stringRedisTemplate.opsForSet().remove(key,userId.toString());
           }
       }

点赞排行榜

BlogServiceImpl

@Override
 public Result likeBlog(Long id) {
     // 1.获取登录用户
     Long userId = UserHolder.getUser().getId();
     // 2.判断当前登录用户是否已经点赞
     String key = BLOG_LIKED_KEY + id;
     Double score = stringRedisTemplate.opsForZSet().score(key, userId.toString());
     if (score == null) {
         // 3.如果未点赞，可以点赞
         // 3.1.数据库点赞数 + 1
         boolean isSuccess = update().setSql("liked = liked + 1").eq("id", id).update();
         // 3.2.保存用户到Redis的set集合  zadd key value score
         if (isSuccess) {
             stringRedisTemplate.opsForZSet().add(key, userId.toString(), System.currentTimeMillis());
         }
     } else {
         // 4.如果已点赞，取消点赞
         // 4.1.数据库点赞数 -1
         boolean isSuccess = update().setSql("liked = liked - 1").eq("id", id).update();
         // 4.2.把用户从Redis的set集合移除
         if (isSuccess) {
             stringRedisTemplate.opsForZSet().remove(key, userId.toString());
         }
     }
     return Result.ok();
 }

 private void isBlogLiked(Blog blog) {
     // 1.获取登录用户
     UserDTO user = UserHolder.getUser();
     if (user == null) {
         // 用户未登录，无需查询是否点赞
         return;
     }
     Long userId = user.getId();
     // 2.判断当前登录用户是否已经点赞
     String key = "blog:liked:" + blog.getId();
     Double score = stringRedisTemplate.opsForZSet().score(key, userId.toString());
     blog.setIsLike(score != null);
 }

说明：

① Double score = stringRedisTemplate.opsForZSet().score(key, userId.toString());

作用：查询 指定博客的点赞集合 中，当前用户 是否存在，并返回它的分数。

业务判断：

score == null → 用户没点赞
score != null → 用户已点赞

② stringRedisTemplate.opsForZSet().add(key, userId.toString(), System.currentTimeMillis());

作用：向 ZSet 中添加一个点赞用户，三个参数：

博客点赞的 key
点赞用户 ID
分数（当前时间戳）

关键点：

ZSet 元素唯一 → 同一个用户重复点赞会被自动去重（完美适配「一人只能点一次赞」）
用时间戳当分数 → 后续可以直接按时间倒序，展示「最新点赞的用户列表」（普通 Set 做不到排序，这就是用 ZSet 的原因！）

BlogController

@GetMapping("/likes/{id}")
public Result queryBlogLikes(@PathVariable("id") Long id) {

    return blogService.queryBlogLikes(id);
}

BlogService

@Override
public Result queryBlogLikes(Long id) {
    String key = BLOG_LIKED_KEY + id;
    // 1.查询top5的点赞用户 zrange key 0 4
    Set top5 = stringRedisTemplate.opsForZSet().range(key, 0, 4);
    if (top5 == null || top5.isEmpty()) {
        return Result.ok(Collections.emptyList());
    }
    // 2.解析出其中的用户id
    List ids = top5.stream().map(Long::valueOf).collect(Collectors.toList());
    String idStr = StrUtil.join(",", ids);
    // 3.根据用户id查询用户 WHERE id IN ( 5 , 1 ) ORDER BY FIELD(id, 5, 1)
    List userDTOS = userService.query()
            .in("id", ids).last("ORDER BY FIELD(id," + idStr + ")").list()
            .stream()
            .map(user -> BeanUtil.copyProperties(user, UserDTO.class))
            .collect(Collectors.toList());
    // 4.返回
    return Result.ok(userDTOS);
}

说明：

① List ids = top5.stream().map(Long::valueOf).collect(Collectors.toList());

top5 是你从 Redis 取出来的 Set，里面是：["1001", "1002", "1003"]（字符串格式的用户 ID），数据库查询必须用数字类型（Long），所以要转换。

map(Long::valueOf)

map = 格式转换

1	Long::valueOf` = 把字符串 `"1001"` 转成数字 `1001

② List userDTOS = userService.query() .in(“id”, ids) .last(“ORDER BY FIELD(id,” + idStr + “)”) .list() .stream() .map(user -> BeanUtil.copyProperties(user, UserDTO.class)) .collect(Collectors.toList());

1). userService.query()

这是 MyBatis-Plus（MP）的链式查询

作用：开启一个查询构造器，不用写复杂的 SQL，用代码拼接查询条件
等价于：SELECT * FROM user

2). .in(“id”, ids)

MP 的批量查询条件

含义：id 在 ids 集合中
对应 SQL：WHERE id IN (1001,1002,1003,1004,1005)
作用：只查我们需要的前 5 个点赞用户，不查全表

3). .last (“ORDER BY FIELD (id,” + idStr + “)”)

先讲背景：

数据库用 IN 查询时，返回的用户是乱序的！比如你查 IN (1,2,3)，数据库可能返回 3,1,2，会打乱 Redis 里点赞的先后顺序。

两个关键点：

**last()**MP 的方法：手动在 SQL 最后追加一段代码（这里用来加排序）
**ORDER BY FIELD(id, 1,2,3,4,5)**MySQL 专属函数，作用：强制让结果按照我指定的 ID 顺序排序

举个例子：

idStr = "1001,1002,1003,1004,1005"
拼接后 SQL：ORDER BY FIELD(id,1001,1002,1003,1004,1005)
结果：用户必须按 1001→1002→1003→1004→1005 的顺序返回完美对应 Redis 里的点赞先后顺序！

4). String idStr = StrUtil.join(“,”, ids);

StrUtil.join 是 hutool 工具类的拼接方法，作用：把一个集合 / 数组，用指定符号拼接成一个字符串

举个最直观的例子：

输入：ids = [101, 102, 103]
拼接符号：,
输出：idStr = "101,102,103"

为什么要拼这个字符串？

为了给后面的 SQL 排序 用！数据库需要这种逗号分隔的格式。

好友关注

关注和取消关注

FollowController

//关注
@PutMapping("/{id}/{isFollow}")
public Result follow(@PathVariable("id") Long followUserId, @PathVariable("isFollow") Boolean isFollow) {
    return followService.follow(followUserId, isFollow);
}
//取消关注
@GetMapping("/or/not/{id}")
public Result isFollow(@PathVariable("id") Long followUserId) {
      return followService.isFollow(followUserId);
}

FollowService

取消关注service
@Override
public Result isFollow(Long followUserId) {
        // 1.获取登录用户
        Long userId = UserHolder.getUser().getId();
        // 2.查询是否关注 select count(*) from tb_follow where user_id = ? and follow_user_id = ?
        Integer count = query().eq("user_id", userId).eq("follow_user_id", followUserId).count();
        // 3.判断
        return Result.ok(count > 0);
    }

 关注service
 @Override
    public Result follow(Long followUserId, Boolean isFollow) {
        // 1.获取登录用户
        Long userId = UserHolder.getUser().getId();
        String key = "follows:" + userId;
        // 1.判断到底是关注还是取关
        if (isFollow) {
            // 2.关注，新增数据
            Follow follow = new Follow();
            follow.setUserId(userId);
            follow.setFollowUserId(followUserId);
            boolean isSuccess = save(follow);

        } else {
            // 3.取关，删除 delete from tb_follow where user_id = ? and follow_user_id = ?
            remove(new QueryWrapper()
                    .eq("user_id", userId).eq("follow_user_id", followUserId));

        }
        return Result.ok();
    }

说明：

字段	含义
`userId`	当前登录用户（你自己）
`followUserId`	要关注 / 取关的用户（博主）
`tb_follow` 表	专门存关注关系的表
`isFollow`	`true`= 关注，`false`= 取关

① if (isFollow) → 关注（新增数据）

// 新建一个【关注关系】对象
Follow follow = new Follow();
// 设置：关注人是「我」（当前登录用户）
follow.setUserId(userId);
// 设置：被关注的人是「对方」（博主）
follow.setFollowUserId(followUserId);
// 把这条关注记录 保存到数据库
boolean isSuccess = save(follow);

**Follow follow = new Follow();**数据库里有一张表叫 tb_follow（关注表），我们要往表里加一条数据，就得先创建一个对应的对象。
**setUserId(userId)**填数据：关注的人是我（我是主动关注的一方）。
**setFollowUserId(followUserId)**填数据：我关注的人是他（对方是被关注的博主）。
**save(follow)**MyBatis-Plus 提供的方法，直接把这条关注数据插入数据库。

② else → 取关（删除数据）

remove(new QueryWrapper()
    .eq("user_id", userId)          // 条件1：关注人是我
    .eq("follow_user_id", followUserId) // 条件2：被关注人是他
);

new QueryWrapper()

→ 删除条件

翻译：我不能乱删，必须告诉我删哪一行

共同关注

代码实现

// UserController 根据id查询用户
@GetMapping("/{id}")
public Result queryUserById(@PathVariable("id") Long userId){
// 查询详情
User user = userService.getById(userId);
if (user == null) {
return Result.ok();
}
UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
// 返回
return Result.ok(userDTO);
}

// BlogController  根据id查询博主的探店笔记
@GetMapping("/of/user")
public Result queryBlogByUserId(
@RequestParam(value = "current", defaultValue = "1") Integer current,
@RequestParam("id") Long id) {
// 根据用户查询
Page page = blogService.query()
.eq("user_id", id).page(new Page<>(current, SystemConstants.MAX_PAGE_SIZE));
// 获取当前页数据
List records = page.getRecords();
return Result.ok(records);
}

说明：

① @PathVariable 和 @RequestParam 的区别

@PathVariable（路径参数，写在 URL / 里的）， @RequestParam 是 查询参数，写在 URL ? 后面的。

注解	位置	例子
`@PathVariable`	URL 路径 `/` 里	`/100/true`
`@RequestParam`	URL 问号 `?` 后面	`?current=1&id=100`

② blogService.query()

→ 翻译：我要查 blog 表（博客表）的数据

→ 等价 SQL：SELECT * FROM blog

③ .page(分页参数)

.page(new Page<>(current, SystemConstants.MAX_PAGE_SIZE));

这是MyBatis-Plus 分页方法，两个参数：

current：当前页码（比如 1 = 第一页，2 = 第二页）
SystemConstants.MAX_PAGE_SIZE：固定值，比如 10 → 一页显示 10 条博客

④ page.getRecords()

→ 翻译：从分页结果里，把「当前页的博客列表」拿出来

→ 结果：[博客1, 博客2, ..., 博客10]

修改FollowServiceImpl

改造原因：我们需要在用户关注了某位用户后，需要将数据放入到set集合中，方便后续进行共同关注，同时当取消关注时，也需要从set集合中进行删除。set集合可以实现交集、并集、补集的功能。

@Override
public Result followCommons(Long id) {
    // 1.获取当前用户
    Long userId = UserHolder.getUser().getId();
    String key = "follows:" + userId;
    // 2.求交集
    String key2 = "follows:" + id;
    Set intersect = stringRedisTemplate.opsForSet().intersect(key, key2);
    if (intersect == null || intersect.isEmpty()) {
        // 无交集
        return Result.ok(Collections.emptyList());
    }
    // 3.解析id集合
    List ids = intersect.stream().map(Long::valueOf).collect(Collectors.toList());
    // 4.查询用户
    List users = userService.listByIds(ids)
            .stream()
            .map(user -> BeanUtil.copyProperties(user, UserDTO.class))
            .collect(Collectors.toList());
    return Result.ok(users);
}

说明：

.collect(Collectors.toList())

把转换好的数字 ID，打包成一个列表

Feed流实现方案

针对好友的操作，采用的是Timeline的方式，只需要拿到我们关注用户的信息，然后按照时间排序即可，因此采用Timeline的模式。该模式的实现方案有三种：

拉模式
推模式
推拉结合

拉模式

① 核心逻辑：

当张三、李四和王五发了消息后，都会保存在自己的邮箱中。假设赵六要读取信息，那么它会从读取它自己的收件箱，此时系统会从它关注的人群中，把它关注人的信息全部都进行拉取，然后在进行排序。

② 优点：比较节约空间，因为赵六在读信息时，并没有重复读取，而且读取完之后可以把它的收件箱进行清楚。

③ 缺点：比较延迟，当用户读取数据时才去关注的人里边去读取数据，假设用户关注了大量的用户，那么此时就会拉取海量的内容，对服务器压力巨大。

推模式

① 核心逻辑：

推模式是没有写邮箱的，当张三写了一个内容，此时会主动的把张三写的内容发送到它的粉丝收件箱中去，假设此时李四再来读取，就不用再去临时拉取了。

② 优点：时效快，不用临时拉取。

③ 缺点：内存压力大，假设一个大V写信息，很多人关注它，就会写很多分数据到粉丝那边去

推拉模式

推拉模式是一个折中的方案。

① 站在发件人这一端，如果是个普通的人，那么我们采用写扩散的方式，直接把数据写入到它的粉丝中去，因为普通的人它的粉丝关注量比较小，所以这样做没有压力。如果是大V，那么它是直接将数据先写入到一份到发件箱里边去，然后再直接写一份到活跃粉丝收件箱里边去。

② 现在站在收件人这端来看，如果是活跃粉丝，那么大V和普通的人发的都会直接写入到自己收件箱里边来，而如果是普通的粉丝，由于它们上线不是很频繁，所以等它们上线时，再从发件箱里边去拉信息。

推送到粉丝收件箱

需求

修改新增探店笔记的业务，在保存blog到数据库的同时，推送到粉丝的收件箱
收件箱满足可以根据时间戳排序，必须用Redis的数据结构实现
查询收件箱数据时，可以实现分页查询

Feed流的分页问题

① 传统分页

t1 时刻：取第 1 页（page=1, size=5），拿到10,9,8,7,6。
t2 时刻：新增一条内容11，数据整体后移。
t3 时刻：取第 2 页（page=2, size=5），按传统逻辑从第 6 条开始取，拿到6,5,4,3,2。
结果：6在第 1 页和第 2 页都出现了，数据重复。

② 滚动分页

t1 时刻：首次加载，lastId = ∞（无前置数据），取前 5 条10,9,8,7,6，记录lastId = 6。
t2 时刻：新增内容11，插入到最顶部，不影响已记录的6。
t3 时刻：加载下一页，传入lastId = 6，从6之后的5开始取，拿到5,4,3,2,1，无重复。

代码实现

@Override
public Result saveBlog(Blog blog) {
    // 1.获取登录用户
    UserDTO user = UserHolder.getUser();
    blog.setUserId(user.getId());
    // 2.保存探店笔记
    boolean isSuccess = save(blog);
    if(!isSuccess){
        return Result.fail("新增笔记失败!");
    }
    // 3.查询笔记作者的所有粉丝 select * from tb_follow where follow_user_id = ?
    List follows = followService.query().eq("follow_user_id", user.getId()).list();
    // 4.推送笔记id给所有粉丝
    for (Follow follow : follows) {
        // 4.1.获取粉丝id
        Long userId = follow.getUserId();
        // 4.2.推送
        String key = FEED_KEY + userId;
        stringRedisTemplate.opsForZSet().add(key, blog.getId().toString(), System.currentTimeMillis());
    }
    // 5.返回id
    return Result.ok(blog.getId());
}

实现分页查询收邮箱

需求

① 每次查询完成后，我们要分析出查询出数据的最小时间戳，这个值会作为下一次查询的条件

② 我们需要找到与上一次查询相同的查询个数作为偏移量，下次查询时，跳过这些查询过的数据，拿到我们需要的数据

参数	含义	核心目的
`lastId`	上一次查询结果里的最小时间戳	限定本次查询只加载「比这个时间更早」的 Blog，保证数据按时间倒序加载，避免重复获取
`offset`	上一次查询返回的Blog 数量	用来跳过已经加载过的数据，实现 “下一页” 的翻页效果

代码实现

① 定义出来具体的返回值实体类

@Data
public class ScrollResult {
    private List list;
    private Long minTime;
    private Integer offset;
}

② BlogController

@GetMapping("/of/follow")
public Result queryBlogOfFollow(
    @RequestParam("lastId") Long max, @RequestParam(value = "offset", defaultValue = "0") Integer offset){
    return blogService.queryBlogOfFollow(max, offset);
}

③ BlogServiceImpl

@Override
public Result queryBlogOfFollow(Long max, Integer offset) {
    // 1.获取当前用户
    Long userId = UserHolder.getUser().getId();
    // 2.查询收件箱 ZREVRANGEBYSCORE key Max Min LIMIT offset count
    String key = FEED_KEY + userId;
    Set> typedTuples = stringRedisTemplate.opsForZSet()
        .reverseRangeByScoreWithScores(key, 0, max, offset, 2);
    // 3.非空判断
    if (typedTuples == null || typedTuples.isEmpty()) {
        return Result.ok();
    }
    // 4.解析数据：blogId、minTime（时间戳）、offset
    List ids = new ArrayList<>(typedTuples.size());
    long minTime = 0; // 2
    int os = 1; // 2
    for (ZSetOperations.TypedTuple tuple : typedTuples) { // 5 4 4 2 2
        // 4.1.获取id
        ids.add(Long.valueOf(tuple.getValue()));
        // 4.2.获取分数(时间戳）
        long time = tuple.getScore().longValue();
        if(time == minTime){
            os++;
        }else{
            minTime = time;
            os = 1;
        }
    }
os = minTime == max ? os : os + offset;
    // 5.根据id查询blog
    String idStr = StrUtil.join(",", ids);
    List blogs = query().in("id", ids).last("ORDER BY FIELD(id," + idStr + ")").list();

    for (Blog blog : blogs) {
        // 5.1.查询blog有关的用户
        queryBlogUser(blog);
        // 5.2.查询blog是否被点赞
        isBlogLiked(blog);
    }

    // 6.封装并返回
    ScrollResult r = new ScrollResult();
    r.setList(blogs);
    r.setOffset(os);
    r.setMinTime(minTime);

    return Result.ok(r);
}

说明：

① List ids = new ArrayList<>(typedTuples.size());

List：创建一个列表，里面专门存 数字类型的博客 ID（数据库里的 ID 是数字，不是字符串）
ids：列表的名字，意思就是 id 集合
new ArrayList<>()：创建列表对象
1
typedTuples.size()
：
提前指定列表的大小
- 比如 Redis 查到了 2 条数据，列表就直接开 2 个位置
- 作用：优化性能，不用让列表自动扩容

② String idStr = tuple.getValue(); ids.add(Long.valueOf(idStr));

tuple：循环中每一个 Redis 包裹（包含博客 ID + 时间戳）
tuple.getValue()：拿出包裹里的博客 ID（注意：是字符串格式，比如 “1001”）
1
Long.valueOf(idStr)
：
把字符串 ID 转成数字 ID
- 因为数据库里的 ID 是 Long 数字类型，字符串查不到数据，必须转类型
ids.add(...)：把转换后的数字 ID，放进刚才创建的列表里

③ List blogs = query().in(“id”, ids).last(“ORDER BY FIELD(id,” + idStr + “)”).list();

1). 问题

Redis 查出的 blogId 是按时间倒序的，但 MySQL 的 IN 查询不会保证返回顺序！直接查会导致博客顺序乱掉。

2). 解决方案

ORDER BY FIELD(id, 1,2,3)：强制让数据库返回的顺序 和 Redis 中的 id 顺序完全一致，保证前端展示顺序正确。

附近商户

GEO数据结构的基本用法

GEO就是Geolocation的简写形式，代表地理坐标。Redis在3.2版本中加入了对GEO的支持，允许存储地理坐标信息，帮助我们根据经纬度来检索数据。常见的命令有：

GEOADD：添加一个地理空间信息，包含：经度（longitude）、纬度（latitude）、值（member）
GEODIST：计算指定的两个点之间的距离并返回
GEOHASH：将指定member的坐标转为hash字符串形式并返回
GEOPOS：返回指定member的坐标
GEORADIUS：指定圆心、半径，找到该圆内包含的所有member，并按照与圆心之间的距离排序后返回。6.以后已废弃
GEOSEARCH：在指定范围内搜索member，并按照与指定点之间的距离排序后返回。范围可以是圆形或矩形。6.2.新功能
GEOSEARCHSTORE：与GEOSEARCH功能一致，不过可以把结果存储到一个指定的key。6.2.新功能

导入店铺数据到GEO

Redis GEO 数据结构设计

① 按「商家类型」分组存储

Redis GEO 本身不支持额外的类型筛选条件（比如只查美食、排除 KTV），所以我们用分组来解决：

给每种商家类型建一个独立的 GEO 集合，Key 格式为：
1
shop:geo:{类型}
- 美食类：shop:geo:美食
- KTV 类：shop:geo:KTV
这样用户选「美食」时，直接查询 shop:geo:美食，天然就过滤了类型，只查美食商家。

② GEO 里只存「商家 ID」，不存完整信息

Redis 是内存数据库，存太多数据会占满内存，所以：

Value（member）：只存商家的ID（比如海底捞的 ID 是 1，就存 “1”）
Score：Redis 自动把经纬度转换成 GeoHash 值，用来计算距离和排序
完整的商家信息（名称、地址、评分等）依然存在数据库（MySQL）里，之后用 ID 去查。

代码实现

@Test
void loadShopData() {
    // 1.查询店铺信息
    List list = shopService.list();
    // 2.把店铺分组，按照typeId分组，typeId一致的放到一个集合
    Map> map = list.stream().collect(Collectors.groupingBy(Shop::getTypeId));
    // 3.分批完成写入Redis
    for (Map.Entry> entry : map.entrySet()) {
        // 3.1.获取类型id
        Long typeId = entry.getKey();
        String key = SHOP_GEO_KEY + typeId;
        // 3.2.获取同类型的店铺的集合
        List value = entry.getValue();
        List> locations = new ArrayList<>(value.size());
        // 3.3.写入redis GEOADD key 经度 纬度 member
        for (Shop shop : value) {
            // stringRedisTemplate.opsForGeo().add(key, new Point(shop.getX(), shop.getY()), shop.getId().toString());
            locations.add(new RedisGeoCommands.GeoLocation<>(
                    shop.getId().toString(),
                    new Point(shop.getX(), shop.getY())
            ));
        }
        stringRedisTemplate.opsForGeo().add(key, locations);
    }
}

说明：

① Map> map = list.stream() .collect(Collectors.groupingBy(Shop::getTypeId));

用 groupingBy(Shop::getTypeId) 把所有店铺，按类型 ID分成一组一组；
最终得到一个 Map：key = 类型 ID，value = 该类型的所有店铺；
后续给每个类型创建一个独立的 Redis GEO Key（比如 shop:geo:1 是美食店，shop:geo:2 是 KTV），查询时直接查对应 Key，天然过滤类型。

② 往箱子里「装每个店铺的包裹」

for (Shop shop : value) {
    locations.add(
        new GeoLocation<>(
            shop.getId().toString(),  // 包裹里的「快递单号」：店铺ID
            new Point(shop.getX(), shop.getY())  // 包裹里的「收货地址」：经纬度
        )
    );
}

shop.getId().toString()：把店铺 ID 转成字符串，作为 Redis GEO 里的 member（相当于快递单号，用来后续查询店铺信息）
new Point(shop.getX(), shop.getY())：封装店铺的经纬度

实现附近商户功能

ShopController

@GetMapping("/of/type")
public Result queryShopByType(
        @RequestParam("typeId") Integer typeId,
        @RequestParam(value = "current", defaultValue = "1") Integer current,
        @RequestParam(value = "x", required = false) Double x,
        @RequestParam(value = "y", required = false) Double y
) {
   return shopService.queryShopByType(typeId, current, x, y);
}

ShopServiceImpl

@Override
    public Result queryShopByType(Integer typeId, Integer current, Double x, Double y) {
        // 1.判断是否需要根据坐标查询
        if (x == null || y == null) {
            // 不需要坐标查询，按数据库查询
            Page page = query()
                    .eq("type_id", typeId)
                    .page(new Page<>(current, SystemConstants.DEFAULT_PAGE_SIZE));
            // 返回数据
            return Result.ok(page.getRecords());
        }

        // 2.计算分页参数
        int from = (current - 1) * SystemConstants.DEFAULT_PAGE_SIZE;
        int end = current * SystemConstants.DEFAULT_PAGE_SIZE;

        // 3.查询redis、按照距离排序、分页。结果：shopId、distance
        String key = SHOP_GEO_KEY + typeId;
        GeoResults> results = stringRedisTemplate.opsForGeo() // GEOSEARCH key BYLONLAT x y BYRADIUS 10 WITHDISTANCE
                .search(
                        key,
                        GeoReference.fromCoordinate(x, y),
                        new Distance(5000),
                        RedisGeoCommands.GeoSearchCommandArgs.newGeoSearchArgs().includeDistance().limit(end)
                );
        // 4.解析出id
        if (results == null) {
            return Result.ok(Collections.emptyList());
        }
        List>> list = results.getContent();
        if (list.size() <= from) {
            // 没有下一页了，结束
            return Result.ok(Collections.emptyList());
        }
        // 4.1.截取 from ~ end的部分
        List ids = new ArrayList<>(list.size());
        Map distanceMap = new HashMap<>(list.size());
        list.stream().skip(from).forEach(result -> {
            // 4.2.获取店铺id
            String shopIdStr = result.getContent().getName();
            ids.add(Long.valueOf(shopIdStr));
            // 4.3.获取距离
            Distance distance = result.getDistance();
            distanceMap.put(shopIdStr, distance);
        });
        // 5.根据id查询Shop
        String idStr = StrUtil.join(",", ids);
        List shops = query().in("id", ids).last("ORDER BY FIELD(id," + idStr + ")").list();
        for (Shop shop : shops) {
            shop.setDistance(distanceMap.get(shop.getId().toString()).getValue());
        }
        // 6.返回
        return Result.ok(shops);
    }

说明：

① .page(new Page<>(current, 每页条数))

current：前端传的当前页码（比如第 1 页、第 2 页）
SystemConstants.DEFAULT_PAGE_SIZE：每页默认显示多少条店铺（比如 10 条）

② return Result.ok(page.getRecords());

Page 分页对象里包含了很多分页信息：

总页数、总条数、当前页、每页条数、数据列表
getRecords() = 获取分页查询到的「店铺数据列表」（就是我们要展示给用户的店铺集合）

③ 指定类型 + 5 公里范围内 + 按距离排序 的店铺

参数	代码写法	大白话翻译
第 1 个	`key`	查哪种类型的店铺（比如美食店）
第 2 个	`GeoReference.fromCoordinate(x, y)`	以用户当前坐标为圆心
第 3 个	`new Distance(5000)`	以圆心为中心，画 5000 米（5 公里）的圈
第 4 个	`includeDistance()`	必须计算并返回每个店铺离用户的距离
第 4 个	`limit(end)`	最多查 `end` 条数据（分页用）

④ Map distanceMap = new HashMap<>(list.size());

distanceMap：一个空 Map
作用：等会儿存 “店铺 ID → 离你多远”
比如：105 → 1.2km

⑤ shop.setDistance(distanceMap.get(shop.getId().toString()).getValue());

.getValue() 的作用是从 Distance 对象里，提取出纯数字的距离值（比如 1.2），Distance 对象是 Redis 封装的，包含单位、数值等信息，我们只需要数值给前端展示

用户签到

BitMap的操作命令：

SETBIT：向指定位置（offset）存入一个0或1
GETBIT ：获取指定位置（offset）的bit值
BITCOUNT ：统计BitMap中值为1的bit位的数量
BITFIELD ：操作（查询、修改、自增）BitMap中bit数组中的指定位置（offset）的值
BITFIELD_RO ：获取BitMap中bit数组，并以十进制形式返回
BITOP ：将多个BitMap的结果做位运算（与、或、异或）
BITPOS ：查找bit数组中指定范围内第一个0或1出现的位置

实现签到功能

UserServiceImpl

@Override
public Result sign() {
    // 1.获取当前登录用户
    Long userId = UserHolder.getUser().getId();
    // 2.获取日期
    LocalDateTime now = LocalDateTime.now();
    // 3.拼接key
    String keySuffix = now.format(DateTimeFormatter.ofPattern(":yyyyMM"));
    String key = USER_SIGN_KEY + userId + keySuffix;
    // 4.获取今天是本月的第几天
    int dayOfMonth = now.getDayOfMonth();
    // 5.写入Redis SETBIT key offset 1
    stringRedisTemplate.opsForValue().setBit(key, dayOfMonth - 1, true);
    return Result.ok();
}

签到统计

UserServiceImpl

@Override
public Result signCount() {
    // 1.获取当前登录用户
    Long userId = UserHolder.getUser().getId();
    // 2.获取日期
    LocalDateTime now = LocalDateTime.now();
    // 3.拼接key
    String keySuffix = now.format(DateTimeFormatter.ofPattern(":yyyyMM"));
    String key = USER_SIGN_KEY + userId + keySuffix;
    // 4.获取今天是本月的第几天
    int dayOfMonth = now.getDayOfMonth();
    // 5.获取本月截止今天为止的所有的签到记录，返回的是一个十进制的数字 BITFIELD sign:5:202203 GET u14 0
    List result = stringRedisTemplate.opsForValue().bitField(
            key,
            BitFieldSubCommands.create()
                    .get(BitFieldSubCommands.BitFieldType.unsigned(dayOfMonth)).valueAt(0)
    );
    if (result == null || result.isEmpty()) {
        // 没有任何签到结果
        return Result.ok(0);
    }
    Long num = result.get(0);
    if (num == null || num == 0) {
        return Result.ok(0);
    }
    // 6.循环遍历
    int count = 0;
    while (true) {
        // 6.1.让这个数字与1做与运算，得到数字的最后一个bit位  // 判断这个bit位是否为0
        if ((num & 1) == 0) {
            // 如果为0，说明未签到，结束
            break;
        }else {
            // 如果不为0，说明已签到，计数器+1
            count++;
        }
        // 把数字右移一位，抛弃最后一个bit位，继续下一个bit位
        num >>>= 1;
    }
    return Result.ok(count);
}

说明：

① 第一层判断：result == null || result.isEmpty()

result 是一个列表集合（比如查询数据库返回的 List）

result == null：列表对象都不存在（彻底没数据）
result.isEmpty()：列表存在，但里面空空如也（一条数据都没有）
满足任意一个 → 直接返回 0

② 第二层判断：num == null || num == 0

num == null：数据库里这个值是空值
num == 0：数字本身就是 0
满足任意一个 → 直接返回 0

③ 举个生活例子

快递柜都坏了 / 根本没这个柜 → 没包裹，返回 0
快递柜是好的 → 打开柜门
柜子里空的 / 包裹是个空盒子 → 还是没东西，返回 0
有真实包裹 → 把包裹给你

Redis学习笔记之基础篇

2026-03-29T02:00:00.000Z

Redis 学习笔记

基础篇

认识 Redis

认识 NoSQL

NoSql可以翻译做Not Only Sql（不仅仅是SQL），或者是No Sql（非Sql的）数据库。是相对于传统关系型数据库而言，有很大差异的一种特殊的数据库，因此也称之为非关系型数据库。

结构化与非结构化

① 传统关系型数据库是结构化数据，每一张表都有严格的约束信息：字段名、字段数据类型、字段约束等等信息，插入的数据必须遵守这些约束：

② 而NoSql则对数据库格式没有严格约束，往往形式松散，自由。可以是键值型、文档型、图格式。

关联和非关联

① 传统数据库的表与表之间往往存在关联，例如外键：

② 而非关系型数据库不存在关联关系，要维护关系要么靠代码中的业务逻辑，要么靠数据之间的耦合：

{
  id: 1,
  name: "张三",
  orders: [
    {
       id: 1,
       item: {
 id: 10, title: "荣耀6", price: 4999
       }
    },
    {
       id: 2,
       item: {
 id: 20, title: "小米11", price: 3999
       }
    }
  ]
}

查询方式

① 传统关系型数据库会基于Sql语句做查询，语法有统一标准；

② 不同的非关系数据库查询语法差异极大，五花八门各种各样。

事务

① 传统关系型数据库能满足事务ACID的原则。

② 而非关系型数据库往往不支持事务，或者不能严格保证ACID的特性，只能实现基本的一致性。

总结

	SQL	NoSQL
数据结构	结构化(Structured)	非结构化
数据关联	关联的(Relational)	无关联的
查询方式	SQL查询	非SQL
事务特性	ACID	BASE
存储方式	磁盘	内存
扩展性	垂直	水平
使用场景	1）数据结构固定 2)对一致性、安全性要求不高	1)数据结构不固定 2)相关业务对数据安全性、一致性要求较高 3）对性能要求

Redis 桌面客户端

(1) Redis安装完成后就自带了命令行客户端：redis-cli，使用方式如下：

1	redis-cli [options] [commonds]

其中常见的options有：

-h 127.0.0.1：指定要连接的redis节点的IP地址，默认是127.0.0.1
-p 6379：指定要连接的redis节点的端口，默认是6379
-a 123321：指定redis的访问密码

Redis 常见命令

Redis 数据结构

Redis存储的是key-value结构的数据，其中key是字符串类型，value有5中常用的数据类型

字符串：String
哈希：Hash
列表：List
集合：Set
有序集合：Sorted Set

Redis命令-String命令

介绍

String 类型，也就是字符串类型，是Redis中最简单的存储类型。其value是字符串，根据字符串的格式不同，又可以分为3类：

string：普通字符串
int：整数类型，可以做自增、自减操作
float：浮点类型，可以做自增、自减操作

说明：

Redis 没有原生的 “整数类型” “浮点类型” 存储结构，String 类型的所有 value，底层都以 简单动态字符串（SDS） 这种字节数组形式存储。

表格中 num 的 10：底层存的是字符 '1' 和 '0' 的字节，不是编程语言里占 4 字节的整数 10；
表格中 score 的 92.5：底层存的是字符 '9' '2' '.' '5' 的字节，不是浮点型的二进制存储；
只有格式上的区别，存储本质完全一致。

String 的常见命令有：

SET：添加或者修改已经存在的一个String类型的键值对
GET：根据key获取String类型的value
MSET：批量添加多个String类型的键值对
MGET：根据多个key获取多个String类型的value
INCR：让一个整型的key自增1
INCRBY：让一个整型的key自增并指定步长，例如：incrby num 2 让num值自增2
SETNX：添加一个String类型的键值对，前提是这个key不存在，否则不执行
SETEX：添加一个String类型的键值对，并且指定有效期

① SET 和 GET：如果key不存在则是新增，如果存在则是修改

127.0.0.1:6379> set name Rose  //原来不存在
OK

127.0.0.1:6379> get name 
"Rose"

127.0.0.1:6379> set name Jack //原来存在，就是修改
OK

127.0.0.1:6379> get name
"Jack"

② INCR 和 INCRBY 和 DECY

127.0.0.1:6379> get age 
"10"

127.0.0.1:6379> incr age //增加1
(integer) 11
    
127.0.0.1:6379> get age //获得age
"11"

127.0.0.1:6379> incrby age 2 //一次增加2
(integer) 13 //返回目前的age的值
    
127.0.0.1:6379> incrby age 2
(integer) 15
    
127.0.0.1:6379> incrby age -1 //也可以增加负数，相当于减
(integer) 14
    
127.0.0.1:6379> incrby age -2 //一次减少2个
(integer) 12
    
127.0.0.1:6379> DECR age //相当于 incr 负数，减少正常用法
(integer) 11
    
127.0.0.1:6379> get age 
"11"

Redis命令-Key的层级结构

存在的问题

需要存储用户、商品信息到redis，有一个用户id是1，有一个商品id恰好也是1，此时如果使用id作为key，那就会冲突了，该怎么办？

解决方案

① Redis的key允许有多个单词形成层级结构，多个单词之间用’:’隔开，格式如下：

② 例如我们的项目名称叫 heima，有user和product两种不同类型的数据，我们可以这样定义key：

user相关的key：heima:user:1
product相关的key：heima:product:1

Redis命令-Hash命令

优势

Hash结构可以将对象中的每个字段独立存储，可以针对单个字段做CRUD：

Hash类型的常见命令

HSET key field value：添加或者修改hash类型key的field的值
HGET key field：获取一个hash类型key的field的值
HMSET：批量添加多个hash类型key的field的值
HMGET：批量获取多个hash类型key的field的值
HGETALL：获取一个hash类型的key中的所有的field和value
HKEYS：获取一个hash类型的key中的所有的field
HINCRBY:让一个hash类型key的字段值自增并指定步长
HSETNX：添加一个hash类型的key的field值，前提是这个field不存在，否则不执行

① HSET 和 HGET

127.0.0.1:6379> HSET heima:user:3 name Lucy//大key是 heima:user:3 小key是name，小value是Lucy
(integer) 1
127.0.0.1:6379> HSET heima:user:3 age 21// 如果操作不存在的数据，则是新增
(integer) 1
127.0.0.1:6379> HSET heima:user:3 age 17 //如果操作存在的数据，则是修改
(integer) 0
127.0.0.1:6379> HGET heima:user:3 name 
"Lucy"
127.0.0.1:6379> HGET heima:user:3 age
"17"

② HKEYS和HVALS

127.0.0.1:6379> HKEYS heima:user:4
1) "name"
2) "age"
3) "sex"
127.0.0.1:6379> HVALS heima:user:4
1) "LiLei"
2) "20"
3) "man"

Redis命令-List命令

特征

有序
元素可以重复
插入和删除快
查询速度一般

List的常见命令

LPUSH key element … ：向列表左侧插入一个或多个元素
LPOP key：移除并返回列表左侧的第一个元素，没有则返回nil
RPUSH key element … ：向列表右侧插入一个或多个元素
RPOP key：移除并返回列表右侧的第一个元素
LRANGE key star end：返回一段角标范围内的所有元素
BLPOP和BRPOP：与LPOP和RPOP类似，只不过在没有元素时等待指定时间，而不是直接返回nil

Redis命令-Set命令

特征

无序
元素不可重复
查找快
支持交集、并集、差集等功能

常见的命令

命令	描述
SADD key member1 [member2]	向集合添加一个或多个成员
SMEMBERS key	返回集合中的所有成员
SCARD key	获取集合的成员数
SINTER key1 [key2]	返回给定所有集合的交集
SUNION key1 [key2]	返回所有给定集合的并集
SDIFF key1 [key2]	返回给定所有集合的差集
SREM key member1 [member2]	移除集合中一个或多个成员

Redis命令-SortedSet类型

特征

Sorted Set有序集合是String类型元素的集合，且不允许重复的成员。每个元素都会关联一个double类型的分数(score) 。Redis正是通过分数来为集合中的成员进行从小到大排序。有序集合的成员是唯一的，但分数却可以重复。

常见命令

ZADD key score member：添加一个或多个元素到sorted set ，如果已经存在则更新其score值
ZREM key member：删除sorted set中的一个指定元素
ZSCORE key member : 获取sorted set中的指定元素的score值
ZRANK key member：获取sorted set 中的指定元素的排名
ZCARD key：获取sorted set中的元素个数
ZCOUNT key min max：统计score值在给定范围内的所有元素的个数
ZINCRBY key increment member：让sorted set中的指定元素自增，步长为指定的increment值
ZRANGE key min max：按照score排序后，获取指定排名范围内的元素
ZRANGEBYSCORE key min max：按照score排序后，获取指定score范围内的元素
ZDIFF、ZINTER、ZUNION：求差集、交集、并集三、

Redis的Java客户端 - Jedis（了解即可）

操作步骤

① 引入依赖


<dependency>
    <groupId>redis.clientsgroupId>
    <artifactId>jedisartifactId>
    <version>3.7.0version>
dependency>

<dependency>
    <groupId>org.junit.jupitergroupId>
    <artifactId>junit-jupiterartifactId>
    <version>5.7.0version>
    <scope>testscope>
dependency>

② 建立连接

新建一个单元测试类，内容如下：

private Jedis jedis;

@BeforeEach
void setUp() {
    // 1.建立连接
    // jedis = new Jedis("192.168.150.101", 6379);
    jedis = JedisConnectionFactory.getJedis();
    // 2.设置密码
    jedis.auth("123321");
    // 3.选择库
    jedis.select(0);
}

③ 测试

@Test
void testString() {
    // 存入数据
    String result = jedis.set("name", "虎哥");
    System.out.println("result = " + result);
    // 获取数据
    String name = jedis.get("name");
    System.out.println("name = " + name);
}

@Test
void testHash() {
    // 插入hash数据
    jedis.hset("user:1", "name", "Jack");
    jedis.hset("user:1", "age", "21");

    // 获取
    Map map = jedis.hgetAll("user:1");
    System.out.println(map);
}

④ 释放资源

@AfterEach
void tearDown() {
    if (jedis != null) {
        jedis.close();
    }
}

Jedis连接池

创建Jedis的连接池

static { // 静态代码块：类加载时自动执行，只执行一次
    // 1. 配置连接池的“规则”
    JedisPoolConfig poolConfig = new JedisPoolConfig();
    poolConfig.setMaxTotal(8);      // 最多同时有 8 个连接（满了就等）
    poolConfig.setMaxIdle(8);       // 最多保留 8 个“空闲”的连接（多余的释放）
    poolConfig.setMinIdle(0);       // 最少保留 0 个空闲连接（没有就新建）
    poolConfig.setMaxWaitMillis(1000); // 没连接时最多等 1000 毫秒（1秒），超时就报错

    // 2. 根据规则，创建真正的连接池
    jedisPool = new JedisPool(
        poolConfig,          // 刚才的规则
        "192.168.150.101",   // Redis 服务器的 IP
        6379,                // Redis 端口
        1000,                // 连接超时时间（毫秒）
        "123321"             // Redis 密码
    );
}

public static Jedis getJedis() { // 对外提供的“借连接”的方法
    return jedisPool.getResource(); // 从连接池里拿一个可用的连接
}

Redis的Java客户端-SpringDataRedis

介绍

SpringDataRedis中提供了RedisTemplate工具类，其中封装了各种对Redis的操作。并且将不同数据类型的操作API封装到了不同的类型中：

快速入门

① 需要导入它的maven坐标


<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-data-redisartifactId>
dependency>

② 配置文件

spring:
  redis:
    host: 192.168.150.101
    port: 6379
    password: 123321
    lettuce:
      pool:
        max-active: 8  #最大连接
        max-idle: 8   #最大空闲连接
        min-idle: 0   #最小空闲连接
        max-wait: 100ms #连接等待时间

③ 测试代码

@SpringBootTest
class RedisDemoApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void testString() {
        // 写入一条String数据
        redisTemplate.opsForValue().set("name", "虎哥");
        // 获取string数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }
}

数据序列化器

自定义RedisTemplate的序列化方式，代码如下：

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory){
        // 创建RedisTemplate对象
        RedisTemplate template = new RedisTemplate<>();
        // 设置连接工厂
        template.setConnectionFactory(connectionFactory);
        // 创建JSON序列化工具
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = 
            new GenericJackson2JsonRedisSerializer();
        // 设置Key的序列化
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        // 设置Value的序列化
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(jsonRedisSerializer);
        // 返回
        return template;
    }
}

说明：

之所以要写 HashKey 和 HashValue，是因为Redis 里的 Hash 类型，就像一个「嵌套的 Map」：

顶层结构：RedisKey（顶层Key） → Hash结构（顶层Value）
Hash 内部结构：HashKey → HashValue

StringRedisTemplate

存在的问题

默认情况下，RedisTemplate 使用的序列化器（比如 JdkSerializationRedisSerializer）会把对象的 完整类信息（class 类型） 也写入到 JSON 结果中，再存入 Redis。

比如一个 User 对象，序列化后可能变成这样：

{
  "@class": "com.example.User",
  "name": "Jack",
  "age": 21
}

这里的 "@class": "com.example.User" 就是额外的类信息，它会占用不必要的内存空间。

解决方案

先使用ObjectMapper把对象手动转换成纯 JSON 字符串（不带 class 信息）。
再用 StringRedisTemplate把这个 JSON 字符串存入 Redis。
读取时，先从 Redis 取出 JSON 字符串，再手动用 Jackson 把它反序列化为对象。

代码实现

@SpringBootTest
class RedisStringTests {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    void testString() {
        // 写入一条String数据
        stringRedisTemplate.opsForValue().set("verify:phone:13600527634", "124143");
        // 获取string数据
        Object name = stringRedisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }

    private static final ObjectMapper mapper = new ObjectMapper();

    @Test
    void testSaveUser() throws JsonProcessingException {
        // 创建对象
        User user = new User("虎哥", 21);
        // 手动序列化
        String json = mapper.writeValueAsString(user);
        // 写入数据
        stringRedisTemplate.opsForValue().set("user:200", json);

        // 获取数据
        String jsonUser = stringRedisTemplate.opsForValue().get("user:200");
        // 手动反序列化
        User user1 = mapper.readValue(jsonUser, User.class);
        System.out.println("user1 = " + user1);
    }

}

Hash结构操作

@SpringBootTest
class RedisStringTests {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    void testHash() {
        stringRedisTemplate.opsForHash().put("user:400", "name", "虎哥");
        stringRedisTemplate.opsForHash().put("user:400", "age", "21");

        Map entries = stringRedisTemplate.opsForHash().entries("user:400");
        System.out.println("entries = " + entries);
    }
}

MySQL学习笔记之运维篇

2026-03-28T04:00:00.000Z

日志

错误日志

(1) 错误日志是 MySQL 中最重要的日志之一，它记录了当 mysqld 启动和停止时，以及服务器在运行过程中发生任何严重错误时的相关信息当数据库出现任何故障导致无法正常使用时，建议首先查看此日志。

(2) 该日志是默认开启的，默认存放目录 /var/log/，默认的日志文件名为 mysqld.log 。查看日志位置：

1	show variables like '%log_error%'

二进制日志

(1) 二进制日志(BINLOG)记录了所有的 DDL(数据定义语言)语句和 DML(数据操纵语言)语句，但不包括数据查询(SELECT、SHOW)语句。

(2) 作用：

① 灾难时的数据恢复；

② MySQL的主从复制。

在MySQL8版本中，默认二进制日志是开启着的，涉及到的参数如下：

1	show variables like '%log_bin%'

(3) 日志格式

MySQL服务器中提供了多种格式来记录二进制记录，具体格式及特点如下：

日志格式	含义
statement	基于SQL语句的日志记录，记录的是SQL语句，对数据进行修改的SQL都会记录在日志文件中。
row	基于行的日志记录，记录的是每一行的数据变更。(默认)
mixed	混合了STATEMENT和ROW两种格式，默认采用STATEMENT，在某些特殊情况下会自动切换为ROW进行记录。

查看参数方式：

1	show variables like '%binlog_format%';

(4) 日志查看

由于日志是以二进制方式存储的，不能直接读取，需要通过二进制日志查询工具 mysqlbinlog 来查看，具体语法：

mysqlbinlog[参数选项]logfilename

参数选项：
    -d    指定数据库名称，只列出指定的数据库相关的操作。
    -o    忽略掉日志中的前n行命令。
    -v    将行事件(数据变更)重构为SOL语句。
    -vv    将行事件(数据变更)重构为SQL语句，并输出注释信息

(5) 日志删除

对于比较繁忙的业务系统，每天生成的binlog数据巨大，如果长时间不清除，将会占用大量磁盘空间。可以通过以下几种方式清理日志：

指令	含义
reset master	删除全部 binlog 日志，删除之后，日志编号，将从 binlog.000001重新开始
purge master logs to ‘binlog.***’	删除 *** 编号之前的所有日志
purge master logs before ‘yyyy-mm-dd hh24:mi:ss’	删除日志为”yyyy-mm-dd hh24:mi:ss”之前产生的所有日志

也可以在mysql的配置文件中配置二进制日志的过期时间，设置了之后，二进制日志过期会自动删除。

1	show variables like '%binlog_expire_logs_seconds%'

查询日志

(1) 查询日志中记录了客户端的所有操作语句，而二进制日志不包含查询数据的SQL语句。默认情况下，查询日志是未开启的。如果需要开启查询日志，可以设置一下配置：

修改MySQL的配置文件 /etc/my.cnf 文件，添加如下内容：

#该选项用来开启查询日志，可选值：0或者1；0代表关闭，1代表开启
general_log=1
#设置日志的文件名 ， 如果没有指定，默认的文件名为 host_name.log
general_log_file=mysql_query.log

慢查询日志

(1) 慢查询日志记录了所有执行时间超过参数 long_query_time 设置值并且扫描记录数不小于 min_examined_row_limit的所有的SQL语句的日志，默认未开启。long_query_time 默认为 10 秒，最小为0，精度可以到微秒。

#慢查询日志
slow_query_log=1
#执行时间参数
long_query_time=2

(2) 默认情况下，不会记录管理语句，也不会记录不使用索引进行查找的查询。可以使用log_slow_admin_statements和更改此行为log_queries_not_using_indexes，如下所述。

#记录执行较慢的管理语句
log_slow_admin_statements = 1
#记录执行较慢的未使用索引的语句
log_queries_not_using_indexes = 1

主从复制

概述

(1) 主从复制是指将主数据库的 DDL 和 DML 操作通过二进制日志传到从库服务器中，然后在从库上对这些日志重新执行（也叫做重做），从而使得从库和主库的数据保持同步。

(2) MySQL 支持一台主库同时向多台从库进行复制，从库同时也可以作为其他服务器的主库，实现链式复制。

(3) MySQL 复制的优点主要包含以下三个方面：

① 主库出现问题，可以快速切换到从库提供服务。

② 实现读写分离，降低主库的访问压力。

③ 可以在从库中执行备份，以避免备份期间影响主服务器。

原理

从上图来看，复制分成三步：

(1) Master 主库在事务提交时，会把数据变更记录在二进制日志文件 Binlog 中。

(2) 从库读取主库的二进制日志文件 Binlog，写入到从库的中继日志 Relay log。

(3) slave 重做中继日志中的事件，将改变反映它自己的数据。

搭建

主库配置

(1) 修改配置文件 /etc/my.cnf

#mysql 服务ID，保证整个集群环境中唯一，取值范围：1 - 2^32-1，默认为1
server-id=1
#是否只读 1代表只读，0代表读写
read-only=0
#忽略的数据库，指不需要同步的数据库
#binlog-ignore-db=mysql
#指定同步的数据库
#binlog-do-db=db01

(2) 重启 MySQL 服务器

1	systemctl restart mysqld

(3) 登录 mysql，创建远程连接的账号，并授予主从复制权限

#创建itcast用户，并设置密码，该用户可在任意主机连接该MySQL服务
CREATE USER 'itcast'@'%' IDENTIFIED WITH mysql_native_password BY 'Root@123456';
#为'itcast'@'%'用户分配主从复制权限
GRANT REPLICATION SLAVE ON *.* TO 'itcast'@'%';

(4) 通过指令，查看二进制日志坐标

1	show master status;

字段含义说明：

file：从哪个日志文件开始推送日志文件

position：从哪个位置开始推送日志

binlog_ignore_db：指定不需要同步的数据库

从库配置

(1) 修改配置文件 /etc/my.cnf

#mysql服务ID，保证整个集群环境中唯一，取值范围：1 - 2^32-1，和主库不一样即可
server-id=2
#是否只读：1代表只读，0代表读写
read-only=1

(2) 重新启动 MySQL 服务

1	systemctl restart mysqld

(3) 登录 mysql，设置主库配置

1	CHANGE REPLICATION SOURCE TO SOURCE_HOST='xxx', SOURCE_USER='xxx', SOURCE_PASSWORD='xxx', SOURCE_LOG_FILE='xxx', SOURCE_LOG_POS=xxx;

上述是 8.0.23 中的语法。如果 mysql 是 8.0.23 之前的版本，执行如下 SQL：

1	CHANGE MASTER TO MASTER_HOST='xxx.xxx.xxx.xxx', MASTER_USER='xxx', MASTER_PASSWORD='xxx', MASTER_LOG_FILE='xxx', MASTER_LOG_POS=xxx;

参数名	含义	8.0.23 之前
SOURCE_HOST	主库 IP 地址	MASTER_HOST
SOURCE_USER	连接主库的用户名	MASTER_USER
SOURCE_PASSWORD	连接主库的密码	MASTER_PASSWORD
SOURCE_LOG_FILE	binlog 日志文件名	MASTER_LOG_FILE
SOURCE_LOG_POS	binlog 日志文件位置	MASTER_LOG_POS

(4) 开启同步操作

1 2	start replica ; #8.0.22之后 start slave ; #8.0.22之前

(5) 查看主从同步状态

1 2	show replica status ; #8.0.22之后 show slave status ; #8.0.22之前

测试

(1) 在主库上创建数据库、表，并插入数据

create database db01;
use db01;
create table tb_use(
id int(11) primary key not null auto_increment,
name varchar(50) not null,
sex varchar(1)
)engine=innodb default charset=utf8mb4;
insert into tb_user(id, name, sex) valurs (null, 'Tom', '1'), (null, 'Trigger', '0'), (null, 'Dawn', '1');

(2) 在从库中查询数据，验证主从是否同步。

分库分表

介绍

(1) 问题分析

随着互联网及移动互联网的发展，应用系统的数据量也是成指数式增长，若采用单数据库进行数据存储，存在以下性能瓶颈：

① I/O 瓶颈：热点数据太多，数据库缓存不足，产生大量磁盘 I/O，效率较低。请求数据太多，带宽不够，网络 I/O 瓶颈。

② CPU 瓶颈：排序、分组、连接查询、聚合统计等 SQL 会耗费大量的 CPU 资源，请求数太多，CPU 出现瓶颈。

分库分表的中心思想都是将数据分散存储，使得单一数据库 / 表的数据量变小来缓解单一数据库的性能问题，从而达到提升数据库性能的目的。

(2) 拆分策略

(3) 垂直拆分

① 垂直分库

以表为依据，根据业务将不同表拆分到不同库中。

特点：

每个库的表结构都不一样。
每个库的数据也不一样。
所有库的并集是全量数据。

② 垂直分表

以字段为依据，根据字段属性将不同字段拆分到不同表中。

特点：

每个表的结构都不一样。
每个表的数据也不一样，一般通过一列（主键 / 外键）关联。
所有表的并集是全量数据。

(4) 水平拆分

① 水平分库

以字段为依据，按照一定策略，将一个库的数据拆分到多个库中。

特点：

每个库的表结构都一样。
每个库的数据都不一样。
所有库的并集是全量数据。

② 水平分表

以字段为依据，按照一定策略，将一个表的数据拆分到多个表中。

特点：

每个表的表结构都一样。
每个表的数据都不一样。
所有表的并集是全量数据。

Mycat 入门

(1) 安装

Mycat 是采用 java 语言开发的开源的数据库中间件，支持 Windows 和 Linux 运行环境，下面介绍 Mycat 在 Linux 中的环境搭建，我们需要在准备好的服务器中安装如下软件。

MySQL
JDK
Mycat

服务器	安装软件	说明
192.168.200.210	JDK、Mycat	Mycat 中间件服务器
192.168.200.210	MySQL	分片服务器
192.168.200.213	MySQL	分片服务器
192.168.200.214	MySQL	分片服务器

(2) 概念介绍

(3) 需求

由于 tb_order 表中数据量很大，磁盘 IO 及容量都到达了瓶颈，现在需要对 tb_order 表进行数据分片，分为三个数据节点，每一个节点主机位于不同的服务器上，具体的结构，参考下图：

(4) 分片配置

编

(5) 启动服务

切换到 Mycat 的安装目录，执行如下指令，启动 Mycat：

#启动
bin/mycat start
#停止
bin/mycat stop

Mycat 启动之后，占用端口号 8066。

启动完毕之后，可以查看 logs 目录下的启动日志，查看 Mycat 是否启动完成。

(6) 分片测试

① 通过如下指令，就可以连接并操作 Mycat。

1	mysql -h 192.168.200.210 -P 8066 -uroot -p123456

② 然后就可以在 Mycat 中创建表，并往结构中插入数据，查看数据在 MySQL 中的分布情况。

CREATE TABLE TB_ORDER(
  id BIGINT(20) NOT NULL,
  title VARCHAR(100) NOT NULL,
  PRIMARY KEY (id)
)ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT INTO TB_ORDER(id,title) VALUES(1,'goods1');
INSERT INTO TB_ORDER(id,title) VALUES(2,'goods2');
INSERT INTO TB_ORDER(id,title) VALUES(3,'goods3');
INSERT INTO TB_ORDER(id,title) VALUES(1000000,'goods1000000');
INSERT INTO TB_ORDER(id,title) VALUES(10000000,'goods10000000');

MyCat 配置

(1) schema.xml

schema.xml作为MyCat中最重要的配置文件之一,涵盖了MyCat的逻辑库、逻辑表、分片规则、分片节点及数据源的配置。

主要包含以下三组标签：

schema标签
datanode标签
datahost标签

① schema标签（第一行）

1
2
3

<schema name="DB01" checkSQLschema="true" sqlMaxLimit="100" >
    <table name="TB_ORDER" dataNode="dn1,dn2,dn3" rule="auto-sharding-long" />
schema>

schema 标签用于定义 MyCat 实例中的逻辑库，一个 MyCat 实例中，可以有多个逻辑库，可以通过 schema 标签来划分不同的逻辑库。

MyCat 中的逻辑库的概念，等同于 MySQL 中的 database 概念，需要操作某个逻辑库下的表时，也需要切换逻辑库 (use xxx)。

核心属性：

name：指定自定义的逻辑库库名
checkSQLschema：在 SQL 语句操作时指定了数据库名称，执行时是否自动去除；true：自动去除，false：不自动去除
sqlMaxLimit：如果未指定 limit 进行查询，列表查询模式查询多少条记录

② table 标签

1
2
3

<schema name="DB01" checkSQLschema="true" sqlMaxLimit="100" >
    <table name="TB_ORDER" dataNode="dn1,dn2,dn3" rule="auto-sharding-long" />
schema>

table 标签定义了 MyCat 中逻辑库 schema 下的逻辑表，所有需要拆分的表都需要在 table 标签中定义。

核心属性：

name：定义逻辑表表名，在该逻辑库下唯一
dataNode：定义逻辑表所属的 dataNode，该属性需要与 dataNode 标签中 name 对应；多个 dataNode 逗号分隔
rule：分片规则的名字，分片规则名字是在 rule.xml 中定义的
primaryKey：逻辑表对应真实表的主键
type：逻辑表的类型，目前逻辑表只有全局表和普通表，如果未配置，就是普通表；全局表，配置为 global

③ dataNode 标签

1
2
3

<dataNode name="dn1" dataHost="dhost1" database="db01" />
<dataNode name="dn2" dataHost="dhost2" database="db01" />
<dataNode name="dn3" dataHost="dhost3" database="db01" />

dataNode 标签中定义了 MyCat 中的数据节点，也就是我们通常说的数据分片。一个 dataNode 标签就是一个独立的数据分片。

核心属性：

name：定义数据节点名称
dataHost：数据库实例主机名称，引用自 dataHost 标签中 name 属性
database：定义分片所属数据库

④ dataHost 标签

<dataHost name="dhost1" maxCon="1000" minCon="10" balance="0" writeType="0" dbType="mysql" dbDriver="jdbc">
    <heartbeat>select user()heartbeat>
    <writeHost host="master" url="jdbc:mysql://192.168.200.210:3306?useSSL=false&serverTimezone=Asia/Shanghai&characterEncoding=utf8"
        user="root" password="1234">
    writeHost>
dataHost>

核心属性：

name：唯一标识，供上层标签使用
maxCon/minCon：最大连接数 / 最小连接数
balance：负载均衡策略，取值 0,1,2,3
writeType：写操作分发方式（0：写操作转发到第一个 writeHost，第一个挂了，切换到第二个；1：写操作随机分发到配置的 writeHost）
dbDriver：数据库驱动，支持 native、jdbc

(2) rule.xml

rule.xml 中定义所有分表的规则，在使用过程中可以灵活的使用分片算法，或者对同一个分片算法使用不同的参数，它让分片过程可配置化。主要包含两类标签：tableRule、function。

(3) server.xml

① system 标签

<system>
    <property name="nonePasswordLogin">0property>
    <property name="useHandshakeV10">1property>
    <property name="useSqlStat">1property>
system>

② user 标签

分库分表

垂直拆分

(1) 场景

(2) 配置

<schema name="SHOPPING" checkSQLschema="true" sqlMaxLimit="100" >
    <table name="tb_goods_base" dataNode="dn1" primaryKey="id"/>
    <table name="tb_goods_cat" dataNode="dn1" primaryKey="id"/>
    <table name="tb_goods_desc" dataNode="dn1" primaryKey="goods_id"/>
    <table name="tb_goods_item" dataNode="dn1" primaryKey="id"/>
    <table name="tb_order_item" dataNode="dn2" primaryKey="id"/>
    <table name="tb_order_master" dataNode="dn2" primaryKey="order_id" rule="order_rule" />
    <table name="tb_order_pay_log" dataNode="dn2" primaryKey="out_trade_no"/>
    <table name="tb_user" dataNode="dn3" primaryKey="id"/>
    <table name="tb_areas_provinces" dataNode="dn3" primaryKey="id"/>
    <table name="tb_areas_city" dataNode="dn3" primaryKey="id"/>
    <table name="tb_areas_region" dataNode="dn3" primaryKey="id"/>
    <table name="tb_user_address" dataNode="dn3" primaryKey="id"/>
schema>

<dataNode name="dn1" dataHost="dhost1" database="shopping" />
<dataNode name="dn2" dataHost="dhost2" database="shopping" />
<dataNode name="dn3" dataHost="dhost3" database="shopping" />

说明：

schema 节点下关联多个 table 标签，不同 table 对应不同 dataNode：

① dn1 对应商品类表（如 tb_goods_base、tb_goods_cat 等）

② dn2 对应订单类表（如 tb_order_item、tb_order_master 等）

③ dn3 对应用户及地址类表（如 tb_user、tb_areas_provinces 等）

(3) 测试

① 在 mycat 的命令行中，通过 source 指令导入表结构及对应数据，查看数据分布情况：

1 2	source /root/shopping_table.sql source /root/shopping_insert.sql

② 查询用户的收件人及收件人地址信息 (包含省、市、区)：

select ua.user_id,ua.contact,p.province,c.city,r.area,ua.address from tb_user_address ua,tb_areas_city c,tb_areas_provinces p,tb_areas_region r where ua.province_id = p.provinceid and ua.city_id = c.cityid and ua.town_id = r.areaid ;

③ 查询每一笔订单及订单的收件地址信息 (包含省、市、区)：

SELECT o.order_id, p.payment,o.receiver,p.province,c.city,r.area FROM tb_order_master o,tb_areas_provinces p,tb_areas_city c,tb_areas_region r WHERE o.receiver_province = p.provinceid AND o.receiver_city = c.cityid AND o.receiver_region = r.areaid ;

(4) 全局表配置

对于省、市、区 / 县表tb_areas_provinces, tb_areas_city, tb_areas_region，是属于数据字典表，在多个业务模块中都可能会遇到，可以将其设置为全局表，利于业务操作。

1
2
3

<table name="tb_areas_provinces" dataNode="dn1,dn2,dn3" primaryKey="id" type="global"/>
<table name="tb_areas_city" dataNode="dn1,dn2,dn3" primaryKey="id" type="global"/>
<table name="tb_areas_region" dataNode="dn1,dn2,dn3" primaryKey="id" type="global"/>

水平拆分

(1) 场景

在业务系统中，有一张表 (日志表)，业务系统每天都会产生大量的日志数据，单台服务器的数据存储及处理能力是有限的，可以对数据库表进行拆分。

(2) 配置

① shema.xml

<schema name="ITCAST" checkSQLschema="true" sqlMaxLimit="100" >
    <table name="tb_log" dataNode="dn4,dn5,dn6" rule="mod-long" />
schema>
<dataNode name="dn4" dataHost="dhost1" database="itcast" />
<dataNode name="dn5" dataHost="dhost2" database="itcast" />
<dataNode name="dn6" dataHost="dhost3" database="itcast" />

② server.xml

<user name="root" defaultAccount="true">
    <property name="password">123456property>
    <property name="schemas">SHOPPING,ITCASTproperty>
    
    
user>

(3) 测试

在 mycat 的命令行中，执行如下 SQL 建表、并插入数据，查看数据分布情况。

CREATE TABLE tb_log (
id bigint(20) NOT NULL COMMENT 'ID',
model_name varchar(200) DEFAULT NULL COMMENT '模块名',
model_value varchar(200) DEFAULT NULL COMMENT '模块值',
type varchar(200) DEFAULT NULL COMMENT '类型',
return_value varchar(200) DEFAULT NULL COMMENT '返回值',
return_class varchar(200) DEFAULT NULL COMMENT '返回类型',
operate_user varchar(200) DEFAULT NULL COMMENT '操作用户',
operate_time timestamp NULL DEFAULT NULL COMMENT '操作时间',
param_and_value varchar(500) DEFAULT NULL COMMENT '请求参数名及参数值',
operate_class varchar(200) DEFAULT NULL COMMENT '操作类',
operate_method varchar(200) DEFAULT NULL COMMENT '操作方法',
cost_time bigint(20) DEFAULT NULL COMMENT '执行方法耗时,单位ms',
summary text DEFAULT NULL COMMENT '摘要 1.2,Arond.102',
PRIMARY KEY (id)
)ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

分片规则

(1) 范围分片

根据指定的字段及其配置的范围与数据节点的对应情况，来决定该数据属于哪一个分片。

说明：

0~5000000 → dataNode1
5000001~10000000 → dataNode2
10000001 及以上 → dataNode3

(2) 取模分片

根据指定的字段值与节点数量进行求模运算，根据运算结果，来决定该数据属于哪一个分片。

**说明：**通过id % 3的结果分配数据：

id%3=0 → dataNode1
id%3=1 → dataNode2
id%3=2 → dataNode3

(3) 一致性hash 分片

所谓一致性哈希，相同的哈希因子计算总是被划分到相同的分区表中，不会因为分区节点的增加而改变原来数据的分区位置。

① schema.xml

<table name="tb_order" dataNode="dn4,dn5,dn6" rule="sharding-by-murmur" />

<dataNode name="dn4" dataHost="dhost1" database="itcast" />
<dataNode name="dn5" dataHost="dhost2" database="itcast" />
<dataNode name="dn6" dataHost="dhost3" database="itcast" />

② rule.xml

<tableRule name="sharding-by-murmur">
    <rule>
        <columns>idcolumns>
        <algorithm>murmuralgorithm>
    rule>
tableRule>

<function name="murmur" class="io.mycat.route.function.PartitionByMurmurHash">
    <property name="seed">0property> 
    <property name="count">3property> 
    <property name="virtualBucketTimes">160property> 
    
function>

(4) 枚举分片

通过在配置文件中配置可能的枚举值，指定数据分布到不同数据库节点上。本规则适用于按照省份、性别、状态拆分数据等业务。

(5) 应用指定算法

运行阶段由应用自主决定路由到哪个分片，直接根据字符串（必须是数字）计算分片号。

说明：

00xxxx → 对应 dataNode1 的数据库
01xxxx → 对应 dataNode2 的数据库
02xxxx → 对应 dataNode3 的数据库

(6) 固定hash算法

该算法类似于十进制的求模运算，但是为二进制的操作，例如，取 id 的二进制低 10 位与1111111111进行位 & 运算。

说明：

① 任何一个十位的二进制与 1111111111（十位全1）进行与运算后的结果，结果就是这个十位二进制数本身。

② 原因是这个二进制数的每一位都是 1，因此在与运算中：

如果原数某一位是 1 → 1 & 1 = 1
如果原数某一位是 0 → 0 & 1 = 0

也就是说，它不会改变原数的任何一位，只是保留原数的所有位。

③ 举例验证：假设原数是 1010101010（十位）：

  1010101010
& 1111111111
-----------
  1010101010  ← 结果和原数完全相同

(7) 字符串hash解析

截取字符串中的指定位置的子字符串，进行hash算法，算出分片

运算示例：

以 “world” 为例：

截取子串：world → 取0:2对应 “wor”
执行 hash 运算：得到结果 26629
计算分片：26629 & (1024-1) = 5

(8) 按天分片

说明：

配置参数：begin:2022-01-01、end:2022-01-30、partitionDay:10

分片时间区间与 dataNode 对应：

2022-01-01 ~ 2022-01-10 → dataNode1
2022-01-11 ~ 2022-01-20 → dataNode2
2022-01-21 ~ 2022-01-30 → dataNode3

(9) 按月分片

使用场景为按月份来分片，每个自然月为一个分片

说明：

分片时间范围为 begin:2022-01-01 至 end:2022-03-31，数据按月份对应到不同 dataNode：

dataNode1 对应数据：2022-01-10、2022-04-12（注：结束时间后会循环分片）
dataNode2 对应数据：2022-02-20
dataNode3 对应数据：2022-03-31

Mycat 管理及监控

(1) Mycat 原理

① select * from tb_user;

客户端把 SQL 发给 Mycat Server；
Mycat 先解析 SQL，再做分片分析（按规则，这个 SQL 要查所有分片）；
经路由分析，确定要访问右边 3 个数据库节点；
从 3 个节点取数据后，做分页、排序、聚合、结果合并；
把合并后的结果返回给客户端。

② select * from tb_user where status in(1,3) order by id;

客户端发 SQL 后，Mycat 解析出status条件；
分片分析 + 路由分析：只需要访问status=1（dn1）和status=3（dn3）的数据库；
从这 2 个节点取数据后，做排序处理 + 结果合并；
返回最终结果给客户端。

(2) Mycat 管理

① Mycat 默认开通 2 个端口，可在server.xml中修改：

8066 数据访问端口，用于执行 DML 和 DDL 操作。
9066 数据库管理端口，用于管理 Mycat 集群状态。

② 连接管理端口的命令：

1	mysql -h 192.168.200.210 -P 9066 -uroot -p123456

③ Mycat 管理命令及含义：

命令	含义
show @@help	查看 Mycat 管理工具文档
show @@version	查看 Mycat 的版本
reload @@config	重新加载 Mycat 的配置文件
show @@datasource	查看 Mycat 的数据源信息
show @@datanode	查看 Mycat 现有的分片节点信息
show @@threadpool	查看 Mycat 的线程池信息
show @@sql	查看执行的 SQL
show @@sql.sum	查看执行的 SQL 统计

读写分离

介绍

(1) 读写分离，简单地说是把对数据库的读和写操作分开，对应不同的数据库服务器。主数据库提供写操作，从数据库提供读操作，这样能有效地减轻单台数据库的压力。

(2) 通过 MyCat 即可轻易实现上述功能，不仅可以支持 MySQL，也可以支持 Oracle 和 SQL Server。

说明：

① 应用程序连接 MyCat，MyCat 将insert/update/delete操作路由到writeHost对应的主库（mysql (m)）

② 将select操作路由到readHost对应的从库（mysql (s)）

③ 主库与从库之间通过主从复制（blog）同步数据

一主一从读写分离

(1) 配置

Mycat 中balance参数的取值及含义说明表：

参数值	含义
0	不开启读写分离机制，所有读操作都发送到当前可用的 writeHost 上
1	全部的 readHost 与备用的 writeHost 都参与 select 语句的负载均衡（主要针对于双主双从模式）
2	所有的读写操作都随机在 writeHost、readHost 上分发
3	所有的读请求随机分发到 writeHost 对应的 readHost 上执行，writeHost 不负担读压力

双主双从

(1) 介绍

一个主机 Master1 用于处理所有写请求，它的从机 Slave1 和另一台主机 Master2 还有它的从机 Slave2 负责所有读请求。当 Master1 主机宕机后，Master2 主机负责写请求，Master1、Master2 互为备机。架构图如下：

说明：

① 应用程序连接 MyCat，MyCat 分发请求；

② mysql (m1)（Master1）复制数据到 mysql (s1)（Slave1），mysql (m2)（Master2）复制数据到 mysql (s2)（Slave2），同时 mysql (m1) 与 mysql (m2) 之间也存在复制关系，mysql (m1) 为主、mysql (m2) 为备

**Q：**主库不是负责写的吗？为什么 Master2 负责读了？

**A：双主双从中，Master1 是 “主用主库”：默认承担所有写请求；**而 Master2 是“备用主库”

平时（Master1 正常运行时），它不处理写请求，而是作为读节点来分担读压力（和 Slave1、Slave2 一起负责读请求）；
只有当 Master1 宕机后，它才会切换为 “主库”，接手写请求。

(2) 准备工作

我们需要准备 5 台服务器，具体的服务器及软件安装情况如下：

编号	IP	预装软件	角色
1	192.168.200.210	MyCat、MySQL	MyCat 中间件服务器
2	192.168.200.211	MySQL	M1（Master1）
3	192.168.200.212	MySQL	S1（Slave1）
4	192.168.200.213	MySQL	M2（Master2）
5	192.168.200.214	MySQL	S2（Slave2）

关闭以上所有服务器的防火墙：

systemctl stop firewalld
systemctl disable firewalld

(3) 搭建

① 主库配置（M1）

修改配置文件 /etc/my.cnf

#mysql 服务ID，保证整个集群环境中唯一，取值范围：1 - 2^32-1，默认为1
server-id=1
#指定同步的数据库
binlog-do-db=db01
binlog-do-db=db02
binlog-do-db=db03
#在作为从数据库的时候，有写入操作也要更新二进制日志文件
log-slave-updates

重启 MySQL 服务器

1	systemctl restart mysqld

② 主库配置（M2）

修改配置文件 /etc/my.cnf

#mysql 服务ID，保证整个集群环境中唯一，取值范围：1 - 2^32-1，默认为1
server-id=3
#指定同步的数据库
binlog-do-db=db01
binlog-do-db=db02
binlog-do-db=db03
#在作为从数据库的时候，有写入操作也要更新二进制日志文件
log-slave-updates

重启 MySQL 服务器

1	systemctl restart mysqld

③ 两台主库创建账户并授权（注：该操作需在 Master1、Master2 两台主库分别执行）

# 创建itcast用户，并设置密码，该用户可在任意主机连接该MySQL服务
CREATE USER 'itcast'@'%' IDENTIFIED WITH mysql_native_password BY 'Root@123456';

# 为'itcast'@'%'用户分配主从复制权限
GRANT REPLICATION SLAVE ON *.* TO 'itcast'@'%';

查看两台主库的二进制日志坐标

1	show master status;

④ 从库配置（S1）

修改配置文件 /etc/my.cnf

1 2	#mysql 服务ID，保证整个集群环境中唯一，取值范围：1 - 2^32-1，默认为1 server-id=2

重启 MySQL 服务器

1	systemctl restart mysqld

⑤ 从库配置（S2）

修改配置文件 /etc/my.cnf

1 2	#mysql 服务ID，保证整个集群环境中唯一，取值范围：1 - 2^32-1，默认为1 server-id=4

重启 MySQL 服务器

1	systemctl restart mysqld

⑥ 两台从库关联的从库

执行CHANGE MASTER TO命令，关联对应的主库（注意：slave1 对应 master1，slave2 对应 master2）：

CHANGE MASTER TO 
MASTER_HOST='xxx.xxx.xxx.xxx',  # 对应主库的IP
MASTER_USER='xxx',             # 主库授权的复制用户（如itcast）
MASTER_PASSWORD='xxx',         # 复制用户的密码（如Root@123456）
MASTER_LOG_FILE='xxx',         # 主库`show master status`查到的日志文件名
MASTER_LOG_POS=xxx;            # 主库`show master status`查到的日志位置

启动两台从库主从复制，查看从库状态

# 启动主从复制
start slave;

# 查看从库状态（需确保Slave_IO_Running、Slave_SQL_Running均为Yes）
show slave status\G;

(4) 测试

分别在两台主库Master1、Master2上执行DDL、DML语句，查看涉及到的数据库服务器的数据同步情况。

create database db01;
use db01;
create table tb_user(
id in(11)not null primary key,
name varchar(50) not null,
sex varcahr(1)
)engine=innodb default charset=utf8mb4

insert into tb user(id,name,sex) values(l,'Tom','1');
insert into tb user(id,name,sex) values(2,'Trigger','0');
insert into tb user(id,name,sex) values(3,'Dawn','1');
insert into tb user(id,name,sex) values(4,"ack Ma','1');
insertinto tb user(id,name,sex) values(5,'Coco','0');
insert into tb user(id,name,sex) values(6,'erry','1');

双主双从读写分离

(1) 配置

(2) 测试

① 登录MyCat，测试查询及更新操作，判定是否能够进行读写分离，以及读写分离的策略是否正确。

② 当主库挂掉一个之后，是否能够自动切换。

MySQL学习笔记之进阶篇

2026-03-28T03:00:00.000Z

存储引擎

MySQL体系结构：

(1) 连接层：最上层是一些客户端和链接服务，主要完成一些类似于连接处理、授权认证、及相关的安全方案。服务器也会为安全接入的每个客户端验证它所具有的操作权限。

(2) 服务层：第二层架构主要完成大多数的核心服务功能，如 SQL 接口，并完成缓存的查询，SQL 的分析和优化，部分内置函数的执行。所有跨存储引擎的功能也在这一层实现，如过程、函数等。

(3) 引擎层：存储引擎真正的负责了 MySQL 中数据的存储和提取，服务器通过 API 和存储引擎进行通信。不同的存储引擎具有不同的功能，这样我们可以根据自己的需要，来选取合适的存储引擎。

(4) 存储层：主要是将数据存储在文件系统之上，并完成与存储引擎的交互。

存储引擎

(1) 存储引擎就是存储数据、建立索引、更新/查询数据等技术的实现方式。存储引擎是基于表而不是基于库的，所以存储引擎也可以被称为表引擎。

(2) 默认存储引擎是InnoDB。

(3) 相关操作：

-- 查询建表语句
show create table account;
-- 建表时指定存储引擎
CREATE TABLE 表名(
...
) ENGINE=INNODB;
-- 查看当前数据库支持的存储引擎
show engines;

InnoDB

(1) InnoDB 是一种兼顾高可靠性和高性能的通用存储引擎，在 MySQL 5.5 之后，InnoDB 是默认的 MySQL 引擎

(2) 特点：

DML 操作遵循 ACID 模型，支持事务
行级锁，提高并发访问性能
支持外键约束，保证数据的完整性和正确性

① 表锁：锁住整个表的锁。当某个人操作（增删改）这个表时，会把整个表 “锁起来”，其他人在锁释放前，不能操作这个表的任何数据。

② 行锁（hang suo）：只锁住表中某一行（或几行）数据的锁。当某个人操作某一行时，只锁这一行，其他行的数据还是可以被其他人正常操作。

(3) 文件：

xxx.ibd: xxx代表表名，InnoDB 引擎的每张表都会对应这样一个表空间文件，存储该表的表结构（frm、sdi）、数据和索引。

参数：innodb_file_per_table，决定多张表共享一个表空间还是每张表对应一个表空间

(4) InnoDB 逻辑存储结构：

MyISAM

(1) MyISAM 是 MySQL 早期的默认存储引擎。

(2) 特点：

不支持事务，不支持外键
支持表锁，不支持行锁
访问速度快

(3) 文件：

xxx.sdi: 存储表结构信息
xxx.MYD: 存储数据
xxx.MYI: 存储索引

Memory

(1) Memory 引擎的表数据是存储在内存中的，受硬件问题、断电问题的影响，只能将这些表作为临时表或缓存使用。

(2) 特点：

存放在内存中，速度快
hash索引（默认）

(3) 文件：

xxx.sdi: 存储表结构信息

存储引擎特点

特点	InnoDB	MyISAM	Memory
存储限制	64TB	有	有
事务安全	支持	-	-
锁机制	行锁	表锁	表锁
B+tree索引	支持	支持	支持
Hash索引	-	-	支持
全文索引	支持（5.6版本之后）	支持	-
空间使用	高	低	N/A
内存使用	高	低	中等
批量插入速度	低	高	高
支持外键	支持	-	-

存储引擎的选择

(1) 在选择存储引擎时，应该根据应用系统的特点选择合适的存储引擎。对于复杂的应用系统，还可以根据实际情况选择多种存储引擎进行组合。

InnoDB: 如果应用对事物的完整性有比较高的要求，在并发条件下要求数据的一致性，数据操作除了插入和查询之外，还包含很多的更新、删除操作，则 InnoDB 是比较合适的选择
MyISAM: 如果应用是以读操作和插入操作为主，只有很少的更新和删除操作，并且对事务的完整性、并发性要求不高，那这个存储引擎是非常合适的。
Memory: 将所有数据保存在内存中，访问速度快，通常用于临时表及缓存。Memory 的缺陷是对表的大小有限制，太大的表无法缓存在内存中，而且无法保障数据的安全性

电商中的足迹和评论适合使用 MyISAM 引擎，缓存适合使用 Memory 引擎。

索引

索引是帮助 MySQL 高效获取数据的数据结构（有序）。在数据之外，数据库系统还维护着满足特定查找算法的数据结构，这些数据结构以某种方式引用（指向）数据，这样就可以在这些数据结构上实现高级查询算法，这种数据结构就是索引。

优缺点：

① 优点：

提高数据检索效率，降低数据库的IO成本
通过索引列对数据进行排序，降低数据排序的成本，降低CPU的消耗

② 缺点：

索引列也是要占用空间的
索引大大提高了查询效率，但降低了更新的速度，比如 INSERT、UPDATE、DELETE

索引结构

索引结构	描述
B+Tree	最常见的索引类型，大部分引擎都支持B+树索引
Hash	底层数据结构是用哈希表实现，只有精确匹配索引列的查询才有效，不支持范围查询
R-Tree(空间索引)	空间索引是 MyISAM 引擎的一个特殊索引类型，主要用于地理空间数据类型，通常使用较少
Full-Text(全文索引)	是一种通过建立倒排索引，快速匹配文档的方式，类似于 Lucene, Solr, ES

索引	InnoDB	MyISAM	Memory
B+Tree索引	支持	支持	支持
Hash索引	不支持	不支持	支持
R-Tree索引	不支持	支持	不支持
Full-text	5.6版本后支持	支持	不支持

(1) B-Tree（多路平衡查找树）

① 二叉树缺点：顺序插入时，会形成一个链表，查询性能大大降低。大数据量情况下，层级较深，检索速度慢。而二叉树的缺点可以用红黑树来解决：

② 红黑树也存在大数据量情况下，层级较深，检索速度慢的问题。为了解决上述问题，可以使用 B-Tree 结构。

③ B-Tree 以一棵最大度数（max-degree，指一个节点的子节点个数）为5（5阶）的 b-tree 为例（每个节点最多存储4个key，5个指针）

(2) B+Tree

① 与 B-Tree 的区别：

所有的数据都会出现在叶子节点
叶子节点形成一个单向链表

② MySQL 索引数据结构对经典的 B+Tree 进行了优化。在原 B+Tree 的基础上，增加一个指向相邻叶子节点的链表指针，就形成了带有顺序指针的 B+Tree，提高区间访问的性能。

(3) Hash

① 哈希索引就是采用一定的hash算法，将键值换算成新的hash值，映射到对应的槽位上，然后存储在hash表中。如果两个（或多个）键值，映射到一个相同的槽位上，他们就产生了hash冲突（也称为hash碰撞），可以通过链表来解决。

② 特点：

Hash索引只能用于对等比较（=、in），不支持范围查询（betwwn、>、<、…）
无法利用索引完成排序操作
查询效率高，通常只需要一次检索就可以了，效率通常要高于 B+Tree 索引

③ 存储引擎支持：

Memory
InnoDB: 具有自适应hash功能，hash索引是存储引擎根据 B+Tree 索引在指定条件下自动构建的

(4) 面试题：为什么 InnoDB 存储引擎选择使用 B+Tree 索引结构？

相对于二叉树，层级更少，搜索效率高
对于 B-Tree，无论是叶子节点还是非叶子节点，都会保存数据，这样导致一页中存储的键值减少，指针也跟着减少，要同样保存大量数据，只能增加树的高度，导致性能降低
相对于 Hash 索引，B+Tree 支持范围匹配及排序操作

索引分类

分类	含义	特点	关键字
主键索引	针对于表中主键创建的索引	默认自动创建，只能有一个	PRIMARY
唯一索引	避免同一个表中某数据列中的值重复	可以有多个	UNIQUE
常规索引	快速定位特定数据	可以有多个
全文索引	全文索引查找的是文本中的关键词，而不是比较索引中的值	可以有多个	FULLTEXT

(1) 在 InnoDB 存储引擎中，根据索引的存储形式，又可以分为以下两种：

分类	含义	特点
聚集索引(Clustered Index)	将数据存储与索引放一块，索引结构的叶子节点保存了行数据	必须有，而且只有一个
二级索引(Secondary Index)	将数据与索引分开存储，索引结构的叶子节点关联的是对应的主键	可以存在多个

Q：叶子节点是什么？

A：叶子节点是 树结构中没有子节点的节点，也就是树的「最底层终端节点」

(2) 演示图：

(3) 聚集索引选取规则：

如果存在主键，主键索引就是聚集索引
如果不存在主键，将使用第一个唯一(UNIQUE)索引作为聚集索引
如果表没有主键或没有合适的唯一索引，则 InnoDB 会自动生成一个 rowid 作为隐藏的聚集索引

(4) 思考题

① 以下 SQL 语句，哪个执行效率高？为什么？

1
2
3

select * from user where id = 10;
select * from user where name = 'Arm';
-- 备注：id为主键，name字段创建的有索引

答：第一条语句，因为第二条需要回表查询，相当于两个步骤。

(2) InnoDB 主键索引的 B+Tree 高度为多少？

答：假设一行数据大小为1k，一页中可以存储16行这样的数据。InnoDB 的指针占用6个字节的空间，主键假设为bigint，占用字节数为8，可得公式：

1	n×8（主键总大小） + (n+1)×6（指针总大小） = 16×1024（页大小）

其中 8 表示 bigint 占用的字节数，n 表示当前节点存储的key的数量，(n + 1) 表示指针数量（比key多一个）。算出n约为1170。

① 如果树的高度为2，那么他能存储的数据量为：

根节点是 1 个非叶子节点，有 1171 个指针；
每个指针对应 1 个叶子节点，每个叶子节点存 16 行；
总数据量 = 1171（叶子节点数量） × 16（每个叶子节点行数） = 18736 行。

② 如果树的高度为3，那么他能存储的数据量为：1171 * 1171 * 16 = 21939856。

根节点有 1171 个指针，对应 1171 个中间层非叶子节点；
每个中间层非叶子节点又有 1171 个指针，对应 1171 个叶子节点；
总数据量 = 1171（中间层数量） × 1171（叶子节点数量） × 16（每个叶子节点行数） ≈ 2193 万行。

语法

(1) 创建索引：

1	CREATE [ UNIQUE \| FULLTEXT ] INDEX index_name ON table_name (index_col_name, ...);

如果 CREATE 后面不加索引类型参数，则创建的是常规索引

(2) 查看索引：

1	SHOW INDEX FROM table_name;

(3) 删除索引：

1	DROP INDEX index_name ON table_name;

(4) 案例：

-- name字段为姓名字段，该字段的值可能会重复，为该字段创建索引
create index idx_user_name on tb_user(name);
-- phone手机号字段的值非空，且唯一，为该字段创建唯一索引
create unique index idx_user_phone on tb_user (phone);
-- 为profession, age, status创建联合索引
create index idx_user_pro_age_stat on tb_user(profession, age, status);
-- 为email建立合适的索引来提升查询效率
create index idx_user_email on tb_user(email);

-- 删除索引
drop index idx_user_email on tb_user;

性能分析

(1) 查看执行频次

查看当前数据库的 INSERT, UPDATE, DELETE, SELECT 访问频次：

1	SHOW GLOBAL STATUS LIKE 'Com_______';

(2) 慢查询日志

① 慢查询日志记录了所有执行时间超过指定参数（long_query_time，单位：秒，默认10秒）的所有SQL语句的日志。

② MySQL的慢查询日志默认没有开启，需要在MySQL的配置文件（/etc/my.cnf）中配置如下信息：

# 开启慢查询日志开关
slow_query_log=1
# 设置慢查询日志的时间为2秒，SQL语句执行时间超过2秒，就会视为慢查询，记录慢查询日志
long_query_time=2

③ 查看慢查询日志开关状态：

1	show variables like 'slow_query_log';

(3) profile

① show profile 能在做SQL优化时帮我们了解时间都耗费在哪里。通过 have_profiling 参数，能看到当前 MySQL 是否支持 profile 操作：

1	SELECT @@have_profiling;

② profiling 默认关闭，可以通过set语句在session/global级别开启 profiling：

1	SET profiling = 1;

③ 查看所有语句的耗时：

1	show profiles;

④ 查看指定query_id的SQL语句各个阶段的耗时：

1	show profile for query query_id;

⑤ 查看指定query_id的SQL语句CPU的使用情况

1	show profile cpu for query query_id;

(4) explain

① EXPLAIN 或者 DESC 命令获取 MySQL 如何执行 SELECT 语句的信息，包括在 SELECT 语句执行过程中表如何连接和连接的顺序。

② 语法：

1 2	# 直接在select语句之前加上关键字 explain / desc EXPLAIN SELECT 字段列表 FROM 表名 HWERE 条件;

③ EXPLAIN 各字段含义：

id：select 查询的序列号，表示查询中执行 select 子句或者操作表的顺序（id相同，执行顺序从上到下；id不同，值越大越先执行）
select_type：表示 SELECT 的类型，常见取值有 SIMPLE（简单表，即不适用表连接或者子查询）、PRIMARY（主查询，即外层的查询）、UNION（UNION中的第二个或者后面的查询语句）、SUBQUERY（SELECT/WHERE之后包含了子查询）等
type：表示连接类型，性能由好到差的连接类型为 NULL、system、const、eq_ref、ref、range、index、all
possible_key：可能应用在这张表上的索引，一个或多个
Key：实际使用的索引，如果为 NULL，则没有使用索引
Key_len：表示索引中使用的字节数，该值为索引字段最大可能长度，并非实际使用长度，在不损失精确性的前提下，长度越短越好
rows：MySQL认为必须要执行的行数，在InnoDB引擎的表中，是一个估计值，可能并不总是准确的
filtered：表示返回结果的行数占需读取行数的百分比，filtered的值越大越好

使用规则

(1) 最左前缀法则

① 如果索引关联了多列（联合索引），要遵守最左前缀法则，最左前缀法则指的是查询从索引的最左列开始，并且不跳过索引中的列。

② 如果跳跃某一列，索引将部分失效（后面的字段索引失效）。

③ 代码示例：

-- 走索引，跟顺序没关系
explain select * from tb_user where profession = '软件工程' and age = 31 and status = '0';
explain select * from tb_user where age = 31 and profession = '软件工程' and status = '0';

-- 不走索引，全部失效
explain select * from tb_user where age = 31 and status = '0';

-- 部分失效
explain select * from tb_user where profession = '软件工程' and status = '0';

④ 联合索引中，出现范围查询（<, >），范围查询右侧的列索引失效。可以用 >= 或者 <= 来规避索引失效问题。

(2) 索引失效情况

① 在索引列上进行运算操作，索引将失效。例如：

1	explain select * from tb_user where substring(phone, 10, 2) = '15';

② 字符串类型字段使用时，不加引号，索引将失效。例如：

1 2	-- 此处phone的值没有加引号 explain select * from tb_user where phone = 17799990015;

③ 模糊查询中，如果仅仅是尾部模糊匹配，索引不会是失效；如果是头部模糊匹配，索引失效。例如：

-- 索引失效 
explain select * from tb_user where profession like '软件%';

-- 索引不失效
explain select * from tb_user where profession like '%工程';

④ 用 or 分割开的条件，如果 or 其中一个条件的列没有索引，那么涉及的索引都不会被用到。只有两侧都有索引的时候，索引才会生效。如果要让数据的索引不失效，那么要给没有索引的创建索引。

-- 假设 age 无索引，则第一句索引失效
explain select * from tb_user where id = 10 or age = 23;

-- 为 age 创建索引后，索引成功
create index idx_user_age on tb_user(age);
explain select * from tb_user where id = 10 or age = 23;

⑤ 如果 MySQL 评估使用索引比全表更慢，则不使用索引。

SQL 提示

这是优化数据库的一个重要手段，简单来说，就是在SQL语句中加入一些人为的提示来达到优化操作的目的。例如：

① 使用索引：

1	explain select * from tb_user use index(idx_user_pro) where profession="软件工程";

② 不使用哪个索引：

1	explain select * from tb_user ignore index(idx_user_pro) where profession="软件工程";

③ 必须使用哪个索引：

1	explain select * from tb_user force index(idx_user_pro) where profession="软件工程";

use 是建议，实际使用哪个索引 MySQL 还会自己权衡运行速度去更改，force就是无论如何都强制使用该索引。

覆盖索引&回表查询

(1) 尽量使用覆盖索引（查询使用了索引，并且需要返回的列，在该索引中已经全部能找到），减少 select *。explain 中 extra 字段含义：

① using index condition：查找使用了索引，但是需要回表查询数据

② using where; using index;：查找使用了索引，但是需要的数据都在索引列中能找到，所以不需要回表查询

(2) 如果在辅助索引中找聚集索引，只需要通过辅助索引(name)查找到对应的id，返回name和name索引对应的id即可，只需要一次查询。例如：

1	select id, name from xxx where name='xxx';

(3) 如果是通过辅助索引查找其他字段，则需要回表查询，例如：

1	select id, name, gender from xxx where name='xxx';

(4) 所以尽量不要用select *，容易出现回表查询，降低效率，除非有联合索引包含了所有字段

(5) 面试题：一张表，有四个字段（id, username, password, status），由于数据量大，需要对以下SQL语句进行优化，该如何进行才是最优方案：

1	select id, username, password from tb_user where username='itcast';

解：给username和password字段建立联合索引，则不需要回表查询，直接覆盖索引，这个优化的核心就是「让索引覆盖查询所需的所有字段」：

利用 InnoDB 二级索引默认带主键的特性；
把查询需要的非主键字段（password、username）加到联合索引里；
最终实现 “一次索引查询就能拿到所有数据”，彻底规避回表的性能损耗。

前缀索引

(1) 当字段类型为字符串（varchar, text等）时，有时候需要索引很长的字符串，这会让索引变得很大，查询时，浪费大量的磁盘IO，影响查询效率，此时可以只将字符串的一部分前缀，建立索引，这样可以大大节约索引空间，从而提高索引效率。

(2) 语法：

create index idx_xxxx on table_name(columnn(n));

-- 案例：
create index idx_email_5 on tb_user(email(5));

(3) 前缀长度：可以根据索引的选择性来决定，而选择性是指不重复的索引值（基数）和数据表的记录总数的比值，**索引选择性越高则查询效率越高，**唯一索引的选择性是1，这是最好的索引选择性，性能也是最好的。

(4) 求选择性公式：

1 2	select count(distinct email) / count() from tb_user; select count(distinct substring(email, 1, 5)) / count() from tb_user;

show index 里面的sub_part可以看到接取的长度

单列索引&联合索引

(1) 概念

① 单列索引：即一个索引只包含单个列

② 联合索引：即一个索引包含了多个列

在业务场景中，如果存在多个查询条件，考虑针对于查询字段建立索引时，建议建立联合索引，而非单列索引。

(2) 单列索引情况：

1 2	-- 这句只会用到phone索引字段 explain select id, phone, name from tb_user where phone = '17799990010' and name = '韩信';

注意事项

多条件联合查询时，MySQL优化器会评估哪个字段的索引效率更高，会选择该索引完成本次查询

(3) 设计原则

① 针对于数据量较大，且查询比较频繁的表建立索引

② 针对于常作为查询条件（where）、排序（order by）、分组（group by）操作的字段建立索引

③ 尽量选择区分度高的列作为索引，尽量**建立唯一索引，**区分度越高，使用索引的效率越高

④ 如果是字符串类型的字段，字段长度较长，可以针对于字段的特点，建立前缀索引

⑤ 尽量使用联合索引，减少单列索引，查询时，联合索引很多时候可以覆盖索引，节省存储空间，避免回表，提高查询效率

⑥ 要控制索引的数量，索引并不是多多益善，索引越多，维护索引结构的代价就越大，会影响增删改的效率

⑦ 如果索引列不能存储NULL值，请在创建表时使用NOT NULL约束它。当优化器知道每列是否包含NULL值时，它可以更好地确定哪个索引最有效地用于查询

SQL 优化

插入数据

普通插入

① 采用批量插入（一次插入的数据不建议超过1000条）

1	Insert into tb_test values(1,'Tom'),(2,'Cat'),(3,'Jerry');

② 手动提交事务

start transaction;
insert into tb_test values(1,'Tom'),(2,'Cat'),(3,'Jerry');
insert into tb_test values(4,'Tom'),(5,'Cat'),(6,'Jerry');
insert into tb_test values(7,'Tom'),(8,'Cat'),(9,'Jerry');
commit;

③ 主键顺序插入

1 2	主键乱序插入：8 1 9 21 88 2 4 15 89 5 7 3 主键顺序插入：1 2 3 4 5 7 8 9 15 21 88 89

大批量插入：

如果一次性需要插入大批量数据，使用insert语句插入性能较低，此时可以使用MySQL数据库提供的load指令插入。

# 客户端连接服务端时，加上参数 --local-infile（这一行在bash/cmd界面输入）
mysql --local-infile -u root -p
# 设置全局参数local_infile为1，开启从本地加载文件导入数据的开关
set global local_infile = 1;
select @@local_infile;
# 执行load指令将准备好的数据，加载到表结构中
load data local infile '/root/load_user_100w_sort.sql' into table tb_user fields terminated by ',' lines terminated by '\n';

主键优化

数据组织方式：

在InnoDB存储引擎中，表数据都是根据主键顺序组织存放的，这种存储方式的表称为索引组织表（Index organized table, IOT）

数据库的存储是：

表空间（Tablespace） → 段（Segment） → 区（Extent） → 页（Page） → 行（Row）

页分裂：

页可以为空，也可以填充一半，也可以填充100%，每个页包含了2-N行数据（如果一行数据过大，会行溢出），根据主键排列。

① 触发场景：当你往表中插入数据时，InnoDB 会把数据存到对应的页里。如果当前页已经没有足够空间存新行（比如页的使用率快满了），就会触发 “页分裂”。

② 典型过程（以非自增主键插入为例）

步骤 1：插入前的页状态

1# 页：存了主键 1、5、9、23、47 的 5 条数据（页已经快存满了）；
2# 页：存了主键 55、67、89、101、107 的 5 条数据；
现在要插入 主键 = 50 的新行。

步骤 2：插入时的 “位置冲突”

主键是有序存储的，50 的大小介于 1# 页的最大主键（47）和 2# 页的最小主键（55）之间，所以50 应该存在 1# 和 2# 页之间。

但问题是：1# 页已经快存满了，没有空间放 50 这条新数据 → 触发页分裂。

步骤 3：页分裂后的结果

分裂后：

1# 页：把原来的部分数据（23、47）移出去，只留 1、5、9；
新建 3# 页：把移出的 23、47，加上新插入的 50，存在 3# 页（主键23、47、50）；
2# 页：保持原来的 55、67、89、101、107 不变。

页合并：

当删除一行记录时，实际上记录并没有被物理删除，只是记录被标记（flaged）为删除并且它的空间变得允许被其他记录声明使用。当页中删除的记录到达 MERGE_THRESHOLD（默认为页的50%），InnoDB会开始寻找最靠近的页（前后）看看是否可以将这两个页合并以优化空间使用。

MERGE_THRESHOLD：合并页的阈值，可以自己设置，在创建表或创建索引时指定

主键设计原则：

满足业务需求的情况下，尽量降低主键的长度。主键越长，每个 “索引页（Page）” 能存的主键数量就越少 → 索引树的层数会变多
插入数据时，尽量选择顺序插入，选择使用 AUTO_INCREMENT 自增主键
尽量不要使用 UUID 做主键或者是其他的自然主键，如身份证号。UUID 是随机生成的，插入时会像之前 “插入 50” 那样，随机插在页的中间位置 → 频繁触发页分裂，既耗性能又产生碎片；
业务操作时，避免对主键的修改

order by 优化

Using filesort：

通过表的索引或全表扫描，读取满足条件的数据行，然后在排序缓冲区 sort buffer 中完成排序操作，所有不是通过索引直接返回排序结果的排序都叫 FileSort 排序

Using index：

通过有序索引顺序扫描直接返回有序数据，这种情况即为 using index，不需要额外排序，操作效率高

(3) 如果order by字段全部使用升序排序或者降序排序，则都会走索引，但是如果一个字段升序排序，另一个字段降序排序，则不会走索引，explain的extra信息显示的是Using index, Using filesort，如果要优化掉Using filesort，则需要另外再创建一个索引，如：create index idx_user_age_phone_ad on tb_user(age asc, phone desc);，此时使用select id, age, phone from tb_user order by age asc, phone desc;会全部走索引

-- 创建索引
create index idx_user_age_phone on tb_user(age,phone);

-- 走索引
explain select id, age, phone from tb_user order by age desc, phone desc;

-- 不走索引，因为索引是 “先age，后phone” 排序的，而 order by 是 “先phone,后age”
explain select id, age, phone from tb_user order by phone, age;

-- 不走索引
explain select id, age, phone from tb_user order by age, phone desc;

-- 创建新的索引后，上面那句走索引
create index idx_user_age_pho_ad on tb_user(age asc, phone desc);

(4) 总结：

根据排序字段建立合适的索引，多字段排序时，也遵循最左前缀法则
尽量使用覆盖索引
多字段排序，一个升序一个降序，此时需要注意联合索引在创建时的规则（ASC/DESC）
如果不可避免出现filesort，大数据量排序时，可以适当增大排序缓冲区大小 sort_buffer_size（默认256k）

group by优化

(1) 在分组操作时，可以通过索引来提高效率

(2) 分组操作时，索引的使用也是遵循最左前缀法则的

-- 创建索引
create index idx_user_pro_age_sta on tb_user(profession,age,status);

-- 走索引
explain select profession, count(*) from tb_user group by profession;

-- 不走索引，不满足最左前缀法则
explain select age, count(*) from tb_user group by age;

-- 走索引
explain select profession, age, count(*) from tb_user group by profession, age;

-- 走索引
explain select profession, age, count(*) from tb_user where profession = '软件工程' group by age;

如索引为idx_user_pro_age_stat，则句式可以是select ... where profession order by age，这样也符合最左前缀法则

limit优化

常见的问题：

如limit 2000000, 10，此时需要 MySQL 排序前2000000条记录，但仅仅返回2000000 - 2000010的记录，其他记录丢弃，查询排序的代价非常大。

优化方案：

一般分页查询时，通过创建覆盖索引能够比较好地提高性能，可以通过覆盖索引加子查询形式进行优化

例如：

- 此语句耗时很长
select * from tb_sku limit 9000000, 10;
-- 通过覆盖索引加快速度，直接通过主键索引进行排序及查询
select id from tb_sku order by id limit 9000000, 10;
-- 下面的语句是错误的，因为 MySQL 不支持 in 里面使用 limit
-- select * from tb_sku where id in (select id from tb_sku order by id limit 9000000, 10);
-- 通过连表查询即可实现第一句的效果，并且能达到第二句的速度
select * from tb_sku as s, (select id from tb_sku order by id limit 9000000, 10) as a where s.id = a.id;

count优化

(1) MyISAM 引擎把一个表的总行数存在了磁盘上，因此执行 count(*) 的时候会直接返回这个数，效率很高（前提是不适用where）；

(2) InnoDB 在执行 count(*) 时，需要把数据一行一行地从引擎里面读出来，然后累计计数。

(3) 优化方案：自己计数，如创建key-value表存储在内存或硬盘，或者是用redis

(4) count 的几种用法：

① 如果 count 函数的参数（count里面写的那个字段）不是NULL（字段值不为NULL），累计值就加一，最后返回累计值

② 用法：count(*)、count(主键)、count(字段)、count(1)

③ count(主键) 跟 count() 一样，因为主键不能为空；count(字段) 只计算字段值不为NULL的行；count(1)引擎会为每行添加一个1，然后就count这个1，返回结果也跟count()一样；count(null)返回0

(5) 各种用法的性能：

① count(主键)：InnoDB引擎会遍历整张表，把每行的主键id值都取出来，返回给服务层，服务层拿到主键后，直接按行进行累加（主键不可能为空）

② count(字段)：没有not null约束的话，InnoDB引擎会遍历整张表把每一行的字段值都取出来，返回给服务层，服务层判断是否为null，不为null，计数累加；有not null约束的话，InnoDB引擎会遍历整张表把每一行的字段值都取出来，返回给服务层，直接按行进行累加

③ count(1)：InnoDB 引擎遍历整张表，但不取值。服务层对于返回的每一层，放一个数字 1 进去，直接按行进行累加

④ count(*)：InnoDB 引擎并不会把全部字段取出来，而是专门做了优化，不取值，服务层直接按行进行累加

按效率排序：count(字段) < count(主键) < count(1) < count()，所以尽量使用 count()

update优化（避免行锁升级为表锁）

(1) InnoDB 的行锁是针对索引加的锁，不是针对记录加的锁，并且该索引不能失效，否则会从行锁升级为表锁。

(2) 案例：

-- 这句由于id有主键索引，所以只会锁这一行
update student set no = '123' where id = 1;

-- 这句由于name没有索引，所以会把整张表都锁住进行数据更新，解决方法是给name字段添加索引
update student set no = '123' where name = 'test';

视图

介绍

(1) 视图(View)是一种虚拟存在的表。视图中的数据并不在数据库中实际存在，行和列数据来自定义视图的查询中使用的表，并且是在使用视图时动态生成的。

(2) 通俗的讲，视图只保存了查询的SQL逻辑，不保存查询结果。所以我们在创建视图的时候，主要的工作就落在创建这条SQL查询语句上。

语法

创建视图：

1	CREATE [OR REPLACE] VIEW 视图名称[(列名列表)] AS SELECT语句 [WITH[CASCADED \| LOCAL] CHECK OPTION

查询视图：

① 查看创建视图语句：

1	SHOW CRETE VIEW 视图名称;

② 查看视图数据：

1	SELECT * FROM 视图名称…;

修改视图：

① 方式一：

1	CREATE [OR REPLACE] VIEW 视图名称[(列名列表)] AS SELECT语句 [WITH[CASCADED \| LOCAL] CHECK OPTION

② 方式二：

1	ALTER VIEW 视图名称[(列名列表)] AS SELECT语句 [WITH[CASCADED \| LOCAL] CHECK OPTION]

删除视图：

1	DROP VIEW [IF EXISTS]视图名称 [,视图名称]

案例：

-- 创建视图
create or replace view stu_v_1 as select id, name from student where id <= 10;

-- 查询视图
show create view stu_v_1;

select * from stu_v_1;

-- 修改视图
create or replace view stu_v_1 as select id, name, no from student where id <= 10;

alter view stu_v_1 as select id, name from student where id <= 10;

-- 删除视图
drop view if exists stu_v_1;

检查选项

视图的检查选项：

① 当使用 WITH CHECK OPTION 子句创建视图时，MySQL 会通过视图检查正在更改的每个行，例如：插入，更新，删除，以使其符合视图的定义。MySQL 允许基于另一个视图创建视图，它还会检查依赖视图中的规则以保持一致性。

② 为了确定检查的范围，mysql 提供了两个选项:CASCADED 和 LOCAL，默认值为CASCADED。

cascaded：在对创建时含有该字段的视图，插入数据时，该视图依赖的视图都会加上检查，需要所有条件都满足才能够插入成功。
local：在对创建时含有该字段的视图，插入数据时，对于该视图依赖的视图中含有检查语句的条件进行检查判断。

with cascaded check option 的案例：

-- 创建视图，但不加 with check option
create or replace view stu_v_1 as select id, name from student where id <= 20;

-- 插入成功，会存入基表中（基表无约束），而且会显示在stu_v1视图中
insert into stu_v_1 values(5,'Tom');

-- 插入成功，虽然id=25不满足stu_v1的id <=20，但插入操作会成功（数据会存入student基表，但不会显示在stu_v1视图中），插入成功。
insert into stu_v_1 values(25,'Tom');

create or replace view stu_v_2 as select id, name from stu_v_1 where id >= 10 with cascaded check option;

-- 插入失败，因为不满足stu_v_2的条件：id >= 10
insert into stu_v_2 values(7,'Tom');

-- 插入失败，因为不满足基表stu_v1的条件：id <= 20
insert into stu_v_2 values(26,'Tom');

-- 插入成功
insert into stu_v_1 values(8,'Tom');

① 向无WITH CHECK OPTION的视图插入数据时，只要满足基表（student）的约束，插入会成功（但不满足视图筛选条件的行，不会显示在视图中）。

② 向有WITH CHECK OPTION的视图插入数据时，必须满足当前视图 + 所有底层视图的筛选条件（cascaded是级联检查所有底层视图），否则插入失败。

with local check option 的案例：

-- 创建视图
create or replace view stu_v_4 as select id, name from student where id <= 15 with local check option;

-- 插入成功，id = 5 满足 stu_v4 的 id <= 15，数据存入基表并且会显示在 stu_v4 中
insert into stu_v_4 values(5,'Tom');

-- 插入失败，16 > 15 不满足 stu_v_4 的 Local 约束，会被直接拦截
insert into stu_v_4 values(16,'Tom');

create or replace view stu_v_5 as select id, name from stu_v_4 where id >= 10 with local check option;

-- 插入成功
insert into stu_v_5 values (13,'Tom');

-- 插入失败，因为不满足 stu_v_4 的约束 id <= 15
insert into stu_v_5 values (17,'Tom');

insert into stu_v_5 values (18,'Tom');

create or replace view stu_v_6 as select id, name from stu_v_5 where id < 20;

-- 插入成功，stu_v_6 无 check option，但插入会触发底层的 stu_v_5 的 local 约束
-- 14 >= 10 满足 stu_v_5 的条件，14 <= 15 满足 stu_v_4 的条件
insert into stu_v_6 values (14,'Tom');

总结

① 没有 CHECK OPTION：不会检查当前视图的WHERE条件，即使数据不满足该条件，也能成功存入基表；但后续查询该视图时，这条不满足条件的数据不会在视图结果中显示

② 有 check option：会按LOCAL/CASCADED的规则检查对应范围的WHERE条件（当前视图 / 底层视图），不满足条件则插入 / 更新操作直接失败，数据既不会存入基表，自然也不会在视图中显示

更新及作用

视图的更新：

要使视图可更新，视图中的行与基础表中的行之间必须存在一对一的关系。如果视图包含以下任何一项，则该视图不可更新：

聚合函数或窗口函数(SUM()、MIN()、MAX()、COUNT()等
DISTINCT
GROUP BY
HAVINGA
UNION 或者 UNION ALL

作用：

**① 简单：**视图不仅可以简化用户对数据的理解，也可以简化他们的操作。那些被经常使用的查询可以被定义为视图，从而使得用户不必为以后的操作每次指定全部的条件。

**② 安全：**数据库可以授权，但不能授权到数据库特定行和特定的列上。通过视图用户只能查询和修改他们所能见到的数据。

**③ 数据独立：**视图可帮助用户屏蔽真实表结构变化带来的影响。

案例：

-- 1.为了保证数据库表的安全性，开发人员在操作tb_user表时，只能看到的用户的基本字段，屏蔽手机号和邮箱两个字段。
create view tb user view as select id,name,profession, age,gender,status,createtime from tb_user;
select *from tb user view;

-- 2.查询每个学生所选修的课程（三张表联查），这个功能在很多的业务中都有使用到，为了简化操作，定义一个视图。
create view tb_stu_course_view 
select s.name student_name, s.no student_no, c.name course_name 
from student s, stuent_course sc, course c 
where s.id = sc.studentid and sc.courseid = c.id;

-- 以后每次只需要进行查询视图即可
select * from tb_stu_course_view;

存储过程

介绍

(1) 存储过程是事先经过编译并存储在数据库中的一段 SQL语句的集合，调用存储过程可以简化应用开发人员的很多工作，减少数据在数据库和应用服务器之间的传输，对于提高数据处理的效率是有好处的。

(2) 存储过程思想上很简单，就是数据库 SOL语言层面的代码封装与重用。

特点：

封装，复用
可以接收参数，也可以返回数据
减少网络交互，效率提升

基本语法

创建：

CREATE PROCEDURE 存储过程名称([参数列表])
BEGIN
    -- 这里写要执行的SQL语句（比如查询、插入、更新等）
END;

调用：

1	CALL 名称([参数]);

查看：

-- 查询数据库的存储过程及状态信息
SELECT* FROM INFORMATION SCHEMA.ROUTINES WHERE ROUTINE_SCHEMA='xx';

-- 查询某个存储过程的定义
SHOW CREATE PROCEDURE 存储过程名称;

删除：

1	DROP PROCEDURE [IF EXISTS] 存储过程名称;

案例：

-- 存储过程基本语法
-- 创建
create procedure p1()
begin
  select count(*) from student;
end;

-- 调用
call p1();

-- 查看
select * from information_schema.ROUTINES where ROUTINE_SCHEMA = 'itcast';
show create procedure p1;

-- 删除
drop procedure if exists p1;

变量

系统变量

① 系统变量是 MySQL 服务器提供，不是用户定义的，属于服务器层面。分为全局变量(GLOBAL)、会话变量(SESSION)。

② 查看系统变量

-- 查看所有系统变量
SHOW [SESSION |GLOBAL] VARIABLES ; 

-- 可以通过LKE模糊匹配方式查找变量
SHOW[SESSION|GLOBAL] VARIABLES LIKE '......'; 

-- 查看指定变量的值
SELECT @@[SESSION|GLOBAL] 系统变量名;

③ 设置系统变量

-- 语法1：直接指定作用域（SESSION/全局）
SET [SESSION | GLOBAL] 系统变量名 = 值;

-- 语法2：用@@指定作用域（和语法1效果一致）
SET @@[SESSION | GLOBAL]系统变量名 = 值;

④ 案例：

-- 变量：系统变量
-- 查看系统变量
show session variables;
show session variables like 'auto%';
show glabal variables like 'auto%';
select @@global.autocommit;

-- 设置系统变量
set session autocommit = 0;
insert into course(id, name) values (5, 'Oracle');
set global auto commit = 0;

注意：

如果没有指定 session / global，默认 session，会话变量
mysql 服务器重启之后，所设置的全局参数会失效，要想不失效，需要更改/etc/my.cnf 中的配置。

用户定义变量

① 用户定义变量是用户根据需要自己定义的变量，用户变量不用提前声明，在用的时候直接用“@变量名”使用就可以。其作用域为当前连接。

② 赋值：

SET @var name = expr [, @var_name = expr]...;
SET @var name := expr [, @var_name := expr]...;

SELECT @var name := expr , @var name := expr ...;
SELECT 字段名 INTO @var_name FROM 表名;

③ 使用：

1	SELECT @var_name;

④ 案例：

-- 变量：用户变量
-- 赋值
set @myname = 'itcast';
set @myage := 10;

select @mycolor := 'red';
select count(*) into @mycount from tb_user;

-- 使用
select @myname, @myage, @mycolor, @mycount;

select @abc; -- 输出为NULL

注意：

用户定义的变量无需对其进行声明或者初始化，只不过获取到的值为 NULL。

局部变量

① 局部变量是根据需要定义的在局部生效的变量，访问之前，需要DECLARE声明。可用作存储过程内的局部变量和输入参数，局部变量的范围是在其内声明的BEGIN .. END块。

② 声明：

1	DECLARE 变量名变量类型 [DEFAULT..];

变量类型就是数据库字段类型:INT、BIGINT、CHAR、VARCHAR、DATE、TIME等。

③ 赋值：

SET 变量名=值;

SET 变量名:=值;

SELECT 字段名 INTO 变量名 FROM 表名 ...;

④ 案例：

-- 变量：局部变量
-- 声明 - declare
-- 赋值 -
create procedure p2()
begin
  declare stu_count int default 0;
  select count(*) into stu_count from student;
  select stu_count;
end;

call p2();

if 判断

语法：

IF 条件1 THEN
        ...
ELSEIF 条件2 THEN -- 可选
        ...
ELSE              -- 可选
        ...
END IF;

案例：

create procedure p3()
begin
  declare score int default 58;
  declare result varchar(10);
  if score >= 85 then
    set result :='优秀';
  elseif score >= 60 then
    set result :='及格';
  else
    set result :='不及格';
  end if;
  select result;
end;

参数（in, out, inout)

类型	含义	备注
IN	该类参数作为输入，也就是需要调用时传入值	默认
OUT	该类参数作为输出，也就是该参数可以作为返回值
INOUT	既可以作为输入参数，也可以作为输出参数****

用法：

CREATE PROCEDURE 存储过程名称([IN/OUT/INOUT 参数名 参数类型 ])
BEGIN
    -- SQL语句
END :

案例：

-- 根据传入(in)参数score，判定当前分数对应的分数等级，并返回(out)
-- score >= 85分，等级为优秀。
-- score >= 60分 且 score < 85分，等级为及格
-- score < 60分，等级为不及格。
create procedure p4(in score int, out result varchar(10))
begin
    if score >= 85 then
        set result := '优秀';
    elseif score >= 60 then
        set result := '及格';
    else
        set result := '不及格';
    end if;
end;

call p4(68,@result);
select @result;

-- 将传入的200分制的分数，进行换算，换算成百分制，然后返回分数 --> inout
create procedure p5(inout score double)
begin
  set score := score * 0.5;
end;

set @score = 198;
call p5(score);
select @score;

case

语法一：

CASE case value
  WHEN when_value1 THEN statement_list1
  [WHEN when_value2 THEN statement_list2]...
  [ELSE statement_list ]
END CASE;

语法二：

CASE
  WHEN search_conditionl THEN statement_list1
  WHEN search_condition2 THEN statement_list2]...
  [ELSE statement_list]
END CASE;

案例：

-- case
-- 根据传入的月份，判定月份所属的季节(要求采用case结构)
-- 1-3月份，为第一季度
-- 4-6月份，为第二季度
-- 7-9月份，为第三季度
-- 10-12月份，为第四季度

create procedure p6(in month int)
begin 
  declare result varchar(10);
  case 
    when month >= 1 and month <= 3 then
      set result := '第一季度';
    when month >= 4 and month <= 6 then
      set result := '第二季度';
    when month >= 7 and month <= 9 then
      set result := ' 第三季度';
    when month >= 10 and month <= 12 then
      set result := '第四季度';
    else
      set result := '非法参数';
  end case;

-- concat() 用于字符串的拼接
  select concat('你输入的月份为：', month, '，所属季度为：', result);
end;

循环

while

① while 循环是有条件的循环控制语句。满足条件后，再执行循环体中的SQL语句。

② 语法：

-- 先判定条件，如果条件为true，则执行逻辑，否则，不执行逻辑
WHILE 条件 DO
  SQL逻辑...
END WHILE;

③ 案例：

-- while计算从1累加到 n 的值，n 为传入的参数值。
-- A.定义局部变量，记录累加之后的值;
-- B.每循环一次，就会对 n 进行减1，如果 n 减到0，则退出循环

create procedure p7(in n int)
begin
  declare total int default 0;
  
  while n>0 do
    set total := total + n
    set n:=n-1;
  end while;
  
  select total;
end;
call p7(100);

repeat

① repeat是有条件的循环控制语句,当满足条件的时候退出循环。

② 语法：

-- 先执行一次逻辑，然后判定逻辑是否满足，如果满足，则退出。如果不满足，则继续下一次循环
REPEAT
  SQL逻辑.
  UNTIL 条件
END REPEAT;

③ 案例：

-- while计算从1累加到 n 的值，n 为传入的参数值。
-- A.定义局部变量，记录累加之后的值;
-- B.每循环一次，就会对 n 进行减1，如果 n 减到0，则退出循环

create procedure p8(innint)
begin
  declare total int default 0;
  
  repeat
    set total := total + n;
    set n := n - 1;
  until n <= 0
  end repeat;
  
  select total;
end;

call p8(10);
call p8(100);

④ 与 while 区别：

先进行循环一次再判断。相当于 c 语言中的 do while();
满足条件则退出

loop

① LOOP 实现简单的循环，如果不在SQL逻辑中增加退出循环的条件，可以用其来实现简单的死循环。LOOP可以配合一下两个语句使用。

LEAVE:配合循环使用，退出循环。
ITERATE:必须用在循环中，作用是跳过当前循环剩下的语句，直接进入下一次循环。

② 语法：

[begin label:] LOOP
  SQL逻辑..
END LOOP [end label];

-- 退出指定标记的循环体
LEAVE label; 
-- 直接进入下一次循环
ITERATE label;

③ 案例：

-- loop 计算从1到n之间的偶数累加的值，n为传入的参数值。
-- A.定义局部变量，记录累加之后的值;
-- B.每循环一次，就会劝进行-1，如果n减到0，则退出循环。------> leave xx
-- C.如果当次累加的数据是奇数，则直接进入下一次循坏。-------> iterate xx

create procedure p10(in n int)
begin 
  declare total int defatult 0;

  sum: loop
    if n <= 10 then
      leave sum;
    end if;

    if n%2 = 1 then
      set n := n - 1;
      iterate sum;
    end if;

    set total := total + n;
    set n := n - 1;
  end loop sum;

  select total;
end;

游标-cursor

介绍

游标(CURSOR)是用来存储查询结果集的数据类型,在存储过程和函数中可以使用游标对结果集进行循环的处理。游标的使用包括游标的声明、OPEN、FETCH和 CLOSE，其语法分别如下。

① 声明游标

1	DECLARE 游标名称 CURSOR FOR 查询语句;

② 打开游标：

1	OPEN 游标名称;

③ 获取游标记录：

1	FETCH 游标名称 INTO 变量[,变量];

④ 关闭游标：

1	CLOSE 游标名称;

案例：

-- 游标
-- 根据传入的参数uage，来查询用户表tb_user 中， 所有的用户年龄小于uage的用户姓名（name)和专业（profession），
-- 并将用户的姓名和专业插入到所创建的一张新表(id,name,profession)中。
-- 逻辑:
-- A.声明游标，存储查询结果集
-- B.准备:创建表结构
-- C.开启游标
-- D.获取游标中的记录
-- E.插入数据到新表中
-- F.关闭游标

create procedure p11(in uage int)
begin 
  declare uname varchar(100);
  declare upro varchar(100);
  declare u_cursor cursor for select name, profession from tb_user where age <= uage;

  drop table if exists tb_user_pro;
  create table if not exists tb_user_pro(
    id int primary key auto_increment,
    name varchar(100),
    profession varchar(100)
  );
  
  open u_cursor;
  while true do
    fetch u_cursor into uname,upro;
    insert into tb_user_pro values(null, uname, upro);
  end while;
  close u_cursor;
end;

条件处理程序-handler

① 条件处理程序(Handler)可以用来定义在流程控制结构执行过程中遇到问题时相应的处理步骤。

② 语法：

DECLARE handler action HANDLERFOR condition value l, condition value.... statement;
handler action
  CONTINUE: 继续执行当前程序
  EXIT: 终止执行当前程序
condition value
  SOLSTATE sqlstate_value:状态码，如 02000
  SQLWARNING:所有以01开头的SQLSTATE代码的简写
  NOT FOUND:所有以02开头的SOLSTATE代码的简写
  SOLEXCEPTION:所有没有被SOLWARNING 或 NOT FOUND捕获的SOLSTATE代码的简写

③ 案例：

create procedure p11(in uage int)
begin 
  declare uname varchar(100);
  declare upro varchar(100);
  declare u_cursor cursor for select name, profession from tb_user where age <= uage;
  
  -- 监控到02000的状态码后，关闭游标后执行exit退出操作。
  declare exit handler for not found close u_cursor; 

  drop table if exists tb_user_pro;
  create table if not exists tb_user_pro(
    id int primary key auto_increment,
    name varchar(100),
    profession varchar(100)
  );
  
  open u_cursor;
  while true do
    fetch u_cursor into uname,upro;
    insert into tb_user_pro values(null, uname, upro);
  end while;
  close u_cursor;
end;

存储函数：

1. 介绍：

存储函数是有返回值的存储过程，存储函数的参数只能是IN类型的。存储函数用的较少，能够使用存储函数的地方都可以用存储过程替换。

2. 语法：

CREATE FUNCTION 存储函数名称([ 参数列表 ])
RETURNS type [characteristic ...]
BEGIN
  -- SQL语句
  RETURN ...;
END ;
characteristic说明:
· DETERMINISTIC:相同的输入参数总是产生相同的结果
· NO SQL:不包含 SQL语句。
· READS SOL DATA:包含读取数据的语句，但不包含写入数据的语句,

3. 案例：

create function fun1(n int)
returns int deterministic
begin
    declare total int default 0;
     while n>0 do
        set total := total + n;
        set n:= n - 1;
     end while;

    return total;
end;

select fun1(100);

触发器

1. 介绍

(1) 触发器是与表有关的数据库对象，指在 insert/update/delete 之前或之后，触发并执行触发器中定义的SQL语句集合。触发器的这种特性可以协助应用在数据库端确保数据的完整性，日志记录，数据校验等操作。

(2) 使用别名 OLD 和 NEW 来引用触发器中发生变化的记录内容，这与其他的数据库是相似的。现在触发器还只支持行级触发，不支持语句级触发。

触发器类型	NEW 和 OLD
insert 型触发器	NEW 表示将要或者已经新增的数据
update 型触发器	OLD 表示修改之前的数据，NEW 表示将要或已经修改后的数据
delete 型触发器	OLD 表示将要或者已经删除的数据

2. 语法：

创建：

CREATE TRIGGER trigger name
BEFORE/AFTER INSERT/UPDATE/DELETE
ON tbl name FOR EACH ROW --行级触发器BEGIN
  trigger_stmt;
END;

查看：

1	SHOW TRIGGERS;

删除：

1	DROP TRIGGER [schema_name.]trigger_name; --如果没有指定 schema name，默认为当前数据库

案例：

-- 插入数据触发器
create trigger tb_user_insert_trigger
  after insert on tb_user for each row
  begin 
  insert into user_logs(id, operation, operate_time, operate_id, operate_params)values
  (null, 'insert', now(), new.id, concat('插入的数据内容为：id=', new.id, ',name=', new.name, ', phone=', new.phone, ', email=', new.email, ', profession=', new.profession));
end;

-- 查看
show triggers;

-- 删除
drop trigger tb_user_insert_trigger;

-- 插入数据tb_user
insert into tb_user(id, name, phtone, email, profession, age, gender, status, createtime) values(25, '二皇子', '1880901212', 'erhuangzi@163.com', '软件工程', 23, '1', '1'1, now());

-- 修改数据触发器
create trigger tb_user_update_trigger
  after update on tb_user for each row
  begin 
  insert into user_logs(id, operation, operate_time, operate_id, operate_params)values
  (null, 'update', now(), new.id, 
   concat('更新之前的数据：id=', old.id, ',name=', old.name, ', phone=', old.phone, ', email=', old.email, ', profession=', old.profession,
    '更新之后的数据：id=', new.id, ',name=', new.name, ', phone=', new.phone, ', email=', new.email, ', profession=', new.profession));
end;

update tb_user set age = 32 where id = 23;
update tb_user set age = 32 where id <= 5; -- 触发器为行级触发器，所以更改几行数据则触发几次，该语句触发5次

-- 删除数据触发器
create trigger tb_user_delete_trigger
  after delete on tb_user for each row
  begin 
  insert into user_logs(id, operation, operate_time, operate_id, operate_params)values
  (null, 'insert', now(), old.id, 
   concat('删除之前的数据：id=', new.id, ',name=', old.name, ', phone=', old.phone, ', email=', old.email, ', profession=', old.profession));
end;

delete from tb_user where id = 26;

锁

介绍

锁是计算机协调多个进程或线程并发访问某一资源的机制。在数据库中，除传统的计算资源(CPU、RAM、I/0)的争用以外，数据也是一种供许多用户共享的资源。如何保证数据并发访问的一致性、有效性是所有数据库必须解决的一个问题，锁冲突也是影响数据库并发访问性能的一个重要因素。从这个角度来说，锁对数据库而言显得尤其重要，也更加复杂。

全局锁

介绍

① 全局锁就是对整个数据库实例加锁，加锁后整个实例就处于只读状态，后续的DML的写语句，DDL语句，已经更新操作的事务提交语句都将被阻塞。

② 其典型的使用场景是做全库的逻辑备份，对所有的表进行锁定，从而获取一致性视图，保证数据的完整性。

演示图

基本操作

① 使用全局锁：

1	flush tables with read lock

② 释放全局锁：

1	unlock tables

特点：

数据库中加全局锁，是一个比较重的操作，存在以下问题:

如果在主库上备份，那么在备份期间都不能执行更新，业务基本上就得停摆
如果在从库上备份，那么在备份期间从库不能执行主库同步过来的二进制日志(binlog)，会导致主从延迟。（该结构会在后续主从复制讲解）

解决方法：

在InnoDB引擎中，我们可以在备份时加上参数 –single-transaction 参数来完成不加锁的一致性数据备份。

1	mysqldump --single-transaction -uroot -p123456 itcast > itcast.sql

注意：

这个方法只对 InnoDB 引擎有用（因为只有 InnoDB 支持事务）；如果是 MyISAM 引擎，备份还是会锁表（MyISAM 不支持事务，没法搞 “快照”）。

表级锁

介绍

每次操作锁住整张表。锁定粒度大，发生锁的冲突的概率最高，并发度最低。应用在MyISAM、InnoDB、BDB等存储引擎中。对于表级锁，主要分为一下三类：

表锁
元数据锁（meta data lock，MDL）
意向锁

表锁

① 对于表锁，分为两类：

表共享读锁（read lock）
表独占写锁（write lock）

读锁不会阻塞其他客户端的读，但是会阻塞写。写锁既会阻塞其他客户端的读，又会阻塞其他客户端的写。

② 语法：

#表级别的共享锁，也就是读锁；
#允许当前会话读取被锁定的表，但阻止当前会话和其他会话对这些表进行写操作。
lock tebles t_student read;

#表级锁的独占锁，也是写锁；
#允许当前会话对表进行读写操作，但阻止其他会话对这些表进行任何操作（读或写）。
lock tables t_stuent write;

#会话退出，也会释放所有锁
unlock tables

元数据锁

① MDL加锁过程是系统自动控制，无需显式使用，在访问一张表的时候会自动加上。MDL锁主要作用是维护表元数据的数据一致性，在表上有活动事务的时候，不可以对元数据进行写入操作。为了避免DML与DDL冲突，保证读写的正确性。

对一张表进行 CRUD（增删改查）操作时，加的是 MDL 读锁；
对一张表做结构变更操作的时候，加的是 MDL 写锁；

对应SQL	锁类型	说明
lock tables xxx read /write	SHARED_READ_ONLY/SHARED_NO_READ_WRITE
select 、 select … lock in share mode	SHARED_READ	与SHARED_READ、SHARED_WRITE兼容，与EXCLUSIVE互斥
insert 、update、delete、select …for update	SHARED_WRITE	与SHARED_READ、SHARED_WRITE兼容，与EXCLUSIVE互斥
alter table …	EXCLYSIVE	与其他的MDL都互斥

② 查看元数据锁

1	select object_type,object_schema,object_name,lock_type,lock_duration from performance_schema.metadata_locks;

意向锁

(1) 为什么需要意向锁？

若没有意向锁，加表锁时需要逐行检查表中所有记录是否有行锁（比如表有 10 万行，需检查 10 万次），效率极低。

(2) 核心类比

把数据库表比作「教室」，表中每一行比作「座位」：

行锁 = 占某个座位；
意向锁 = 教室门口贴的纸条（提示 “教室内已有座位被占用”）；
表锁 = 锁整个教室（要求教室内无任何占座）。

(3) 意向共享锁和意向独占锁是表级锁，不会和行级的共享锁和独占锁发生冲突，而且意向锁之间也不会发生冲突，只会和**共享表锁（lock tables … read)和独占表锁（lock tables … write）**发生冲突

① 意向共享锁（IS）：与表锁共享锁（read）兼容，与表锁排它锁（write）互斥。

② 意向排他锁（IX）：与表锁共享锁（read）及排它锁（write）都互斥。

(4) 加锁方式：

-- 意向共享锁：（先在表上加上意向共享锁，然后对读取的记录加共享锁）
select ... lock in share mode

-- 意向独占锁：（先表上加上意向独占锁，然后对读取的记录加独占锁）
insert、update、delete、select ... for update

-- 可以通过以下SQL，查看意向锁及行锁的枷锁情况
select object_schema,object_name,index_name,lock_type,lock_mode,lock_data from performance_schema.data_locks;

行级锁

行级锁，每次操作锁住对应的行数据。锁定粒度最小，发生锁冲突的概率最低，并发度最高。应用在InnoDB存储引擎中。

行锁(Record Lock):锁定单个行记录的锁，防止其他事务对此行进行update和delete。在RC、RR隔离级别下都支持。
间隙锁(GapLock):锁定索引记录间隙(不含该记录)，确保索引记录间隙不变，防止其他事务在这个间隙进行insert，产生幻读。在RR隔离级别下都支持。
临键锁(Next-Key Lock):行锁和间隙锁组合，同时锁住数据，并锁住数据前面的间隙Gap。在RR隔离级别下支持。

Record Lock（行锁）

Record Lock 称为记录锁，锁住的是一条记录。而且记录锁是有 S 锁和 X 锁之分。

(1) InnoDB实现了以下两种类型的行锁：

共享锁(S)：允许一个事务去读一行，阻止其他事务获得相同数据集的排它锁。
排他锁(X)：允许获取排他锁的事务更新数据，阻止其他事务获得相同数据集的共享锁和排他锁。

	S (共享锁)	X (排他锁)
S (共享锁)	兼容	冲突
X (排他锁)	冲突	冲突

(2) 行锁类型：

SQL	行锁类型	说明
insert，update，delete …	排他锁	自动加锁
select	不加任何锁
select … lock in share mode	共享锁	需要手动select之后加上lock in share mode
select … for update	排他锁	需要手动在select之后for update

(3) 默认情况下，InnoDB在 REPEATABLE READ事务隔离级别运行，InnoDB使用 next-key锁进行搜索和索引扫描，以防止幻读。

针对唯一索引进行检索时，对已存在的记录进行等值匹配时，将会自动优化为行锁。
InnoDB的行锁是针对于索引加的锁，不通过索引条件检索数据，那么!nnoDB将对表中的所有记录加锁，此时 就会升级为表锁。

(4) 查看意向锁及行锁的加锁情况：

1	select object_schema,object_name,index_name,lock_type,lock_mode,lock_data from performance_schema.data_locks;

Gap Lock（间隙锁）

(1) Gap Lock 称为间隙锁，只存在于可重复读隔离级别，目的是为了解决可重复读隔离级别下幻读的现象。

(2) 假设，表中有一个范围 id 为（3，5）间隙锁，那么其他事务就无法插入 id = 4 这条记录了，这样就有效的防止幻读现象的发生。

间隙锁虽然存在 X 型间隙锁和 S 型间隙锁，但是并没有什么区别，间隙锁之间是兼容的，即两个事务可以同时持有包含共同间隙范围的间隙锁，并不存在互斥关系，因为间隙锁的目的是防止插入幻影记录而提出的。

Next-Key Lock（临键锁）

(1) Next-Key Lock 称为临键锁，是 Record Lock + Gap Lock 的组合，锁定一个范围，并且锁定记录本身。

(2) 假设，表中有一个范围 id 为（3，5] 的 next-key lock，那么其他事务即不能插入 id = 4 记录，也不能修改 id = 5 这条记录。

(3) 所以，next-key lock 既能保护该记录，又能阻止其他事务将新纪录插入到被保护记录前面的间隙中。

结论

默认情况下，InnODB在 REPEATABLE READ事务隔离级别运行，InnoDB使用 next-key 锁进行搜索和索引扫描，以防止幻读。

索引上的等值查询(唯一索引)，给不存在的记录加锁时,优化为间隙锁。
索引上的等值查询(普通索引)，向右遍历时最后一个值不满足查询需求时，next-keylock退化为间隙锁。
索引上的范围查询(唯一索引)–会访问到不满足条件的第一个值为止。

InnoDB引擎

逻辑存储结构

(1) 表空间（对应 ibd 文件）

MySQL 实例级的存储容器，一个 MySQL 实例可以对应多个表空间，用于存储表的记录、索引等数据。

(2) 段（Segment）

① 是表空间的下一级结构，用于管理多个区；

② 分类：

数据段（Leaf node segment）：对应 B + 树的叶子节点
索引段（Non-leaf node segment）：对应 B + 树的非叶子节点；
回滚段（Rollback segment）：用于事务回滚相关的版本管理。

(3) 区（Extent）

表空间的单元结构，每个区的大小为 1MB，默认 InnoDB 页大小为 16KB，因此 1 个区包含 1MB ÷ 16KB = 64个连续的页。

(4) 页（Page）

① InnoDB 存储引擎**磁盘管理的最小单元，**每个页的大小默认 16KB；

② 为了保证页的物理连续性，InnoDB 存储引擎每次会从磁盘一次性申请 4-5 个区。

(5) 行

① InnoDB 的数据是按 “行” 为单位存放的；

② 行的隐藏列（事务相关）：

trx_id：事务 ID，每次修改记录时，会将对应事务的 ID 存入trx_id隐藏列；
roll_pointer（回滚指针）：修改记录时，会把数据的旧版本写入 undo 日志；回滚指针相当于 “指针”，可通过它找到记录修改前的信息。

整体架构

内存架构

(1) Buffer Pool：

① 缓冲池是内存中的一个区域，它可以缓存磁盘上经常操作的真实数据，在执行增删改查操作时，先操作缓冲中的数据（若缓冲池没有数据，则从磁盘加载并缓存），然后以一定频率刷新到磁盘，从而减少磁盘 IO，加快处理速度。

② 缓冲池以 Page 为单位，采用链表数据结构管理 Page。根据状态，将 Page 分为三种类型：

free page：空的 page，未被使用。
clean page：被使用 page，数据没有被修改过。
dirty page：脏页，被使用 page，数据被修改过，也就是缓冲与磁盘的数据产生了不一致。

(2) Change Buffer：

① 更改缓存（针对于非唯一二级索引使用），在执行 DML 语句时，如果该数据 Page 没有在 Buffer Pool 里，不会直接把磁盘进行操作，而会将变更暂存在更改缓存区 Change Buffer 中，在未来数据被读取时，再将数据合并并更新到 Buffer Pool，再将合并后的数据刷新到磁盘中。

② 与主键索引不同，二级索引通常是非唯一的，并且以相对随机的顺序插入二级索引，同样，删除和更新可能会影响索引中不相邻的二级索引页，如果每一次都操作磁盘，会造成大量的随机 IO，有了 ChangeBuffer 之后，我们可以在缓存池中进行合并处理，减少磁盘 IO。

(3) Adaptive Hash Index：

① 自适应 hash 索引，用于优化对 Buffer Pool 数据的查询。InnoDB 存储引擎会监控对表上各索引页的查询，如果观察到 hash 索引可以提升速度，则建立 hash 索引，称之为自适应 hash 索引。

② 自适应哈希索引，无需人工干预，是系统根据情况自动完成。

(4) Log Buffer：

① 日志缓冲区，用来保存要写入到磁盘中的 log 日志数据（redo log、undo log）。默认大小为 16MB，日志缓冲区的日志会定期刷新到磁盘中。如果需要更新、插入或删除许多行的事务，增加日志缓冲区的大小可以节省磁盘 I/O。

② 参数：

Innodb_log_buffer_size：缓冲区大小
innodb_flush_log_at_trx_commit：日志刷新到磁盘时机

1: 日志在每次事务提交时写入并刷新到磁盘

0: 每秒将日志写入并刷新到磁盘一次

2: 日志在每次事务提交后写入，并每秒刷新到磁盘一次

磁盘结构

(1) System Tablespace：

① 是更改缓冲区的存储区域；若表创建在该空间（而非单表 / 通用表空间），还会包含表、索引数据。(在 MySQL5.x 版本中还包含 InnoDB 数据字典、undolog 等)

② 参数：innodb_data_file_path

(2) File-Per-Table Tablespaces：

① 每个表的文件表空间包含单个 InnoDB 表的数据和索引，并存储在文件系统上的单个数据文件中。

② 参数：innodb_file_per_table

(3) General Tablespaces：通用表空间

① 创建通用表空间：

1	CREATE TABLESPACE xxx ADD DATAFILE 'file_name' ENGINE = engine_name;

② 对应表创建语句：

1	CREATE TABLE xxx ... TABLESPACE ts_name;

(4) Undo Tablespaces：

撤销表空间，MySQL 在实例初始化时会自动创建两个默认的 undo 表空间（初始大小 16MB），用于存储 undo log 日志。

(5) Temporary Tablespaces：

InnoDB 使用设备临时表空间和全局临时表空间，存储用户创建的临时表等数据。

(6) Doublewrite Buffer Files：

① 双写缓冲，InnoDB 引擎将数据页从 Buffer Pool 刷新到磁盘前，先将数据页写入双写缓冲文件中，便于系统异常时恢复数据。

② 示例文件：

#ib_16384.0.dblwr
#ib_16384.1.dblwr

(7) Redo Log：

① 重做日志，是用来实现事务的持久性。该日志文件由两部分组成：重做日志缓冲（redo log buffer）以及重做日志文件（redo log）。前者是在内存中，后者在磁盘中。当事务提交之后会把所有修改信息都存到该日志中，用于在数据页写到磁盘时发生错误时，进行数据恢复使用。

② 以循环方式写入重做日志文件，涉及两个文件：

ib_logfile0
ib_logfile1

后台线程

事务原理

(1) 事务：一组操作的集合，它是一个不可分割的工作单位，事务会把所有的操作作为一个整体一起向系统提交或撤销操作请求，即这些操作要么同时成功，要么同时失败。

(2) 特征：

原子性(Atomicity)：事务是不可分割的最小操作单元，要么全部成功，要么全部失败。
一致性(Consistency) ：事务完成时，必须使所有的数据都保持一致状态。
隔离性(lsolation)：数据库系统提供的隔离机制，保证事务在不受外部并发操作影响的独立环境下运行。
持久性(Durability)：事务一旦提交或回滚，它对数据库中的数据的改变就是永久的。

(3) 特性原理分类图：

redo log

(1) 重做日志，记录的是事务提交时数据页的物理修改，是用来实现事务的持久性。

(2) 该日志文件由两部分组成:重做日志缓冲(redo log buffer)以及重做日志文件(redo log file),前者是在内存中，后者在磁盘中。当事务提交之后会把所有修改信息都存到该日志文件中,用于在刷新脏页到磁盘,发生错误时,进行数据恢复使用。

(3) Buffer Pool在产生脏页数据的时候，会先将数据存储到 redo log buffer 再存储到 redo log 中进行磁盘持久化存储，在内存出现异常（比如突然断电）时，通过redo log中持久化的数据进行回滚。过程如下图：

(4) redo log 分为 2 部分：

内存里的「redo log 缓冲」：临时存一下修改记录（相当于 “草稿纸”）；
磁盘里的「redo log 文件」：长期存修改记录（相当于 “正式笔记本”）。

(5) 工作流程像这样：

比如你修改了一条数据 → 先把 “我改了啥、怎么改的” 记到「redo log 缓冲」里 → 事务提交时，把缓冲里的记录写到「redo log 文件」里 → 之后数据库再慢慢把修改好的数据（存在内存缓存里的 “脏数据”）刷到磁盘。

要是中途突然断电：重启后，数据库会看「redo log 文件」里的记录，把没来得及刷到磁盘的修改，重新恢复出来。

Q：redo log 要写到磁盘，数据也要写磁盘，为什么要多此一举?

A：redo log 是 ”顺序写“，**磁盘处理起来特别快；**而直接写数据是 ”随机写“，得先找到数据在磁盘里的位置，再修改，速度很慢。

undo log

(1) 回滚日志，用于记录数据被修改前的信息，作用包含两个：提供回滚和 MVCC(多版本并发控制)。

(2) undo log 和 redo log 记录物理日志不一样，它是逻辑日志。可以认为当 delete 一条记录时，undo log中会记录一条对应的insert记录，反之亦然，当 update 一条记录时，它记录一条对应相反的 update 记录。当执行 rollback 时，就可以从 undo log 中的逻辑记录读取到相应的内容并进行回滚。

(3) Undo log 销毁：undo log 在事务执行时产生，事务提交时，并不会立即删除undol0g，因为这些日志可能还用于 MVCC。

(4) Undo log 存储：undo log 采用段的方式进行管理和记录，存放在前面介绍的 rollback segment 回滚段中，内部包含1024个 undo log segment.

MVCC

当前读：

读取的是记录的最新版本，读取时还要保证其他并发事务不能修改当前记录，会对读取的记录进行加锁。对于我们日常的操作，如：select…lock in share mode(共享锁)，select… for update、update、insert、delete(排他锁)都是一种当前读。

快照读：

简单的select(不加锁)就是快照读，快照读，读取的是记录数据的可见版本，有可能是历史数据，不加锁，是非阻塞读。

Read committed:每次select，都生成一个快照读。
Repeatable Read:开启事务后第一个select语句才是快照读的地方。
Serializable:快照读会退化为当前读。

MVCC：

全称 Multi-Version Concurrency Control，多版本并发控制。指维护一个数据的多个版本，使得读写操作没有冲突，快照读为 MVSQL 实现MVCC提供了一个非阻塞读功能。MVCC的具体实现，还需要依赖于数据库记录中的三个隐式字段、undo log日志、read View。

三个隐藏字段

undo log

(1) 回滚日志，在insert、update、delete的时候产生的便于数据回滚的日志。

(2) 当insert的时候，产生的undolog日志只在回滚时需要，在事务提交后，可被立即删除。

(3) 而update、delete的时候，产生的undo log日志不仅在回滚时需要，在快照读时也需要，不会立即被删除。

(4) 那么何时删除？

① 事务提交后：

对于INSERT操作，事务提交后，undo log可以被立即删除，因为不再需要用于回滚。例如：你新增了一条 “订单记录”，事务提交后，既不需要回滚（回滚是删这条记录，但提交了就不用回滚了），也不会有其他事务需要读这条记录的 “旧版本”（因为它是刚新增的，没有更早的版本），所以 undo log 没用了，直接删。

**Q：**为什么说没有旧版本？旧版本不是没有插入之前的吗？

**A：**这里的旧版本指的是 **“这条新插入记录本身的旧版本” ，**不是 ”表在插入前的状态“，可以理解成行锁和表锁的关系。

对于UPDATE和DELETE操作，undo log不会立即被删除，因为它们可能在后续的快照读取中被使用。例如：你把 “订单金额从 100 改成 200”，事务提交后，可能有其他事务需要看 “金额 100” 这个旧版本（比如查 5 分钟前的订单状态），这时候得靠 undo log 调出旧数据，所以它还能用，得留着。

② 快照读取结束：

当所有依赖于该undo log的快照读取操作结束后，undo log才会被删除。这意味着如果有一个事务正在进行快照读取，并且依赖于某个undo log，那么这个undo log会一直保留直到该事务结束。

(5) undo log 版本链

readview

(1) ReadView(读视图)是快照读 SOL执行时MVCC提取数据的依据，记录并维护系统当前活跃的事务(未提交的)id。

(2) ReadView中包含了四个核心字段:

字段	含义
m_ids	当前活跃的事务ID集合
min_trx_id	最小活跃事务ID
max_trx_id	预分配事务ID，当前最大事务ID+1（因为事务ID是自增的）
creator_trx_id	ReadView创建者的事务ID（即 “当前要读数据的那个事务” 的 ID）

(3) 版本链数据访问规则

① 规则 1：（trx_id = creator_trx_id → 能访问）：

这里的creator_trx_id就是表格里的 “ReadView 创建者的事务 ID”—— 如果某数据版本的修改者 ID，和 “当前读数据的事务 ID” 一致，说明是自己改的，能访问。

② 规则 2：（trx_id < min_trx_id → 能访问）：

min_trx_id是 “最小活跃事务 ID”—— 如果某数据版本的修改者 ID，比 “当前最小编号的活跃事务” 还小，说明这个修改事务早于所有活跃事务完成提交，能访问。

③ 规则 3：（trx_id > max_trx_id → 不能访问）：

max_trx_id是 “预分配事务 ID（当前最大 ID+1）”—— 如果某数据版本的修改者 ID，比这个预分配 ID 还大，说明这个修改事务是在 ReadView 创建之后才启动的（事务 ID 自增），还没完成，不能访问。

④ 规则 4：（min_trx_id ≤ trx_id ≤ max_trx_id 且 trx_id 不在 m_ids 里 → 能访问）：

min_trx_id/max_trx_id限定了 “当前活跃事务的 ID 范围”；
m_ids是 “当前活跃的事务 ID 集合”—— 如果某数据版本的修改者 ID 在这个范围内，但不在活跃集合里，说明这个修改事务已经提交了（从活跃状态变成已完成），能访问。

(4) 原理分析（RC 级别）

之所以事务3，事务4都是活跃事务，是因为这个表格执行顺序是从上至下的，在事务5 第一次查询 id 为 30 的记录时，事务3 和事务4 都没有结束。在事务5 第二次查询 id 为 30 的记录时，事务3 已经结束了

(5) 原理分析（RR 级别）

MySQL 管理

系统数据库介绍

Mysql数据库安装完成后，自带了一下四个数据库，具体作用如下：

数据库	含义
mysql	存储MySQL服务器正常运行所需要的各种信息(时区、主从、用户、权限等)
information_schema	提供了访问数据库元数据的各种表和视图，包含数据库、表、字段类型及访问权限等
performance_schema	为MySQL服务器运行时状态提供了一个底层监控功能，主要用于收集数据库服务器性能参数
sys	包含了一系列方便 DBA和开发人员利用 performance_schema性能数据库进行性能调优和诊断的视图

常用工具

(1) mysql

(2) mysqladmin

(3) mysqlbinlog

(4) mysqlshow

(5) mysqldump

(6) mysqlimport / source

MySQL学习笔记之基础篇

2026-03-28T02:00:00.000Z

MySQL基础篇

DDL（数据定义语言）

作用：

用来定义数据库对象（数据库、表、字段）

数据库操作

① 查询所有数据库

1	SHOW DATABASES;

② 查询当前数据库：

1	SELECT DATABASE();

③ 创建数据库：

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

④ 删除数据库：

1	DROP DATABASE [ IF EXISTS ] 数据库名;

⑤ 使用数据库：

USE 数据库名;

注意：UTF8字符集长度为3字节，有些符号占4字节，所以推荐用utf8mb4字符集

表操作

(1) 查询当前数据库所有表：

1	SHOW TABLES;

(2) 查询表结构：

DESC 表名;

(3) 查询指定表的建表语句：

1	SHOW CREATE TABLE 表名;

(4) 创建表：

CREATE TABLE 表名(
字段1 字段1类型 [COMMENT 字段1注释],
字段2 字段2类型 [COMMENT 字段2注释],
字段3 字段3类型 [COMMENT 字段3注释],
...
字段n 字段n类型 [COMMENT 字段n注释]
)[ COMMENT 表注释 ];

注意：最后一个字段后面没有逗号

(5) 添加字段：

1	ALTER TABLE 表名 ADD 字段名类型(长度) [COMMENT 注释] [约束];

例：ALTER TABLE emp ADD nickname varchar(20) COMMENT '昵称';

(6) 修改数据类型：

1	ALTER TABLE 表名 MODIFY 字段名新数据类型(长度);

(7) 修改字段名和字段类型：

1	ALTER TABLE 表名 CHANGE 旧字段名新字段名类型(长度) [COMMENT 注释] [约束];

例：将emp表的nickname字段修改为username，类型为varchar(30)
ALTER TABLE emp CHANGE nickname username varchar(30) COMMENT '昵称';

(8) 删除字段：

1	ALTER TABLE 表名 DROP 字段名;

(9) 修改表名：

1	ALTER TABLE 表名 RENAME TO 新表名

(10) 删除表：

1	DROP TABLE [IF EXISTS] 表名;

数据类型

用于存储数字，分整数、浮点、定点数：

整数类型（按范围从小到大）

类型	大小	有符号范围	无符号范围	说明
TINYINT	1byte	(-128, 127)	(0, 255)	小整数
SMALLINT	2bytes	(-32768, 32767)	(0, 65535)	中整数
MEDIUMINT	3bytes	(-8388608, 8388607)	(0, 16777215)	大整数
INT/INTEGER	4bytes	(-2147483648, 2147483647)	(0, 4294967295)	常用大整数
BIGINT	8bytes	(-2^63, 2^63-1)	(0, 2^64-1)	极大整数

✅ 备注：无符号整数写法（如无符号 int）：INT UNSIGNED

浮点 / 定点数

类型	大小	说明
FLOAT	4bytes	单精度浮点（范围约 ±3.4E+38）
DOUBLE	8bytes	双精度浮点（范围约 ±1.8E+308）
DECIMAL	依赖 M/D	精确定点数（适合金额等场景）

✅ 备注：double 可指定 “总长 + 小数位”，格式：double(总长, 小数位)（如double(4,1)）

字符类型

用于存储字符串 / 二进制数据，分定长、变长、二进制、文本：

类型	大小范围	描述
CHAR	0-255bytes	定长字符串（性能高）
VARCHAR	0-65535bytes	变长字符串（性能略低）
TINYBLOB	0-255bytes	小二进制数据（≤255 字符）
TINYTEXT	0-255bytes	短文本字符串
BLOB	0-65535bytes	长二进制数据
TEXT	0-65535bytes	长文本数据
MEDIUMBLOB	0-16777215bytes	中等长二进制数据
MEDIUMTEXT	0-16777215bytes	中等长文本数据
LONGBLOB	0-4294967295bytes	极大二进制数据
LONGTEXT	0-4294967295bytes	极大文本数据

✅ 性能提示：同长度下，char(n)（如char(10)）性能优于varchar(n)（定长存储更高效）

日期时间类型

用于存储日期、时间相关数据：

类型	大小	范围	格式	描述
DATE	3bytes	1000-01-01 ~ 9999-12-31	YYYY-MM-DD	纯日期值
TIME	3bytes	-838:59:59 ~ 838:59:59	HH:MM:SS	时间间隔 / 持续时间
YEAR	1byte	1901 ~ 2155	YYYY	纯年份值
DATETIME	8bytes	1000-01-01 00:00:00 ~ 9999-12-31 23:59:59	YYYY-MM-DD HH:MM:SS	混合日期 + 时间
TIMESTAMP	4bytes	1970-01-01 00:00:01 ~ 2038-01-19 03:14:07	YYYY-MM-DD HH:MM:SS	带时间戳特性的日期时间

DML（数据操作语言）

添加数据

(1) 指定字段：

1	INSERT INTO 表名 (字段名1, 字段名2, ...) VALUES (值1, 值2, ...);

(2) 全部字段：

1	INSERT INTO 表名 VALUES (值1, 值2, ...);

(3) 批量添加数据：

1 2	INSERT INTO 表名 (字段名1, 字段名2, ...) VALUES (值1, 值2, ...), (值1, 值2, ...), (值1, 值2, ...); INSERT INTO 表名 VALUES (值1, 值2, ...), (值1, 值2, ...), (值1, 值2, ...);

注意：

字符串和日期类型数据应该包含在引号中
插入的数据大小应该在字段的规定范围内

更新和删除数据

(1) 修改数据：

1
2
3

UPDATE 表名 SET 字段名1 = 值1, 字段名2 = 值2, ... [ WHERE 条件 ];
例：
UPDATE emp SET name = 'Jack' WHERE id = 1;

(2) 删除数据：

1	DELETE FROM 表名 [ WHERE 条件 ];

DQL（数据查询语言）

语法：

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

基础查询

(1) 查询多个字段：

1 2	SELECT 字段1, 字段2, 字段3, ... FROM 表名; SELECT * FROM 表名;

(2) 设置别名：

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

(3) 去除重复记录：

1	SELECT DISTINCT 字段列表 FROM 表名;

条件查询

(1) 语法：

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

(2) 条件：

比较运算符	功能
>	大于
>=	大于等于
<	小于
<=	小于等于
=	等于
<> 或 !=	不等于
BETWEEN … AND …	在某个范围内（含最小、最大值）
IN(…)	在in之后的列表中的值，多选一
LIKE 占位符	模糊匹配（_匹配单个字符，%匹配任意个字符）
IS NULL	是NULL

逻辑运算符	功能
AND 或 &&	并且（多个条件同时成立）
OR 或 \|\|	或者（多个条件任意一个成立）
NOT 或 !	非，不是

(3) 例子：

-- 1. 查询年龄等于 88 的员工
select * from emp where age = 88;

-- 2. 查询年龄小于 20 的员工
select * from emp where age < 20;

-- 3. 查询没有身份证号的员工信息
select * from emp where idCard is null;

-- 4. 查询所有身份证号的员工信息
select * from emp where idCard is not null;

-- 5. 查询年龄不等于 88 的员工信息
select * from emp where age != 88;

-- 6. 查询年龄在15岁（包含）到20岁（包含）之间的员工信息
select * from emp where age >= 15 and age <= 20;
select * from emp where age between 15 and 20;

-- 7. 查询性别为 女 且年龄小于 25 岁的员工信息
select * from emp where gender = '女' and age < 25

-- 8. 查询年龄等于 18 或 20 或 40 的员工信息
select * from emp where age in(18,20,40);

-- 9. 查询姓名为两个字的员工信息
select * from emp where name like '__';

-- 10. 查询身份证号最后一位是X的员工信息
select * from emp where idCard like '%X';

注意：MySQL 中查询 idCard 为 NULL 的员工时，不能用 idCard = null 或 idCard == null，在 MySQL 中，NULL表示「未知值」，不是一个具体的数值 / 字符串，因此普通的比较运算符（=、==、!=、<>）无法和 NULL 进行有效比较—— 用这些运算符和 NULL 比较的结果既不是TRUE也不是FALSE，而是NULL（不成立），最终查不到任何数据。

聚合查询（聚合函数）

(1) 常见聚合函数：

函数	功能
count	统计数量
max	最大值
min	最小值
avg	平均值
sum	求和

(2) 语法：

1	SELECT 聚合函数(字段列表) FROM 表名;

(3) 代码示例：

-- 1.统计该企业员工数量
select count(*) from emp;
select count(id) from emp;

-- 2.统计该企业员工的平均年龄
select avg(age) from emp;

-- 3.统计该企业员工的最大年龄
select max(age) from emp;

-- 4.统计西安地区员工的年龄之和
select sum(age) from emp where workaddress = '西安';

注意：null 值不参与所有聚合函数运算

关键逻辑：count(\*)

统计所有符合条件的行数（不管字段是否为 NULL），只要这一行存在，就会被计数，适合直接统计 “员工总数”。

分组查询

(1) 语法：

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

(2) where 和 having 的区别：

执行时机不同：where是分组之前进行过滤，不满足where条件不参与分组；having是分组后对结果进行过滤。
判断条件不同：where不能对聚合函数进行判断，而having可以。

(3) 代码示例：

-- 1.根据性别分组，统计男性员工和女性员工的数量
select gender,count(*) from emp group by gender;

-- 2.根据性别分组，统计男性员工和女性员工的平均年龄
select gender,avg(age) from emp group by gender;

-- 3.查询年龄小于45的员工，并根据工作地址分组，获取员工数量大于等于3的工作地址
select workaddress,count(*) from emp where age < 45 group by workaddress having count(*) >= 3;

关键逻辑：

① HAVING COUNT(*) >= 3

分组后的筛选：只保留 “统计人数 ≥ 3” 的分组 —— 比如西安分组只有 2 人，就会被筛掉；北京有 6 人、上海 4 人、江苏 3 人，都会保留。

→ 记住：HAVING只管 “分组后的统计结果”（比如 COUNT (*)），不管 “单个员工的字段”。

② SELECT workaddress,count(*)

最终展示：把筛选后的分组结果展示出来，列是 “工作地址” 和 “对应人数”。

(4) 注意事项

执行顺序：where > 聚合函数 > having，因为 WHERE先筛行→GROUP BY分组→聚合函数统计→HAVING筛组
分组之后，查询的字段一般为聚合函数和分组字段，查询其他字段无任何意义（上述例子中，workaddress 是分组标识，count(*) 是聚合函数）

排序查询

(1) 语法：

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

(2) 排序方式：

ASC: 升序（默认）
DESC: 降序

(3) 代码示例：

-- 1.根据年龄对公司的员工进行升序排序
select * from emp order by age asc;
select * from emp order by age;

-- 2.根据年龄对公司的员工进行升序排序，年龄相同，再按照入职时间进行降序排序
select * from emp order by age asc, entrydate desc;

(4) 注意：如果是多字段排序，当第一个字段值相同时，才会根据第二个字段进行排序

分页查询

(1) 语法：

1	SELECT 字段列表 FROM 表名 LIMIT 起始索引, 查询记录数;

(2) 注意：

起始索引从0开始，起始索引 = （查询页码 - 1） * 每页显示记录数
分页查询是数据库的方言，不同数据库有不同实现，MySQL是LIMIT
如果查询的是第一页数据，起始索引可以省略，直接简写 LIMIT 10

(3) 代码示例：

-- 1.查询第1页员工数据，每页展示10条记录
select * from emp limit 0,10;
select * from emp limit 10;

-- 2.查询第2条
select * from emp limit 10,10;

综合练习

-- 1.查询年龄为20，21，22，23岁的女性员工信息
select * from emp where gender = '女' and age in (20,21,22,23);

-- 2.统计员工表中，年龄小于60岁的，男性员工和女性员工的人数
select gender, count(*) from emp where age < 60 group by gender

-- 3.查询所有年龄小于等于35岁员工的姓名和年龄，并对查询结果按年龄升序排序，如果年龄相同按入职时间降序排序
select name,age from emp where age <= 35 order by age asc, entrydate desc;

-- 4.查询性别为男，且年龄在20-40岁（含）以内的前5个员工信息，对查询的结果按年龄升序排序，年龄相同按入职时间升序时间
select * from emp where gender = '男' and age between 20 and 40 order by age asc, entrydate desc limit 5;

DQL 编写顺序

1	1. FROM → 2. WHERE → 3. GROUP BY → 4. HAVING → 5. ORDER BY → 6. LIMIT

DQL执行顺序

FROM -> WHERE -> GROUP BY、HAVING -> SELECT -> ORDER BY -> LIMIT

DCL

管理用户

(1) 查询用户：

1 2	USE mysql; SELECT * FROM user;

(2) 创建用户:

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

(3) 修改用户密码：

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

(4) 删除用户：

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

(5) 代码示例：

-- 创建用户test，只能在当前主机localhost访问
create user 'test'@'localhost' identified by '123456';
-- 创建用户test，能在任意主机访问
create user 'test'@'%' identified by '123456';
create user 'test' identified by '123456';
-- 修改密码
alter user 'test'@'localhost' identified with mysql_native_password by '1234';
-- 删除用户
drop user 'test'@'localhost';

权限控制

(1) 常用权限：

权限	说明
ALL, ALL PRIVILEGES	所有权限
SELECT	查询数据
INSERT	插入数据
UPDATE	修改数据
DELETE	删除数据
ALTER	修改表
DROP	删除数据库/表/视图
CREATE	创建数据库/表

(2) 查询权限：

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

(3) 授予权限：

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

(4) 撤销权限：

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

(5) 注意事项

多个权限用逗号分隔
授权时，数据库名和表名可以用 * 进行通配，代表所有

实用技巧

DataGrip 快速执行单行 SQL 的方法

使用 Ctrl+Enter（Windows/Linux），无需选中整行，只需将光标定位在目标行，按下此快捷键，DataGrip 会自动执行该行完整 SQL 语句。

换行技巧（无需移到行尾）

Windows/Linux：Shift + Enter

单行注释（最常用）

用 --（两个减号）开头，后面跟注释内容，注释范围从--到行尾。

1
2
3

-- 这是单行注释（整行注释）
SELECT * FROM employee; -- 这是行尾注释（注释该行后面的内容）
-- INSERT INTO employee (id, name) VALUES (2, '李四'); -- 注释掉整行执行语句

函数

字符串函数
数值函数
日期函数
流程函数

字符串函数

(1) 常用函数：

函数	功能
CONCAT(s1, s2, …, sn)	字符串拼接，将s1, s2, …, sn拼接成一个字符串
LOWER(str)	将字符串全部转为小写
UPPER(str)	将字符串全部转为大写
LPAD(str, n, pad)	左填充，用字符串pad对str的左边进行填充，达到n个字符串长度
RPAD(str, n, pad)	右填充，用字符串pad对str的右边进行填充，达到n个字符串长度
TRIM(str)	去掉字符串头部和尾部的空格
SUBSTRING(str, start, len)	返回从字符串str从start位置起的len个长度的字符串
REPLACE(column, source, replace)	替换字符串

(2) 使用示例：

select concat('Hello','MySQL');

select lower('Hello');

select upper('Hello');

select lpad('01',5,'-');

select rpad('01',5,'-');

select trim(' Hello MySQL ');

select substring('Hello MySQL',1,5);

数值函数

(1) 常见函数：

函数	功能
CEIL(x)	向上取整
FLOOR(x)	向下取整
MOD(x, y)	返回x/y的模
RAND()	返回0~1内的随机数
ROUND(x, y)	求参数x的四舍五入值，保留y位小数

(2) 代码示例：

select ceil(1.5);
select ceil(1.1);

select floor (1.9);

select mod(3,4);

select rand();

select round(2.345,2);

-- 案例：通过数据库的函数，生成一个六位数的随机验证码
select lpad(round(rand() * 1000000,0),6,'0');

日期函数

(1) 常用函数：

函数	功能
CURDATE()	返回当前日期
CURTIME()	返回当前时间
NOW()	返回当前日期和时间
YEAR(date)	获取指定date的年份
MONTH(date)	获取指定date的月份
DAY(date)	获取指定date的日期
DATE_ADD(date, INTERVAL expr type)	返回一个日期/时间值加上一个时间间隔expr后的时间值
DATEDIFF(date1, date2)	返回起始时间date1和结束时间date2之间的天数

(2) 代码示例：

select curdate();

select curtime();

select now();

select YEAR(now());

select MONTH(now());

select DAY(now());

select date_add(now(),INTERVAL 70 DAY);

select datediff('2021-12-21','2021-12-02');

-- 案例：查询所有员工的入职天数，并根据入职天数倒序排序
select name, datediff(curdate(), entrydate) as 'entrydays' from emp order by entrydays desc;

流程函数

(1) 常用函数：

函数	功能
IF(value, t, f)	如果value为true，则返回t，否则返回f
IFNULL(value1, value2)	如果value1不为空，返回value1，否则返回value2
CASE WHEN [ val1 ] THEN [ res1 ] … ELSE [ default ] END	如果val1为true，返回res1，… 否则返回default默认值
CASE [ expr ] WHEN [ val1 ] THEN [ res1 ] … ELSE [ default ] END	如果expr的值等于val1，返回res1，… 否则返回default默认值

(2) 代码示例：

select if(true,'OK','Error');

select ifnull('OK','Default');
select ifnull(null,'Default');
select ifnull('','Default');

select
    id,
    name,
    (case when math >= 85 then '优秀' when math >= 60 then '及格' else '不及格' end) as '数学',
    (case english when english >= 85 then '优秀' when english >= 60 then '及格' else '不及格' end) as '英语',
    (case chinese when chinese >=85 then '优秀' when chinese >= 60 then '及格' else '不及格' end) as '语文'
from score;

约束

分类：

约束	描述	关键字
非空约束	限制该字段的数据不能为null	NOT NULL
唯一约束	保证该字段的所有数据都是唯一、不重复的	UNIQUE
主键约束	主键是一行数据的唯一标识，要求非空且唯一	PRIMARY KEY
默认约束	保存数据时，如果未指定该字段的值，则采用默认值	DEFAULT
检查约束（8.0.1版本后）	保证字段值满足某一个条件	CHECK
外键约束	用来让两张图的数据之间建立连接，保证数据的一致性和完整性	FOREIGN KEY

约束是作用于表中字段上的，可以再创建表/修改表的时候添加约束。

常用约束

约束条件	关键字
主键	PRIMARY KEY
自动增长	AUTO_INCREMENT
不为空	NOT NULL
唯一	UNIQUE
逻辑条件	CHECK
默认值	DEFAULT

代码示例：

create table user(
id int primary key auto_increment,
name varchar(10) not null unique,
age int check(age > 0 and age < 120),
status char(1) default '1',
gender char(1)
);

外键约束

(1) 添加外键

方法一：

CREATE TABLE 表名(
字段名 字段类型,
...
[CONSTRAINT] [外键名称] FOREIGN KEY(外键字段名) REFERENCES 主表(主表列名)
);

方法二：

ALTER TABLE 表名 ADD CONSTRAINT 外键名称 FOREIGN KEY (外键字段名) REFERENCES 主表(主表列名);

-- 例子
alter table emp add constraint fk_emp_dept_id foreign key(dept_id) references dept(id);

(2) 删除外键：

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

(2) 删除/更新行为

行为	说明
NO ACTION	当在父表中删除/更新对应记录时，首先检查该记录是否有对应外键，如果有则不允许删除/更新（与RESTRICT一致）
RESTRICT	当在父表中删除/更新对应记录时，首先检查该记录是否有对应外键，如果有则不允许删除/更新（与NO ACTION一致）
CASCADE	当在父表中删除/更新对应记录时，首先检查该记录是否有对应外键，如果有则也删除/更新外键在子表中的记录
SET NULL	当在父表中删除/更新对应记录时，首先检查该记录是否有对应外键，如果有则设置子表中该外键值为null（要求该外键允许为null）
SET DEFAULT（不重要）	父表有变更时，子表将外键设为一个默认值（Innodb不支持）

(3) 更改删除/更新行为：

1	ALTER TABLE 表名 ADD CONSTRAINT 外键名称 FOREIGN KEY (外键字段) REFERENCES 主表名(主表字段名) ON UPDATE 行为 ON DELETE 行为;

多表查询

多表关系

一对多（多对一）
多对多
一对一

(1) 一对多

案例：部门与员工
关系：一个部门对应多个员工，一个员工对应一个部门
实现：在多的一方建立外键，指向一的一方的主键

(2) 多对多

案例：学生与课程
关系：一个学生可以选多门课程，一门课程也可以供多个学生选修
实现：建立第三张中间表，中间表至少包含两个外键，分别关联两方主键

(3) 一对一

案例：用户与用户详情
关系：一对一关系，多用于单表拆分，将一张表的基础字段放在一张表中，其他详情字段放在另一张表中，以提升操作效率
实现：在任意一方加入外键，关联另外一方的主键，并且设置外键为唯一的（UNIQUE）

查询

(1) 合并查询（笛卡尔积，会展示所有组合结果）：

1	select * from employee, dept;

笛卡尔积：两个集合A集合和B集合的所有组合情况（在多表查询时，需要消除无效的笛卡尔积）

(2) 消除无效笛卡尔积：

1	select * from emp, dept where dept_id = dept.id;

(3) 内连接查询

① 内连接查询的是两张表交集的部分，即如图的绿色部分

② 隐式内连接：

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

③ 显式内连接：

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

④ 代码示例：

-- 隐式内连接
select e.name, d.name from emp e, dept d where e.dept_id = d.id;

-- 显式内连接
select e.name, d.name from emp e inner join dept d on e.dept_id = d.id;

(4) 外连接查询

① 左外连接：查询左表所有数据，以及两张表交集部分数据（相当于蓝色部分 + 绿色部分），相当于查询表1的所有数据，包含表1和表2交集部分数据

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

② 右外连接：查询右表所有数据，以及两张表交集部分数据，相当于查询表 2 的所有数据，同时包含表 1 与表 2 交集部分数据

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

③ 代码示例：

-- 左
select e.*, d.name from employee as e left outer join dept as d on e.dept = d.id;
select d.name, e.* from dept d left outer join emp e on e.dept = d.id;  -- 这条语句与下面的语句效果一样
-- 右
select d.name, e.* from employee as e right outer join dept as d on e.dept = d.id;

关键逻辑：

1	select d.name, e.* from dept d left outer join emp e on e.dept = d.id;

表顺序：dept d（左表） ← LEFT JOIN → emp e（右表）
连接类型：左连接 → 保 “左表（dept）” 的所有行
逻辑：返回dept的所有部门（哪怕这个部门没有员工），同时匹配emp中该部门的员工数据

1	select d.name, e.* from employee as e right outer join dept as d on e.dept = d.id;

表顺序：employee e（左表） ← RIGHT JOIN → dept d（右表）
连接类型：右连接 → 保 “右表（dept）” 的所有行
逻辑：返回dept的所有部门（哪怕这个部门没有员工），同时匹配emp中该部门的员工数据

(5) 自连接查询

① 当前表与自身的连接查询，自连接必须使用表别名

② 语法：

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

自连接查询，可以是内连接查询，也可以是外连接查询

③ 代码示例：

-- 查询员工及其所属领导的名字
select a.name, b.name from employee a, employee b where a.manager = b.id;
-- 没有领导的也查询出来
select a.name, b.name from employee a left join employee b on a.manager = b.id;

(6) 联合查询 union, union all

① 把多次查询的结果合并，形成一个新的查询集

② 语法：

1
2
3

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

③ 注意事项

UNION ALL 会有重复结果，UNION 不会
联合查询比使用or效率高，不会使索引失效

子查询

(1) SQL语句中嵌套SELECT语句，称谓嵌套查询，又称子查询。

(2) 语法：

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

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

③ 根据子查询结果可以分为：

标量子查询（子查询结果为单个值）
列子查询（子查询结果为一列）
行子查询（子查询结果为一行）
表子查询（子查询结果为多行多列）

④ 根据子查询位置可分为：

WHERE 之后
FROM 之后
SELECT 之后

(3) 标量子查询

① 子查询返回的结果是单个值（数字、字符串、日期等）。

② 常用操作符：-、<>、>、>=、<、<=

**注意：**在 MySQL 中，<>是 “不等于” 的比较操作符，用于判断两个值是否不相等，等价于!=（二者是完全相同的含义）

③ 代码示例：

select id from dept where name = '销售部';
select * from emp where dept_id = 4;
select * from emp where dept_id = (select id from dept where name = '销售部');

-- 查询在 “方东白” 入职之后的员工信息
select * from emp where entrydate > (select entrydate from emp where name = '方东白');

(4) 列子查询

① 返回的结果是一列（可以是多行）。

② 常用操作符：

操作符	描述
IN	在指定的集合范围内，多选一
NOT IN	不在指定的集合范围内
ANY	子查询返回列表中，有任意一个满足即可
SOME	与ANY等同，使用SOME的地方都可以使用ANY
ALL	子查询返回列表的所有值都必须满足

③ 代码示例：

-- 查询财务部所有人的工资
select salary from emp where dept_id = (select id from dept where name = '财务部');

-- 查询比财务部所有人工资都高的员工信息
select * from emp where salary > all (select salary from emp where dept_id = (select id from dept where name = '财务部'));

(5) 行子查询

① 返回的结果是一行（可以是多列）。

② 常用操作符：=, <, >, IN, NOT IN

③ 代码示例：

1
2
3

-- 查询与xxx的薪资及直属领导相同的员工信息
select * from employee where (salary, manager) = (12500, 1);
select * from employee where (salary, manager) = (select salary, manager from employee where name = 'xxx');

(6) 表子查询

① 返回的结果是多行多列

② 常用操作符：IN

③ 代码示例：

1
2
3

-- 查询与 “鹿杖客”，“宋远桥” 的职位和薪资相同的员工信息
select job, salary from emp where name = '鹿杖客' or name = '宋远桥';
select * from emp where (job, salary) in (select job, salary from emp where name = '鹿杖客' or name = '宋远桥');

关键逻辑：重点理解外面的「主查询」

遍历emp表的每一个员工，取出他的job和salary组成一个 “组合对”，看这个组合对是否在子查询的 “模板列表” 里（也就是是否是(职员,3750)或(销售,4600)），如果在，就把这个员工的所有信息查出来。

-- 查询入职日期是 “2006-01-01” 之后的员工信息及其部门信息
select * from emp where entrydate > '2006-01-01';

-- 查询这部分员工，对应的部门信息
select * from (select * from emp where entrydate > '2006-01-01') e left join dept d on e.dept_id = d.id;

综合练习

(1) 查询年龄小于30岁的员工的姓名、年龄、职位、部门信息（显式内连接）

1	select e.name, e.age, e.job, d.name from emp e inner join dept d on e.dept_id = d.id where e.age < 30;

关键逻辑：显式内连接（INNER JOIN）的标准语法结构是：

SELECT 字段 
FROM 表1 别名1
JOIN 表2 别名2 ON 表1和表2的连接条件  -- ON是JOIN子句的核心部分，必须紧跟JOIN
WHERE 筛选条件;  -- WHERE是全局筛选，在JOIN（含ON）之后

① ON是JOIN的 “配套条件”—— 数据库要求，只要写JOIN关联两张表，就必须用ON指定 “两张表怎么关联”，所以ON必须紧跟在JOIN 表2之后；

② WHERE是对 “关联后的结果集” 做筛选，只能放在最后。

(2) 查询拥有员工的部门ID、部门名称

1	select distinct d.id, d.name from emp e, dept d where e.dept_id = d.id;

易错点：忘记加 distinct

(3) 查询低于本部门平均工资的员工信息

1	select * from emp e2 where e2.salary < (select avg(e1.salary) from emp e1 where e1.dept_id = e2.dept_id);

关键逻辑：

拆分成先算出每个部门的平均工资，再查询低于本部门平均工资的员工信息

1	select avg(e1.salary) from emp e1 where e1.dept_id = 1;

事务

事务是一组操作的集合，事务会把所有操作作为一个整体一起向系统提交或撤销操作请求，即这些操作要么同时成功，要么同时失败。

基本操作：

-- 1. 查询张三账户余额
select * from account where name = '张三';
-- 2. 将张三账户余额-1000
update account set money = money - 1000 where name = '张三';
-- 此语句出错后张三钱减少但是李四钱没有增加
模拟sql语句错误
-- 3. 将李四账户余额+1000
update account set money = money + 1000 where name = '李四';

-- 查看事务提交方式
SELECT @@AUTOCOMMIT;
-- 设置事务提交方式，1为自动提交，0为手动提交，该设置只对当前会话有效
SET @@AUTOCOMMIT = 0;
-- 提交事务
COMMIT;
-- 回滚事务
ROLLBACK;

操作方式二

(1) 开启事务：

1	START TRANSACTION 或 BEGIN TRANSACTION;

(2) 提交事务：

COMMIT;

(3) 回滚事务：

ROLLBACK;

(4) 操作实例：

start transaction;
select * from account where name = '张三';
update account set money = money - 1000 where name = '张三';
update account set money = money + 1000 where name = '李四';
commit;

四大特性ACID

原子性(Atomicity)：事务是不可分割的最小操作单元，要么全部成功，要么全部失败
一致性(Consistency)：事务完成时，必须使所有数据都保持一致状态
隔离性(Isolation)：数据库系统提供的隔离机制，保证事务在不受外部并发操作影响的独立环境下运行
持久性(Durability)：事务一旦提交或回滚，它对数据库中的数据的改变就是永久的

并发事务

(1) 并发事务问题

问题	描述
脏读	一个事务读到另一个事务还没提交的数据
不可重复读	一个事务先后读取同一条记录，但两次读取的数据不同
幻读	一个事务按照条件查询数据时，没有对应的数据行，但是再插入数据时，又发现这行数据已经存在

(2) 并发事务隔离级别：

隔离级别	脏读	不可重复读	幻读
Read uncommitted（读未提交）	√	√	√
Read committed（读已提交）	×	√	√
Repeatable Read(默认)	×	×	√
Serializable（串行化）	×	×	×

√表示在当前隔离级别下该问题会出现
Serializable 性能最低；Read uncommitted 性能最高，数据安全性最差

① 查看事务隔离级别：

1	SELECT @@TRANSACTION_ISOLATION;

② 设置事务隔离级别：

1	SET [ SESSION \| GLOBAL ] TRANSACTION ISOLATION LEVEL {READ UNCOMMITTED \| READ COMMITTED \| REPEATABLE READ \| SERIALIZABLE };

SESSION 是会话级别，表示只针对当前会话有效，GLOBAL 表示对所有会话有效

创建数据库的流程

点击左侧界面 **“Create data source”，**在弹出的菜单中，选择 “MySQL”

填写 MySQL 连接信息，输入User、Password

下载 MySQL 驱动（首次连接需要），界面会提示 “Download missing driver files”（缺少驱动文件），点击这个提示 → 选择自动下载驱动
填写完信息 + 下载驱动后，点击窗口右下角的 **“Test Connection”，**最后点击 “Apply”→“OK”

SSM学习笔记之 MyBatis-Plus

2026-03-20T04:00:00.000Z

MyBatisPlus入门案例与简介

入门案例

创建Dao接口

1
2
3

@Mapper
public interface UserDao extends BaseMapper{
}

编写引导类

@SpringBootApplication
//@MapperScan("com.itheima.dao")
public class Mybatisplus01QuickstartApplication {
    public static void main(String[] args) {
        SpringApplication.run(Mybatisplus01QuickstartApplication.class, args);
    }

}

标准数据层开发

标准CRUD使用

方法大全

新增

语法格式

1	int insert (T t)

T：泛型，新增用来保存新增数据
int：返回值，新增成功后返回1，没有新增成功返回的是0

代码示例

@SpringBootTest
class Mybatisplus01QuickstartApplicationTests {

    @Autowired
    private UserDao userDao;

    @Test
    void testSave() {
        User user = new User();
        user.setName("黑马程序员");
        user.setPassword("itheima");
        user.setAge(12);
        user.setTel("4006184000");
        userDao.insert(user);
    }
}

删除

语法格式

1	int deleteById (Serializable id)

代码示例

@SpringBootTest
class Mybatisplus01QuickstartApplicationTests {

    @Autowired
    private UserDao userDao;

    @Test
    void testDelete() {
        userDao.deleteById(1401856123725713409L);
    }
}

修改

语法格式

1	int updateById(T t);

代码示例

@SpringBootTest
class Mybatisplus01QuickstartApplicationTests {

    @Autowired
    private UserDao userDao;

    @Test
    void testUpdate() {
        User user = new User();
        user.setId(1L);
        user.setName("Tom888");
        user.setPassword("tom888");
        userDao.updateById(user);
    }
}

说明：

在代码中通过 user.setId(1L) 明确指定了要更新的记录的主键值为 1。

根据ID查询

语法格式

1	T selectById (Serializable id)

代码示例

@SpringBootTest
class Mybatisplus01QuickstartApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetById() {
        User user = userDao.selectById(2L);
        System.out.println(user);
    }
}

Lombok

@Data：是个组合注解，可自动为实体类生成所有属性的 get/set 方法、toString 方法、equals 和 hashCode 方法。
@NoArgsConstructor：提供一个无参构造函数
@AllArgsConstructor：提供一个包含所有参数的构造函数

分页功能

语法格式

1	IPage selectPage(IPage page, Wrapper queryWrapper)

IPage：用来构建分页查询条件
Wrapper：用来构建条件查询的条件，目前我们没有可直接传为Null
IPage：返回值，你会发现构建分页条件和方法的返回值都是IPage

IPage是一个接口，我们需要找到它的实现类来构建它，具体的实现类，可以进入到IPage类中按ctrl+h，会找到其有一个实现类为Page。

操作步骤

调用方法传入参数获取返回值

@SpringBootTest
class Mybatisplus01QuickstartApplicationTests {

    @Autowired
    private UserDao userDao;
    
    //分页查询
    @Test
    void testSelectPage(){
        //1 创建IPage分页对象,设置分页参数,1为当前页码，3为每页显示的记录数
        IPage page=new Page<>(1,3);
        //2 执行分页查询
        userDao.selectPage(page,null);
        //3 获取分页结果
        System.out.println("当前页码值："+page.getCurrent());
        System.out.println("每页显示数："+page.getSize());
        System.out.println("一共多少页："+page.getPages());
        System.out.println("一共多少条数据："+page.getTotal());
        System.out.println("数据："+page.getRecords());
    }
}

设置分页拦截器

这个拦截器MP已经为我们提供好了，我们只需要将其配置成Spring管理的bean对象即可。

@Configuration
public class MybatisPlusConfig {
    
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        //1 创建MybatisPlusInterceptor拦截器对象
        MybatisPlusInterceptor mpInterceptor=new MybatisPlusInterceptor();
        //2 添加分页拦截器
        mpInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mpInterceptor;
    }
}

DQL编程控制

条件查询

在进行查询的时候，我们的入口是在Wrapper这个类上，因为它是一个接口，所以我们需要去找它对应的实现类，关于实现类也有很多，说明我们有多种构建查询条件对象的方式。

方式一：简单的 QueryWrapper

@SpringBootTest
class Mybatisplus02DqlApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        QueryWrapper qw = new QueryWrapper();
        qw.lt("age",18);
        List userList = userDao.selectList(qw);
        System.out.println(userList);
    }
}

说明：

lt: 小于(<)，最终的sql语句为：

1	SELECT id,name,password,age,tel FROM user WHERE (age < ?)

方式二：QueryWrapper的基础上使用lambda

@SpringBootTest
class Mybatisplus02DqlApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        QueryWrapper qw = new QueryWrapper();
        qw.lambda().lt(User::getAge, 10);//添加条件
        List userList = userDao.selectList(qw);
        System.out.println(userList);
    }
}

说明：

① User::getAge，为lambda表达式中的方法引用，类名::方法名，最终的sql语句为：

1	SELECT id,name,password,age,tel FROM user WHERE (age < ?)

1). 用 Lambda 表达式的写法（完整逻辑）：

1 2	// Lambda表达式：接收User对象，调用它的getAge()方法返回年龄 qw.lambda().lt((User user) -> user.getAge(), 10);

2). 用方法引用的简化写法

1 2	// 方法引用：直接指向User类的getAge()方法，效果和上面的Lambda完全一样 qw.lambda().lt(User::getAge, 10);

② **注意：**构建LambdaQueryWrapper的时候泛型不能省。

方式三：LambdaQueryWrapper（推荐）

@SpringBootTest
class Mybatisplus02DqlApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        LambdaQueryWrapper lqw = new LambdaQueryWrapper();
        lqw.lt(User::getAge, 10);
        List userList = userDao.selectList(lqw);
        System.out.println(userList);
    }
}

多条件构建

需求：查询数据库表中，年龄在10岁到30岁之间的用户信息

@SpringBootTest
class Mybatisplus02DqlApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        LambdaQueryWrapper lqw = new LambdaQueryWrapper();
        lqw.lt(User::getAge, 30);
        lqw.gt(User::getAge, 10);
        List userList = userDao.selectList(lqw);
        System.out.println(userList);
    }
}

说明：

1). gt：大于(>)，最终的SQL语句为：

1	SELECT id,name,password,age,tel FROM user WHERE (age < ? AND age > ?)

2). 构建多条件的时候，可以支持链式编程

LambdaQueryWrapper lqw = new LambdaQueryWrapper();
lqw.lt(User::getAge, 30).gt(User::getAge, 10);
List userList = userDao.selectList(lqw);
System.out.println(userList);

需求：查询数据库表中，年龄小于10或年龄大于30的数据

@SpringBootTest
class Mybatisplus02DqlApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        LambdaQueryWrapper lqw = new LambdaQueryWrapper();
        lqw.lt(User::getAge, 10).or().gt(User::getAge, 30);
        List userList = userDao.selectList(lqw);
        System.out.println(userList);
    }
}

说明：

or()就相当于我们sql语句中的or关键字，不加默认是and，最终的sql语句为：

1	SELECT id,name,password,age,tel FROM user WHERE (age < ? OR age > ?)

null 判定

存在的问题

先来看一张图：

我们在做条件查询的时候，一般会有很多条件可以供用户进行选择查询。
这些条件用户可以选择使用也可以选择不使用，比如我要查询价格在8000以上的手机
在输入条件的时候，价格有一个区间范围，按照需求只需要在第一个价格输入框中输入8000
后台在做价格查询的时候，一般会让 price>值1 and price <值2
因为前端没有输入值2，所以如果不处理的话，就会出现 price>8000 and price < null问题
这个时候查询的结果就会出问题，具体该如何解决?

操作步骤

1). 新建一个模型类，让其继承User类，并在其中添加age2属性，UserQuery在拥有User属性后同时添加了age2属性。

@Data
public class User {
    private Long id;
    private String name;
    private String password;
    private Integer age;
    private String tel;
}

@Data
public class UserQuery extends User {
    private Integer age2;
}

2). 查询方式

@SpringBootTest
class Mybatisplus02DqlApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        //模拟页面传递过来的查询数据
        UserQuery uq = new UserQuery();
        uq.setAge(10);
        uq.setAge2(30);
        LambdaQueryWrapper lqw = new LambdaQueryWrapper();
        lqw.lt(null!=uq.getAge2(),User::getAge, uq.getAge2());
        lqw.gt(null!=uq.getAge(),User::getAge, uq.getAge());
        List userList = userDao.selectList(lqw);
        System.out.println(userList);
    }
}

说明：

lt()方法

condition为boolean类型，返回true，则添加条件，返回false则不添加条件

你代码里的lqw.lt(null!=uq.getAge2(),User::getAge, uq.getAge2())，第一个参数null!=uq.getAge2()是 MyBatis-Plus 提供的条件过滤功能：

如果null!=uq.getAge2()为true（即前端传了 age2 参数）：就把age < 30这个条件加入 SQL；
如果null!=uq.getAge2()为false（即前端没传 age2）：就忽略这个条件，不会生成age < null这种无效 SQL。

查询投影

查询指定字段

@SpringBootTest
class Mybatisplus02DqlApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        LambdaQueryWrapper lqw = new LambdaQueryWrapper();
        lqw.select(User::getId,User::getName,User::getAge);
        List userList = userDao.selectList(lqw);
        System.out.println(userList);
    }
}

说明：

① select(…)方法用来设置查询的字段列，可以设置多个，最终的sql语句为：

1	SELECT id,name,age FROM user

② lqw.select(User::getId, User::getName, User::getAge)：这是方法引用的应用，MyBatis-Plus 会根据User类的getXxx()方法，自动解析出数据库的字段名（getId→id，getName→name），避免手写字段名出错（比如把name写成naem）。

聚合查询

@SpringBootTest
class Mybatisplus02DqlApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        QueryWrapper lqw = new QueryWrapper();
        //lqw.select("count(*) as count");
        //SELECT count(*) as count FROM user
        //lqw.select("max(age) as maxAge");
        //SELECT max(age) as maxAge FROM user
        //lqw.select("min(age) as minAge");
        //SELECT min(age) as minAge FROM user
        //lqw.select("sum(age) as sumAge");
        //SELECT sum(age) as sumAge FROM user
        lqw.select("avg(age) as avgAge");
        //SELECT avg(age) as avgAge FROM user
        List> userList = userDao.selectMaps(lqw);
        System.out.println(userList);
    }
}

说明：

① 为什么用 QueryWrapper 而不是 LambdaQueryWrapper？

因为这里要直接写 SQL 片段（如 avg(age)），而不是引用实体类的方法。Lambda 方式更适合查询实体类字段，而直接写 SQL 片段时，普通 QueryWrapper 更灵活。

② 为什么用 selectMaps 而不是 selectList？

selectList 要求返回的每一行数据都能映射为 User 对象，但聚合函数（如 avg(age)）的结果不是 User 类的字段，无法直接封装成 User。selectMaps 会把每一行结果封装成一个 Map，其中：

Key 是列名（或别名，如 avgAge）
Value 是对应的值（如平均年龄 25.5）

分组查询

@SpringBootTest
class Mybatisplus02DqlApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        QueryWrapper lqw = new QueryWrapper();
        lqw.select("count(*) as count,tel");
        lqw.groupBy("tel");
        List> list = userDao.selectMaps(lqw);
        System.out.println(list);
    }
}

查询条件

等值查询

需求

根据用户名和密码查询用户信息

代码实现

@SpringBootTest
class Mybatisplus02DqlApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        LambdaQueryWrapper lqw = new LambdaQueryWrapper();
        lqw.eq(User::getName, "Jerry").eq(User::getPassword, "jerry");
        User loginUser = userDao.selectOne(lqw);
        System.out.println(loginUser);
    }
}

说明：

eq()：相当于 =，对应的sql语句为：

1	SELECT id,name,password,age,tel FROM user WHERE (name = ? AND password = ?)

selectList：查询结果为多个或者单个
selectOne：查询结果为单个

范围查询

需求

对年龄进行范围查询，使用lt()、le()、gt()、ge()、between()进行范围查询

代码实现

@SpringBootTest
class Mybatisplus02DqlApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        LambdaQueryWrapper lqw = new LambdaQueryWrapper();
        lqw.between(User::getAge, 10, 30);
        //SELECT id,name,password,age,tel FROM user WHERE (age BETWEEN ? AND ?)
        List userList = userDao.selectList(lqw);
        System.out.println(userList);
    }
}

gt()：大于(>)
ge()：大于等于(>=)
lt()：小于(<)
le()：小于等于(<=)
between()：between ? and ?

模糊查询

需求

查询表中name属性的值以J开头的用户信息，使用like进行模糊查询

代码实现

@SpringBootTest
class Mybatisplus02DqlApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        LambdaQueryWrapper lqw = new LambdaQueryWrapper();
        lqw.likeLeft(User::getName, "J");
        //SELECT id,name,password,age,tel FROM user WHERE (name LIKE ?)
        List userList = userDao.selectList(lqw);
        System.out.println(userList);
    }
}

说明：

like()：前后加百分号,如 %J%
likeLeft()：前面加百分号,如 %J
likeRight()：后面加百分号,如 J%

映射匹配兼容性

存在的问题

问题1：表字段与编码属性设计不同步

① 当表的列名和模型类的属性名发生不一致，就会导致数据封装不到模型对象，这个时候就需要其中一方做出修改，那如果前提是两边都不能改又该如何解决?

② MP给我们提供了一个注解@TableField，使用该注解可以实现模型类属性名和表的列名之间的映射关系

问题2：编码中添加了数据库中未定义的属性

① 当模型类中多了一个数据库表不存在的字段，就会导致生成的sql语句中在select的时候查询了数据库不存在的字段，程序运行就会报错，错误信息为：

Unknown column ‘多出来的字段名称’ in ‘field list’

② 具体的解决方案用到的还是@TableField注解，它有一个属性叫exist，设置该字段是否在数据库表中存在，如果设置为false则不存在，生成sql语句查询的时候，就不会再查询该字段了。

问题3：采用默认查询开放了更多的字段查看权限

① 查询表中所有的列的数据，就可能把一些敏感数据查询到返回给前端，这个时候我们就需要限制哪些字段默认不要进行查询。

② 解决方案是@TableField注解的一个属性叫select，该属性设置默认是否需要查询该字段的值，true(默认值)表示默认查询该字段，false表示默认不查询该字段。

代码实现

① 修改数据库表user为tbl_user

直接查询会报错，原因是MP默认情况下会使用模型类的类名首字母小写当表名使用。

② 模型类添加@TableName注解

@Data
@TableName("tbl_user")
public class User {
    private Long id;
    private String name;
    private String password;
    private Integer age;
    private String tel;
}

③ 将字段password修改成pwd

直接查询会报错，原因是MP默认情况下会使用模型类的属性名当做表的列名使用

④ 使用@TableField映射关系

@Data
@TableName("tbl_user")
public class User {
    private Long id;
    private String name;
    @TableField(value="pwd")
    private String password;
    private Integer age;
    private String tel;
}

知识点

@TableField

名称	@TableField
类型	属性注解
位置	模型类属性定义上方
作用	设置当前属性对应的数据库表中的字段关系
相关属性	value(默认)：设置数据库表字段名称 exist：设置属性在数据库表字段中是否存在，默认为true，此属性不能与value合并使用 select：设置属性是否参与查询，此属性与select()映射配置不冲突

@TableName

名称	@TableName
类型	类注解
位置	模型类定义上方
作用	设置当前类对应于数据库表关系
相关属性	value(默认)：设置数据库表名称

DML编程控制

生成策略

NONE：不设置id生成策略
INPUT：用户手工输入id
ASSIGN_ID：雪花算法生成id(可兼容数值型与字符串型)
ASSIGN_UUID：以UUID生成算法作为id生成策略
其他的几个策略均已过时，都将被ASSIGN_ID和ASSIGN_UUID代替掉。

代码实现

INPUT策略

① 设置生成策略为INPUT

@Data
@TableName("tbl_user")
public class User {
    @TableId(type = IdType.INPUT)
    private Long id;
    private String name;
    @TableField(value="pwd",select=false)
    private String password;
    private Integer age;
    private String tel;
    @TableField(exist=false)
    private Integer online;
}

② 添加数据手动设置ID

@SpringBootTest
class Mybatisplus03DqlApplicationTests {

    @Autowired
    private UserDao userDao;

    @Test
    void testSave(){
        User user = new User();
        //设置主键ID的值
        user.setId(666L);
        user.setName("黑马程序员");
        user.setPassword("itheima");
        user.setAge(12);
        user.setTel("4006184000");
        userDao.insert(user);
    }
}

ASSIGN_ID策略（雪花算法）

① 设置生成策略为ASSIGN_ID

@Data
@TableName("tbl_user")
public class User {
    @TableId(type = IdType.ASSIGN_ID)
    private Long id;
    private String name;
    @TableField(value="pwd",select=false)
    private String password;
    private Integer age;
    private String tel;
    @TableField(exist=false)
    private Integer online;
}

② 添加数据不设置ID

@SpringBootTest
class Mybatisplus03DqlApplicationTests {

    @Autowired
    private UserDao userDao;

    @Test
    void testSave(){
        User user = new User();
        user.setName("黑马程序员");
        user.setPassword("itheima");
        user.setAge(12);
        user.setTel("4006184000");
        userDao.insert(user);
    }
}

ASSIGN_UUID策略

① 设置生成策略为ASSIGN_UUID

使用uuid需要注意的是，主键的类型不能是Long，而应该改成String类型

@Data
@TableName("tbl_user")
public class User {
    @TableId(type = IdType.ASSIGN_UUID)
    private String id;
    private String name;
    @TableField(value="pwd",select=false)
    private String password;
    private Integer age;
    private String tel;
    @TableField(exist=false)
    private Integer online;
}

② 添加数据不设置ID

知识点

名称	@TableId
类型	属性注解
位置	模型类中用于表示主键的属性定义上方
作用	设置当前类中主键属性的生成策略
相关属性	value(默认)：设置数据库表主键名称 type：设置主键属性的生成策略，值查照IdType的枚举值

多记录操作

批量删除

@SpringBootTest
class Mybatisplus03DqlApplicationTests {

    @Autowired
    private UserDao userDao;

    @Test
    void testDelete(){
        //删除指定多条数据
        List list = new ArrayList<>();
        list.add(1402551342481838081L);
        list.add(1402553134049501186L);
        list.add(1402553619611430913L);
        userDao.deleteBatchIds(list);
    }
}

逻辑删除

实体类添加属性

标识新增的字段为逻辑删除字段，使用@TableLogic

@Data
//@TableName("tbl_user") 可以不写是因为配置了全局配置
public class User {
    @TableId(type = IdType.ASSIGN_UUID)
    private String id;
    private String name;
    @TableField(value="pwd",select=false)
    private String password;
    private Integer age;
    private String tel;
    @TableField(exist=false)
    private Integer online;
    @TableLogic(value="0",delval="1")
    //value为正常数据的值，delval为删除数据的值
    private Integer deleted;
}

知识点

名称	@TableLogic
类型	属性注解
位置	模型类中用于表示删除字段的属性定义上方
作用	标识该字段为进行逻辑删除的字段
相关属性	value：逻辑未删除值，delval：逻辑删除值

乐观锁

实现思路

① 数据库表中添加 version 列，默认值给 1

就像给每张票加一个 “版本号”，初始是 1。

② 线程 1 修改前，取出记录，获取 version=1

你看到票的版本号是 1。

③ 线程 2 修改前，取出记录，获取 version=1

你朋友也看到票的版本号是 1。

④ 线程 1 执行更新：set version = 2 where version = 1

你下单：“只有版本号还是 1，我才把它改成 2”。
如果成功，票的版本号就变成 2 了。

⑤ 线程 2 执行更新：set version = 2 where version = 1

你朋友下单：“只有版本号还是 1，我才把它改成 2”。
但此时版本号已经是 2 了，所以他的更新条件不满足，执行失败。

代码实现

① 在模型类中添加对应的属性

根据添加的字段列名，在模型类中添加对应的属性值

@Data
//@TableName("tbl_user") 可以不写是因为配置了全局配置
public class User {
    @TableId(type = IdType.ASSIGN_UUID)
    private String id;
    private String name;
    @TableField(value="pwd",select=false)
    private String password;
    private Integer age;
    private String tel;
    @TableField(exist=false)
    private Integer online;
    private Integer deleted;
    @Version
    private Integer version;
}

② 添加乐观锁的拦截器

@Configuration
public class MpConfig {
    @Bean
    public MybatisPlusInterceptor mpInterceptor() {
        //1.定义Mp拦截器
        MybatisPlusInterceptor mpInterceptor = new MybatisPlusInterceptor();
        //2.添加乐观锁拦截器
        mpInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return mpInterceptor;
    }
}

快速开发

代码生成器实现

创建代码生成类

public class CodeGenerator {
    public static void main(String[] args) {
        //1.获取代码生成器的对象
        AutoGenerator autoGenerator = new AutoGenerator();

        //设置数据库相关配置
        DataSourceConfig dataSource = new DataSourceConfig();
        dataSource.setDriverName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/mybatisplus_db?serverTimezone=UTC");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        autoGenerator.setDataSource(dataSource);

        //设置全局配置
        GlobalConfig globalConfig = new GlobalConfig();
        globalConfig.setOutputDir(System.getProperty("user.dir")+"/mybatisplus_04_generator/src/main/java");    //设置代码生成位置
        globalConfig.setOpen(false);    //设置生成完毕后是否打开生成代码所在的目录
        globalConfig.setAuthor("黑马程序员");    //设置作者
        globalConfig.setFileOverride(true);     //设置是否覆盖原始生成的文件
        globalConfig.setMapperName("%sDao");    //设置数据层接口名，%s为占位符，指代模块名称
        globalConfig.setIdType(IdType.ASSIGN_ID);   //设置Id生成策略
        autoGenerator.setGlobalConfig(globalConfig);

        //设置包名相关配置
        PackageConfig packageInfo = new PackageConfig();
        packageInfo.setParent("com.aaa");   //设置生成的包名，与代码所在位置不冲突，二者叠加组成完整路径
        packageInfo.setEntity("domain");    //设置实体类包名
        packageInfo.setMapper("dao");   //设置数据层包名
        autoGenerator.setPackageInfo(packageInfo);

        //策略设置
        StrategyConfig strategyConfig = new StrategyConfig();
        strategyConfig.setInclude("tbl_user");  //设置当前参与生成的表名，参数为可变参数
        strategyConfig.setTablePrefix("tbl_");  //设置数据库表的前缀名称，模块名 = 数据库表名 - 前缀名  例如： User = tbl_user - tbl_
        strategyConfig.setRestControllerStyle(true);    //设置是否启用Rest风格
        strategyConfig.setVersionFieldName("version");  //设置乐观锁字段名
        strategyConfig.setLogicDeleteFieldName("deleted");  //设置逻辑删除字段名
        strategyConfig.setEntityLombokModel(true);  //设置是否启用lombok
        autoGenerator.setStrategy(strategyConfig);
        //2.执行生成操作
        autoGenerator.execute();
    }
}

SSM学习笔记之 SpringBoot

2026-03-20T03:00:00.000Z

SpringBoot简介

SpringBoot 快速入门

对比

坐标
Spring 程序中的坐标需要自己编写，而且坐标非常多
SpringBoot 程序中的坐标是我们在创建工程时进行勾选自动生成的
web3.0配置类
Spring 程序需要自己编写这个配置类。这个配置类之前编写过，很复杂
SpringBoot 程序不需要我们自己书写
配置类
Spring/SpringMVC 程序的配置类需要自己书写。而 SpringBoot 程序则不需要书写。

配置文件

配置文件格式

application.properties配置文件

1	server.port=80

application.yml配置文件（推荐）

1 2	server: port: 81

注意：在:后，数据前一定要加空格。

application.yaml配置文件

1 2	server: port: 83

三种配合文件的优先级

1	application.properties` > `application.yml` > `application.yaml

yaml 格式

语法规则

大小写敏感
属性层级关系使用多行描述，每行结尾使用冒号结束
使用缩进表示层级关系，同层级左侧对齐，只允许使用空格（不允许使用Tab键）
空格的个数并不重要，只要保证同层级的左侧对齐即可。
属性值前面添加空格（属性名与属性值之间使用冒号+空格作为分隔）
# 表示注释

(2) 数组数据在数据书写位置的下方使用减号作为数据开始符号，每行书写一个数据，减号与数据间空格分隔，例如：（了解即可）

enterprise:
  name: itcast
  age: 16
  tel: 4006184000
  subject:
    - Java
    - 前端
    - 大数据

yaml配置文件数据读取

使用 @Value注解

使用 @Value("表达式") 注解可以从配置文件中读取数据，注解中用于读取属性名引用方式是：${一级属性名.二级属性名……}

我们可以在 BookController 中使用 @Value 注解读取配置文件数据，如下

@RestController
@RequestMapping("/books")
public class BookController {
    
    @Value("${lesson}")
    private String lesson;
    @Value("${server.port}")
    private Integer port;
    @Value("${enterprise.subject[0]}")
    private String subject_00;

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println(lesson);
        System.out.println(port);
        System.out.println(subject_00);
        return "hello , spring boot!";
    }
}

自定义对象（常用）

① SpringBoot 还提供了将配置文件中的数据封装到我们自定义的实体类对象中的方式。具体操作如下：

将实体类 bean 的创建交给 Spring 管理。
在类上添加 @Component 注解
使用 @ConfigurationProperties 注解表示加载配置文件
在该注解中也可以使用 prefix 属性指定只加载指定前缀的数据
在 BookController 中进行注入

② 代码示例

Enterprise 实体类内容如下：

@Component
@ConfigurationProperties(prefix = "enterprise")
public class Enterprise {
    private String name;
    private int age;
    private String tel;
    private String[] subject;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getTel() {
        return tel;
    }

    public void setTel(String tel) {
        this.tel = tel;
    }

    public String[] getSubject() {
        return subject;
    }

    public void setSubject(String[] subject) {
        this.subject = subject;
    }

    @Override
    public String toString() {
        return "Enterprise{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", tel='" + tel + '\'' +
                ", subject=" + Arrays.toString(subject) +
                '}';
    }
}

多环境配置

yaml文件

① 在 application.yml 中使用 --- 来分割不同的配置，内容如下：

#开发
spring:
  profiles: dev #给开发环境起的名字
server:
  port: 80
---
#生产
spring:
  profiles: pro #给生产环境起的名字
server:
  port: 81
---
#测试
spring:
  profiles: test #给测试环境起的名字
server:
  port: 82
---

② 上面配置中 spring.profiles 是用来给不同的配置起名字的。而如何告知 SpringBoot 使用哪段配置呢？可以使用如下配置来启用那一段配置

#设置启用的环境
spring:
  profiles:
    active: dev  #表示使用的是开发环境的配置

③ 综上所述，application.yml 配置文件内容如下

#设置启用的环境
spring:
  profiles:
    active: dev

---
#开发
spring:
  profiles: dev
server:
  port: 80
---
#生产
spring:
  profiles: pro
server:
  port: 81
---
#测试
spring:
  profiles: test
server:
  port: 82
---

命令行启动参数设置

① 这种方式显然有点麻烦，而 SpringBoot 提供了在运行 jar 时设置开启指定的环境的方式，如下

1	java –jar xxx.jar –-spring.profiles.active=test

② 这种方式也可以临时修改端口号，通过如下方式

1	java –jar xxx.jar –-server.port=88

SpringBoot整合第三方技术

SpringBoot 整合 junit

(1) 在 com.itheima.service 下创建 BookService 接口，内容如下

1
2
3

public interface BookService {
    public void save();
}

(2) 在 com.itheima.service.impl 包写创建一个 BookServiceImpl 类，使其实现 BookService 接口，内容如下

@Service
public class BookServiceImpl implements BookService {
    @Override
    public void save() {
        System.out.println("book service is running ...");
    }
}

(3) 在 test/java 下创建 com.itheima 包，在该包下创建测试类，将 BookService 注入到该测试类中

@SpringBootTest
class Springboot07TestApplicationTests {

    @Autowired
    private BookService bookService;

    @Test
    public void save() {
        bookService.save();
    }
}

SpringBoot 整合 MyBatis

操作步骤

① 定义实体类

在 com.itheima.domain 包下定义实体类 Book，内容如下

public class Book {
    private Integer id;
    private String name;
    private String type;
    private String description;
    
    //setter and  getter
    
    //toString
}

② 定义dao接口

在 com.itheima.dao 包下定义 BookDao 接口，内容如下

@Mapper
public interface BookDao {
    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);
}

说明：

1). 一定要加上 @Mapper，否则会显示在 Spring 容器中没有 BookDao 类型的 bean。

2). @Mapper 就是用来 “通知” MyBatis 的 ——给接口打上 @Mapper 注解，就告诉 MyBatis：“这是一个 DAO 接口，帮我生成代理实现类，交给 Spring 管理”。

③ 定义测试类

在 test/java 下定义包 com.itheima ，在该包下测试类，内容如下

@SpringBootTest
class Springboot08MybatisApplicationTests {

@Autowired
private BookDao bookDao;

@Test
void testGetById() {
Book book = bookDao.getById(1);
System.out.println(book);
}
}

案例

静态资源

在 SpringBoot 程序中是没有 webapp 目录的，那么在 SpringBoot 程序中静态资源需要放在什么位置呢？

静态资源需要放在 resources 下的 static 下，如下图所示

SSM学习笔记之 SpringMVC

2026-03-20T02:00:00.000Z

SpringMVC学习笔记

SpringMVC入门案例

TomCat 的作用

先搞懂核心定位（通俗比喻）

把整个 Web 应用比作 “餐厅”

浏览器 = 顾客（发起点餐请求）；
Tomcat = 餐厅的「前台 + 传菜员 + 机房」：负责接待顾客、解析点餐需求、把需求传给后厨，再把做好的餐品送回顾客；
SpringMVC = 餐厅的「后厨（控制器 / 服务 / DAO）」：负责处理具体的 “点餐需求”（业务逻辑），但后厨不能直接面对顾客，必须通过前台（Tomcat）衔接。

Tomcat 在 SpringMVC 中的核心作用

Tomcat 首先是一个轻量级 Web 服务器，负责处理最底层的网络通信：

监听指定端口（默认 8080），接收浏览器发来的 HTTP 请求（比如 GET/POST）；
解析 HTTP 请求的格式（比如请求头、请求参数、请求体），把杂乱的 HTTP 字节流转换成 Java 能识别的对象 ——HttpServletRequest（请求对象）和HttpServletResponse（响应对象）；
处理完请求后，把 SpringMVC 返回的响应数据（比如页面、JSON）重新封装成 HTTP 格式，发送回浏览器。

代码实现

创建配置类

@Configuration
@ComponentScan("com.itheima.controller")
public class SpringMvcConfig {
}

创建Controller类

@Controller
public class UserController {
    
    @RequestMapping("/save")
    public void save(){
        System.out.println("user save ...");
    }
}

使用配置类替换web.xml

将web.xml删除，换成ServletContainersInitConfig

public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    //加载springmvc配置类
    protected WebApplicationContext createServletApplicationContext() {
        //初始化WebApplicationContext对象
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        //加载指定配置类
        ctx.register(SpringMvcConfig.class);
        return ctx;
    }

    //设置由springmvc控制器处理的请求映射路径
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    //加载spring配置类
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }
}

核心逻辑：

① createServletApplicationContext ()：创建 SpringMVC 专属的 IOC 容器

作用：创建并返回一个Spring MVC 专属的 Web 应用上下文（IOC 容器）。
这个上下文专门用来加载 Spring MVC 相关的 Bean，比如控制器（@Controller）、视图解析器、处理器映射等。
AnnotationConfigWebApplicationContext 表示这个容器是基于Java 注解来配置的，而不是 XML。

② getServletMappings ()：指定 SpringMVC 处理哪些请求

作用：指定 DispatcherServlet 要处理哪些 URL 请求。
返回 "/" 意味着它会处理所有进入应用的请求。

bean加载控制

思路分析

加载Spring控制的bean的时候排除掉SpringMVC控制的bean，具体该如何排除

方式一：Spring加载的bean设定扫描范围为精准范围，例如service包、dao包等

方式二：Spring加载的bean设定扫描范围为com.itheima,排除掉controller包中的bean

代码实现

① 方式一：修改Spring配置类，设定扫描范围为精准范围

@Configuration
@ComponentScan({"com.itheima.service","comitheima.dao"})
public class SpringConfig {
}

说明：

上述只是通过例子说明可以精确指定让Spring扫描对应的包结构，真正在做开发的时候，因为Dao最终是交给MapperScannerConfigurer对象来进行扫描处理的，我们只需要将其扫描到service包即可。

② 方式二：修改Spring配置类，设定扫描范围为com.itheima，排除掉controller包中的bean

@Configuration
@ComponentScan(value="com.itheima",
    excludeFilters=@ComponentScan.Filter(
    type = FilterType.ANNOTATION,
        classes = Controller.class
    )
)
public class SpringConfig {
}

excludeFilters属性：设置扫描加载bean时，排除的过滤规则
type属性：设置排除规则，当前使用按照bean定义时的注解类型进行排除
classes属性：设置排除的具体注解类，当前设置排除@Controller定义的bean

③ 测试类

public class App{
public static void main (String[] args){
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        System.out.println(ctx.getBean(UserController.class));
    }
}

1). 注意：

测试的时候，需要把SpringMvcConfig配置类上的@ComponentScan注解注释掉，否则不会报错。因为按照上述的要求，应该是SpringMvcConfig加载Controller，而现在注释掉了@ComponentScan，就会导致SpringMvcConfig无法指定Bean的扫描路径，导致Controller类无法被加载到IoC容器中。

2). 流程如下：

**如果不注释 SpringMvcConfig 上的 @ComponentScan：**Spring 容器加载 SpringConfig → 扫描到 SpringMvcConfig → 执行 SpringMvcConfig 的扫描 → Controller 被加载到根容器 → ctx.getBean(UserController.class) 能找到 Bean → 测试失败，看不到 “被排除” 的效果。
**如果注释掉 SpringMvcConfig 上的 @ComponentScan：**Spring 容器加载 SpringConfig → 扫描到 SpringMvcConfig，但它没有扫描动作 → Controller 没有被加载 → ctx.getBean(UserController.class) 抛出 NoSuchBeanDefinitionException → 测试成功，演示了 “被排除” 的效果。

代码优化

ServletContainerInitConfig

public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {

    protected Class[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    protected Class[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

请求与响应

请求参数

参数传递

① GET请求中文乱码

如果我们传递的参数中有中文，你会发现接收到的参数会出现中文乱码问题。

② 解决方案：配置过滤器

public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    protected Class[] getRootConfigClasses() {
        return new Class[0];
    }

    protected Class[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    //乱码处理
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};
    }
}

getServletFilters()：这是 AbstractAnnotationConfigDispatcherServletInitializer 提供的扩展点，用来注册 Servlet 过滤器。
CharacterEncodingFilter：Spring 内置的过滤器，专门处理字符编码问题。
setEncoding("UTF-8")：明确告诉过滤器，所有请求和响应都用 UTF-8 编码。

五种类型参数传递

① 如果形参与地址参数名不一致该如何解决?

1). 发送请求与参数：

1	http://localhost/commonParamDifferentName?name=张三&age=18

2). 解决方案:使用@RequestParam注解

@RequestMapping("/commonParamDifferentName")
    @ResponseBody
    public String commonParamDifferentName(@RequestPaam("name") String userName , int age){
        System.out.println("普通参数传递 userName > "+userName);
        System.out.println("普通参数传递 age > "+age);
        return "{'module':'common param different name'}";
    }

② POJO数据类型

1). POJO参数：请求参数名与形参对象属性名相同，定义POJO类型形参即可接收参数

public class User {
    private String name;
    private int age;
    //setter...getter...略
}

2). 后台接收参数：

//POJO参数：请求参数与形参对象中的属性对应即可完成参数传递
@RequestMapping("/pojoParam")
@ResponseBody
public String pojoParam(User user){
    System.out.println("pojo参数传递 user > "+user);
    return "{'module':'pojo param'}";
}

1). 如果POJO对象中嵌套了其他的POJO类，如

public class Address {
    private String province;
    private String city;
    //setter...getter...略
}
public class User {
    private String name;
    private int age;
    private Address address;
    //setter...getter...略
}

嵌套POJO参数：请求参数名与形参对象属性名相同，按照对象层次结构关系即可接收嵌套POJO属性参数

2). 发送请求和参数

④ 集合类型参数

1). 存在的问题

//集合参数：同名请求参数可以使用@RequestParam注解映射到对应名称的集合对象中作为数据
@RequestMapping("/listParam")
@ResponseBody
public String listParam(List likes){
    System.out.println("集合参数传递 likes > "+ likes);
    return "{'module':'list param'}";
}

错误的原因是：SpringMVC将List看做是一个POJO对象来处理，将其创建一个对象并准备把前端的数据封装到对象中，但是List是一个接口无法创建对象，所以报错。

2). 解决方案是使用@RequestParam注解

//集合参数：同名请求参数可以使用@RequestParam注解映射到对应名称的集合对象中作为数据
@RequestMapping("/listParam")
@ResponseBody
public String listParam(@RequestParam List likes){
    System.out.println("集合参数传递 likes > "+ likes);
    return "{'module':'list param'}";
}

集合保存普通参数：请求参数名与形参集合对象名相同且请求参数为多个，@RequestParam绑定参数关系

JSON数据传输参数

JSON普通数组

① 开启SpringMVC注解支持

在SpringMVC的配置类中开启SpringMVC的注解支持，这里面就包含了将JSON转换成对象的功能。

@Configuration
@ComponentScan("com.itheima.controller")
//开启json数据类型自动转换
@EnableWebMvc
public class SpringMvcConfig {
}

② 参数前添加@RequestBody

//使用@RequestBody注解将外部传递的json数组数据映射到形参的集合对象中作为数据
@RequestMapping("/listParamForJson")
@ResponseBody
public String listParamForJson(@RequestBody List likes){
    System.out.println("list common(json)参数传递 list > "+likes);
    return "{'module':'list common for json param'}";
}

知识点

① @EnableWebMvc

名称	@EnableWebMvc
类型	配置类注解
位置	SpringMVC配置类定义上方
作用	开启SpringMVC多项辅助功能

② @RequestBody

名称	@RequestBody
类型	形参注解
位置	SpringMVC控制器方法形参定义前面
作用	将请求中请求体所包含的数据传递给请求参数，此注解一个处理器方法只能使用一次

日期类型参数传递

携带时间的日期

@RequestMapping("/dataParam")
@ResponseBody
public String dataParam(Date date,
                        @DateTimeFormat(pattern="yyyy-MM-dd") Date date1,
                        @DateTimeFormat(pattern="yyyy/MM/dd HH:mm:ss") Date date2)
    System.out.println("参数传递 date > "+date);
System.out.println("参数传递 date1(yyyy-MM-dd) > "+date1);
System.out.println("参数传递 date2(yyyy/MM/dd HH:mm:ss) > "+date2);
    return "{'module':'data param'}";
}

知识点

① @DateTimeFormat

名称	@DateTimeFormat
类型	形参注解
位置	SpringMVC控制器方法形参前面
作用	设定日期时间型数据格式
相关属性	pattern：指定日期时间格式字符串

响应

响应JSON数据

① 响应POJO对象

@Controller
public class UserController {
    
    @RequestMapping("/toJsonPOJO")
    @ResponseBody
    public User toJsonPOJO(){
        System.out.println("返回json对象数据");
        User user = new User();
        user.setName("itcast");
        user.setAge(15);
        return user;
    }
    
}

返回值为实体类对象，设置返回值为实体类类型，即可实现返回对应对象的json数据，需要依赖@ResponseBody注解和@EnableWebMvc注解

② 响应POJO集合对象

@Controller
public class UserController {
    
    @RequestMapping("/toJsonList")
    @ResponseBody
    public List toJsonList(){
        System.out.println("返回json集合数据");
        User user1 = new User();
        user1.setName("传智播客");
        user1.setAge(15);

        User user2 = new User();
        user2.setName("黑马程序员");
        user2.setAge(12);

        List userList = new ArrayList();
        userList.add(user1);
        userList.add(user2);

        return userList;
    }
    
}

知识点

名称	@ResponseBody
类型	方法\类注解
位置	SpringMVC控制器方法定义上方和控制类上
作用	设置当前控制器返回值作为响应体, 写在类上，该类的所有方法都有该注解功能
相关属性	pattern：指定日期时间格式字符串

说明：

当方法上有@ReponseBody注解后

方法的返回值为字符串，会将其作为文本内容直接响应给前端
方法的返回值为对象，会将对象转换成JSON响应给前端

Rest 风格

请求方式

按照不同的请求方式代表不同的操作类型：

发送GET请求是用来做查询
发送POST请求是用来做新增
发送PUT请求是用来做修改
发送DELETE请求是用来做删除

RESTful 快速开发

知识点

① @PathVariable

名称	@PathVariable
类型	形参注解
位置	SpringMVC控制器方法形参定义前面
作用	绑定路径参数与处理器方法形参间的关系，要求路径参数名与形参名一一对应

② @RestController

名称	@RestController
类型	类注解
位置	基于SpringMVC的RESTful开发控制器类定义上方
作用	设置当前控制器类为RESTful风格，等同于@Controller与@ResponseBody两个注解组合功能

③ @GetMapping @PostMapping @PutMapping @DeleteMapping

名称	@GetMapping @PostMapping @PutMapping @DeleteMapping
类型	方法注解
位置	基于SpringMVC的RESTful开发控制器方法定义上方
作用	设置当前控制器方法请求访问路径与请求动作，每种对应一个请求动作，例如@GetMapping对应GET请求
相关属性	value（默认）：请求访问路径

代码实现

@RestController //@Controller + ReponseBody
@RequestMapping("/books")
public class BookController {
    
//@RequestMapping(method = RequestMethod.POST)
    @PostMapping
    public String save(@RequestBody Book book){
        System.out.println("book save..." + book);
        return "{'module':'book save'}";
    }

    //@RequestMapping(value = "/{id}",method = RequestMethod.DELETE)
    @DeleteMapping("/{id}")
    public String delete(@PathVariable Integer id){
        System.out.println("book delete..." + id);
        return "{'module':'book delete'}";
    }

    //@RequestMapping(method = RequestMethod.PUT)
    @PutMapping
    public String update(@RequestBody Book book){
        System.out.println("book update..." + book);
        return "{'module':'book update'}";
    }

    //@RequestMapping(value = "/{id}",method = RequestMethod.GET)
    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("book getById..." + id);
        return "{'module':'book getById'}";
    }

    //@RequestMapping(method = RequestMethod.GET)
    @GetMapping
    public String getAll(){
        System.out.println("book getAll...");
        return "{'module':'book getAll'}";
    }
    
}

RESTful案例

代码实现

① 编写Controller类并使用RESTful进行配置

@RestController
@RequestMapping("/books")
public class BookController {

    @PostMapping
    public String save(@RequestBody Book book){
        System.out.println("book save > "+ book);
        return "{'module':'book save success'}";
    }

 @GetMapping
    public List getAll(){
        System.out.println("book getAll is running ...");
        List bookList = new ArrayList();

        Book book1 = new Book();
        book1.setType("计算机");
        book1.setName("SpringMVC入门教程");
        book1.setDescription("小试牛刀");
        bookList.add(book1);

        Book book2 = new Book();
        book2.setType("计算机");
        book2.setName("SpringMVC实战教程");
        book2.setDescription("一代宗师");
        bookList.add(book2);

        Book book3 = new Book();
        book3.setType("计算机丛书");
        book3.setName("SpringMVC实战教程进阶");
        book3.setDescription("一代宗师呕心创作");
        bookList.add(book3);

        return bookList;
    }

}

页面访问处理

① 存在的问题

打开浏览器输入http://localhost/pages/books.html

② 解决方案

1). 出现错误的原因

2). 代码实现

SpringMVC需要将静态资源进行放行。

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    //设置静态资源访问过滤，当前类需要设置为配置类，并被扫描加载
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        //当访问/pages/????时候，从/pages目录下查找内容
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
        registry.addResourceHandler("/js/**").addResourceLocations("/js/");
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
        registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
    }
}

该配置类是在config目录下，SpringMVC扫描的是controller包，所以该配置类还未生效，要想生效需要将SpringMvcConfig配置类进行修改

@Configuration
@ComponentScan({"com.itheima.controller","com.itheima.config"})
@EnableWebMvc
public class SpringMvcConfig {
}

或者

@Configuration
@ComponentScan("com.itheima")
@EnableWebMvc
public class SpringMvcConfig {
}

修改books.html页面

        //添加
        saveBook () {
            axios.post("/books",this.formData).then((res)=>{

            });
        },

        //主页列表查询
        getAll() {
            axios.get("/books").then((res)=>{
                this.dataList = res.data;
            });
        },

    }
})

核心逻辑：

① axios.post("/books", this.formData)：

用 POST 方法向后端的 /books 接口发送请求。
把表单数据 this.formData（比如用户输入的书名、作者、价格等）作为请求体发送给后端。
对应后端的 @PostMapping("/books") 接口，用于 “创建新资源”。

② this.dataList = res.data：

请求成功后，后端会返回所有书籍的 JSON 数据（res.data）。
把这些数据赋值给前端的 dataList 数组，页面就会自动渲染出书籍列表。

SSM整合

整合配置

创建SpringConfig配置类

@Configuration
@ComponentScan({"com.itheima.service"})
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MyBatisConfig.class})
@EnableTransactionManagement
public class SpringConfig {
}

创建JdbcConfig配置类

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }

    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager ds = new DataSourceTransactionManager();
        ds.setDataSource(dataSource);
        return ds;
    }
}

创建MybatisConfig配置类

public class MyBatisConfig {
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        factoryBean.setTypeAliasesPackage("com.itheima.domain");
        return factoryBean;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}

创建JdbcConfig配置类

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }

    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager ds = new DataSourceTransactionManager();
        ds.setDataSource(dataSource);
        return ds;
    }
}

创建MybatisConfig配置类

public class MyBatisConfig {
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        factoryBean.setTypeAliasesPackage("com.itheima.domain");
        return factoryBean;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}

创建SpringMVC配置类

@Configuration
@ComponentScan("com.itheima.controller")
@EnableWebMvc
public class SpringMvcConfig {
}

创建Web项目入口配置类

public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    //加载Spring配置类
    protected Class[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }
    //加载SpringMVC配置类
    protected Class[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }
    //设置SpringMVC请求地址拦截规则
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
    //设置post请求中文乱码过滤器
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("utf-8");
        return new Filter[]{filter};
    }
}

功能模块开发

编写模型类

public class Book {
    private Integer id;
    private String type;
    private String name;
    private String description;
    //getter...setter...toString省略
}

编写Dao接口

public interface BookDao {

//    @Insert("insert into tbl_book values(null,#{type},#{name},#{description})")
    @Insert("insert into tbl_book (type,name,description) values(#{type},#{name},#{description})")
    public void save(Book book);

    @Update("update tbl_book set type = #{type}, name = #{name}, description = #{description} where id = #{id}")
    public void update(Book book);

    @Delete("delete from tbl_book where id = #{id}")
    public void delete(Integer id);

    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);

    @Select("select * from tbl_book")
    public List getAll();
}

编写Service接口和实现类

Service接口

@Transactional
public interface BookService {
    /**
     * 保存
     * @param book
     * @return
     */
    public boolean save(Book book);

    /**
     * 修改
     * @param book
     * @return
     */
    public boolean update(Book book);

    /**
     * 按id删除
     * @param id
     * @return
     */
    public boolean delete(Integer id);

    /**
     * 按id查询
     * @param id
     * @return
     */
    public Book getById(Integer id);

    /**
     * 查询全部
     * @return
     */
    public List getAll();
}

Service实现类

@Service
public class BookServiceImpl implements BookService {
    @Autowired
    private BookDao bookDao;

    public boolean save(Book book) {
        bookDao.save(book);
        return true;
    }

    public boolean update(Book book) {
        bookDao.update(book);
        return true;
    }

    public boolean delete(Integer id) {
        bookDao.delete(id);
        return true;
    }

    public Book getById(Integer id) {
        return bookDao.getById(id);
    }

    public List getAll() {
        return bookDao.getAll();
    }
}

编写Contorller类

@RestController
@RequestMapping("/books")
public class BookController {

    @Autowired
    private BookService bookService;

    @PostMapping
    public boolean save(@RequestBody Book book) {
        return bookService.save(book);
    }

    @PutMapping
    public boolean update(@RequestBody Book book) {
        return bookService.update(book);
    }

    @DeleteMapping("/{id}")
    public boolean delete(@PathVariable Integer id) {
        return bookService.delete(id);
    }

    @GetMapping("/{id}")
    public Book getById(@PathVariable Integer id) {
        return bookService.getById(id);
    }

    @GetMapping
    public List getAll() {
        return bookService.getAll();
    }
}

单元测试

新建测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class BookServiceTest {

}

注入Service类、编写测试方法

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class BookServiceTest {

    @Autowired
    private BookService bookService;

    @Test
    public void testGetById(){
        Book book = bookService.getById(1);
        System.out.println(book);
    }

    @Test
    public void testGetAll(){
        List all = bookService.getAll();
        System.out.println(all);
    }

}

统一结果封装

设置统一数据返回结果类

public class Result{
private Object data;
private Integer code;
private String msg;
}

**注意：**Result类名及类中的字段并不是固定的，可以根据需要自行增减提供若干个构造方法，方便操作。

表现层与前端数据传输协议实现

创建Result类

public class Result {
    //描述统一格式中的数据
    private Object data;
    //描述统一格式中的编码，用于区分操作，可以简化配置0或1表示成功失败
    private Integer code;
    //描述统一格式中的消息，可选属性
    private String msg;

    public Result() {
    }
//构造方法是方便对象的创建
    public Result(Integer code,Object data) {
        this.data = data;
        this.code = code;
    }
//构造方法是方便对象的创建
    public Result(Integer code, Object data, String msg) {
        this.data = data;
        this.code = code;
        this.msg = msg;
    }
//setter...getter...省略
}

定义返回码Code类

//状态码
public class Code {
    public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;

    public static final Integer SAVE_ERR = 20010;
    public static final Integer DELETE_ERR = 20020;
    public static final Integer UPDATE_ERR = 20030;
    public static final Integer GET_ERR = 20040;
}

修改Controller类的返回值

//统一每一个控制器方法返回值
@RestController
@RequestMapping("/books")
public class BookController {

    @Autowired
    private BookService bookService;

    @PostMapping
    public Result save(@RequestBody Book book) {
        boolean flag = bookService.save(book);
        return new Result(flag ? Code.SAVE_OK:Code.SAVE_ERR,flag);
    }

    @PutMapping
    public Result update(@RequestBody Book book) {
        boolean flag = bookService.update(book);
        return new Result(flag ? Code.UPDATE_OK:Code.UPDATE_ERR,flag);
    }

    @DeleteMapping("/{id}")
    public Result delete(@PathVariable Integer id) {
        boolean flag = bookService.delete(id);
        return new Result(flag ? Code.DELETE_OK:Code.DELETE_ERR,flag);
    }

    @GetMapping("/{id}")
    public Result getById(@PathVariable Integer id) {
        Book book = bookService.getById(id);
        Integer code = book != null ? Code.GET_OK : Code.GET_ERR;
        String msg = book != null ? "" : "数据查询失败，请重试！";
        return new Result(code,book,msg);
    }

    @GetMapping
    public Result getAll() {
        List bookList = bookService.getAll();
        Integer code = bookList != null ? Code.GET_OK : Code.GET_ERR;
        String msg = bookList != null ? "" : "数据查询失败，请重试！";
        return new Result(code,bookList,msg);
    }
}

核心逻辑：

① 如果 book 不为 null（查询成功）：code = Code.GET_OK，msg = ""

② 如果 book 为 null（查询失败）：code = Code.GET_ERR，msg = "数据查询失败，请重试！"

统一异常处理

异常处理器的使用

创建异常处理器类

//@RestControllerAdvice用于标识当前类为REST风格对应的异常处理器
@RestControllerAdvice
public class ProjectExceptionAdvice {
    //除了自定义的异常处理器，保留对Exception类型的异常处理，用于处理非预期的异常
    @ExceptionHandler(Exception.class)
    public Result doException(Exception ex){
      System.out.println("嘿嘿,异常你哪里跑！")
        return new Result(666,null,"嘿嘿,异常你哪里跑！");
    }
}

知识点

① @RestControllerAdvice

名称	@RestControllerAdvice
类型	类注解
位置	Rest风格开发的控制器增强类定义上方
作用	为Rest风格开发的控制器类做增强

② @ExceptionHandler

名称	@ExceptionHandler
类型	方法注解
位置	专用于异常处理的控制器方法上方
作用	设置指定异常的处理方案，功能等同于控制器方法，出现异常后终止原始控制器执行，并转入当前方法执行

项目异常处理方案

自定义异常类

//自定义异常处理器，用于封装异常信息，对异常进行分类
public class SystemException extends RuntimeException{
    private Integer code;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public SystemException(Integer code, String message) {
        super(message);
        this.code = code;
    }

    public SystemException(Integer code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
    }

}

//自定义异常处理器，用于封装异常信息，对异常进行分类
public class BusinessException extends RuntimeException{
    private Integer code;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public BusinessException(Integer code, String message) {
        super(message);
        this.code = code;
    }

    public BusinessException(Integer code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
    }

}

说明：

让自定义异常类继承RuntimeException的好处是，后期在抛出这两个异常的时候，就不用在try…catch…或throws了
自定义异常类中添加code属性的原因是为了更好的区分异常是来自哪个业务的

将其他异常包定义成自定义异常

假如在BookServiceImpl的getById方法抛异常了，该如何来包装呢?

public Book getById(Integer id) {
    //模拟业务异常，包装成自定义异常
    if(id == 1){
        throw new BusinessException(Code.BUSINESS_ERR,"请不要使用你的技术挑战我的耐性!");
    }
    //模拟系统异常，将可能出现的异常进行包装，转换成自定义异常
    try{
        int i = 1/0;
    }catch (Exception e){
        throw new SystemException(Code.SYSTEM_TIMEOUT_ERR,"服务器访问超时，请重试!",e);
    }
    return bookDao.getById(id);
}

处理器类中处理自定义异常

//@RestControllerAdvice用于标识当前类为REST风格对应的异常处理器
@RestControllerAdvice
public class ProjectExceptionAdvice {
    //@ExceptionHandler用于设置当前处理器类对应的异常类型
    @ExceptionHandler(SystemException.class)
    public Result doSystemException(SystemException ex){
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员,ex对象发送给开发人员
        return new Result(ex.getCode(),null,ex.getMessage());
    }

    @ExceptionHandler(BusinessException.class)
    public Result doBusinessException(BusinessException ex){
        return new Result(ex.getCode(),null,ex.getMessage());
    }

    //除了自定义的异常处理器，保留对Exception类型的异常处理，用于处理非预期的异常
    @ExceptionHandler(Exception.class)
    public Result doOtherException(Exception ex){
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员,ex对象发送给开发人员
        return new Result(Code.SYSTEM_UNKNOW_ERR,null,"系统繁忙，请稍后再试！");
    }
}

前后台协议联调

列表功能

getAll() {
    //发送ajax请求
    axios.get("/books").then((res)=>{
        this.dataList = res.data.data;
    });
}

添加功能

`handleCreate`打开新增面板

1
2
3

handleCreate() {
    this.dialogFormVisible = true;
},

`handleAdd`方法发送异步请求并携带数据

handleAdd () {
    //发送ajax请求
    //this.formData是表单中的数据，最后是一个json数据
    axios.post("/books",this.formData).then((res)=>{
        this.dialogFormVisible = false;
        this.getAll();
    });
}

添加功能状态处理

① 思路分析

新增成功是关闭面板，重新查询数据，那么新增失败以后该如何处理?

在handlerAdd方法中根据后台返回的数据来进行不同的处理
如果后台返回的是成功，则提示成功信息，并关闭面板
如果后台返回的是失败，则提示错误信息

② 代码实现

1). 修改前端页面

handleAdd () {
    //发送ajax请求
    axios.post("/books",this.formData).then((res)=>{
        //如果操作成功，关闭弹层，显示数据
        if(res.data.code == 20011){
            this.dialogFormVisible = false;
            this.$message.success("添加成功");
        }else if(res.data.code == 20010){
            this.$message.error("添加失败");
        }else{
            this.$message.error(res.data.msg);
        }
    }).finally(()=>{
        this.getAll();
    });
}

2). 后台返回操作结果，将Dao层的增删改方法返回值从void改成int

public interface BookDao {

    @Insert("insert into tbl_book (type,name,description) values(#{type},#{name},#{description})")
    public int save(Book book);

    @Update("update tbl_book set type = #{type}, name = #{name}, description = #{description} where id = #{id}")
    public int update(Book book);

    @Delete("delete from tbl_book where id = #{id}")
    public int delete(Integer id);

    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);

    @Select("select * from tbl_book")
    public List getAll();
}

说明：

在使用 MyBatis 这类框架时，insert、update、delete 这类增删改操作，本质上是在修改数据库的数据。框架本身会自动统计这些操作影响了多少行数据。

如果返回值是 void，上层代码（Service/Controller）就完全不知道这次数据库操作到底有没有真正执行成功，只能 “盲目相信” 它成功了。
如果返回值是 int，这个 int 就代表受影响的行数。比如返回 1 表示成功新增 / 修改 / 删除了 1 条记录，返回 0 就表示没有任何数据被操作（比如要删除的 ID 不存在）。

3). 处理完新增后，会发现新增还存在一个问题，新增成功后，再次点击新增按钮会发现之前的数据还存在，这个时候就需要在新增的时候将表单内容清空。

resetForm(){
this.formData = {};
}
handleCreate() {
    this.dialogFormVisible = true;
    this.resetForm();
}

修改功能

修改`handleUpdate`方法

//弹出编辑窗口
handleUpdate(row) {
    // console.log(row);   //row.id 查询条件
    //查询数据，根据id查询
    axios.get("/books/"+row.id).then((res)=>{
        if(res.data.code == 20041){
            //展示弹层，加载数据
            this.formData = res.data.data;
            this.dialogFormVisible4Edit = true;
        }else{
            this.$message.error(res.data.msg);
        }
    });
}

修改`handleEdit`方法

handleEdit() {
    //发送ajax请求
    axios.put("/books",this.formData).then((res)=>{
        //如果操作成功，关闭弹层，显示数据
        if(res.data.code == 20031){
            this.dialogFormVisible4Edit = false;
            this.$message.success("修改成功");
        }else if(res.data.code == 20030){
            this.$message.error("修改失败");
        }else{
            this.$message.error(res.data.msg);
        }
    }).finally(()=>{
        this.getAll();
    });
}

删除功能

修改handleDelete方法

handleDelete(row) {
    //1.弹出提示框
    this.$confirm("此操作永久删除当前数据，是否继续？","提示",{
        type:'info'
    }).then(()=>{
        //2.做删除业务
        axios.delete("/books/"+row.id).then((res)=>{
            if(res.data.code  20021){
                this.$message.success("删除成功");
            }else{
                this.$message.error("删除失败");
            }
        }).finally(()=>{
            this.getAll();
        });
    }).catch(()=>{
        //3.取消删除
        this.$message.info("取消删除操作");
    });
}

说明：

① $confirm 的作用：

第 1 个参数：对话框的提示内容，这里是 “此操作将永久删除当前数据，是否继续？”
第 2 个参数：对话框的标题，这里是 “提示”
第 3 个参数：配置对象，type: 'info' 表示对话框的类型为 “信息提示”

② $message 的作用

它是前端页面的 “反馈工具”，当用户完成某个操作（比如删除、修改、新增）后，用简洁的弹窗告诉用户 “操作成功 / 失败 / 已取消”，提升交互体验，让用户明确知道自己的操作有没有生效。

this.$confirm("此操作将永久删除当前数据，是否继续？", "提示", {
  type: 'info'
}).then(() => {
  axios.delete("/books/"+row.id).then(res => {
    if(res.data.code === 20021) {
      // 场景1：删除成功 → 绿色的成功提示
      this.$message.success("删除成功");
    } else {
      // 场景2：删除失败 → 红色的错误提示
      this.$message.error("删除失败");
    }
  }).finally(() => {
    this.getAll();
  });
}).catch(() => {
  // 场景3：用户取消删除 → 蓝色/灰色的信息提示
  this.$message.info("取消删除操作");
});

拦截器

拦截器入门案例

创建拦截器类

让类实现HandlerInterceptor接口，重写接口中的三个方法。

@Component
//定义拦截器类，实现HandlerInterceptor接口
//注意当前类必须受Spring容器控制
public class ProjectInterceptor implements HandlerInterceptor {
    @Override
    //原始方法调用前执行的内容
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle...");
        return true;
    }

    @Override
    //原始方法调用后执行的内容
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle...");
    }

    @Override
    //原始方法调用完成后执行的内容
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion...");
    }
}

**注意：**拦截器类要被SpringMVC容器扫描到。

配置拦截器类

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    @Autowired
    private ProjectInterceptor projectInterceptor;

    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
    }

    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        //配置拦截器
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books" );
    }
}

说明：

重写方法：配置静态资源映射

@Override
protected void addResourceHandlers(ResourceHandlerRegistry registry) {
    registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
}

这个方法的作用是：让 Spring MVC 能正确处理静态资源（HTML/CSS/JS/ 图片）。

addResourceHandler("/pages/**")：定义 URL 规则，所有以 /pages/ 开头的请求，都当作静态资源请求处理。
addResourceLocations("/pages/")：告诉 Spring，这些静态资源存放在服务器的 /pages/ 目录下

拦截器参数

前置处理方法

public boolean preHandle(HttpServletRequest request,
                         HttpServletResponse response,
                         Object handler) throws Exception {
    System.out.println("preHandle");
    return true;
}

request：请求对象
response：响应对象
handler：被调用的处理器对象，本质上是一个方法对象，对反射中的Method对象进行了再包装

使用request对象可以获取请求数据中的内容，如获取请求头的Content-Type

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    String contentType = request.getHeader("Content-Type");
    System.out.println("preHandle..."+contentType);
    return true;
}

SSM学习笔记之 Spring

2026-03-20T01:00:00.000Z

SSM学习笔记

Spring相关概念

Spring4 架构图

核心层

Core Container:核心容器，这个模块是Spring最核心的模块，其他的都需要依赖该模块

AOP层

AOP:面向切面编程，它依赖核心层容器，目的是在不改变原有代码的前提下对其进行功能增强
Aspects:AOP是思想,Aspects是对AOP思想的具体实现

数据层

Data Access:数据访问，Spring全家桶中有对数据访问的具体实现技术
Data Integration:数据集成，Spring支持整合其他的数据层解决方案，比如Mybatis
Transactions:事务，Spring中事务管理是Spring AOP的一个具体实现，也是后期学习的重点内容

Web层

这一层的内容将在SpringMVC框架具体学习

Test层

Spring主要整合了Junit来完成单元测试和集成测试

IoC、IoC容器、Bean、DI

什么是控制反转？

使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。

Spring和IoC之间的关系是什么呢?

Spring技术对IoC思想进行了实现
Spring提供了一个容器，称为IoC容器，用来充当IoC思想中的”外部”

IoC容器的作用以及内部存放的是什么?

IoC容器负责对象的创建、初始化等一系列工作，其中包含了数据层和业务层的类对象
被创建或被管理的对象在IoC容器中统称为Bean
IoC容器中放的就是一个个的Bean对象

DI（Dependency Injection）依赖注入

在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入

入门案例

IoC入门案例

关键步骤

① 在配置文件中完成bean的配置

    
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl"/>

beans>

核心逻辑：

① 为什么 class 类型指定的是实现类，不是接口？

直接原因：Spring IOC 容器的核心是创建对象实例，如果你把 class 指定为接口（比如com.itheima.dao.BookDao），Spring 容器在尝试创建对象时，会和上面的 Java 代码一样失败 —— 因为它无法实例化一个接口，最终会抛出类似Cannot instantiate interface com.itheima.dao.BookDao的异常。

从容器中获取对象进行方法调用

public class App {
    public static void main(String[] args) {
        //获取IoC容器
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); 
//        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
//        bookDao.save();
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();
    }
}

DI入门实例

关键步骤

修改配置完成注入

    
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>

    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        
        
        <property name="bookDao" ref="bookDao"/>
    bean>

beans>

注意：配置中的两个bookDao的含义是不一样的

1). name=”bookDao”中bookDao的作用是让Spring的IoC容器在获取到名称后，将首字母小写，前面加set找对应的setBookDao()方法进行对象注入

对应 BookServiceImpl 的代码：

public class BookServiceImpl implements BookService {
    // 👇 这里的变量名是 bookDao，所以 name 必须写 "bookDao"
    private BookDao bookDao;

    // 👇 setter方法名是 setBookDao，Spring 会自动匹配 "bookDao"（去掉set，首字母小写）
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

如果把类里的变量名改成 dao，setter 改成 setDao，那配置里的 name 必须改成 "dao"，否则 Spring 找不到要赋值的属性，会报错；
比如：private BookDao dao; + public void setDao(BookDao dao) → 配置要写成。

2). ref=”bookDao”中bookDao的作用是让Spring能在IoC容器中找到id为bookDao的Bean对象给bookService进行注入

IoC相关内容

bean基础配置

bean基础配置(id与class)

bean的name属性

① 代码实现

步骤1：配置别名

打开spring的配置文件applicationContext.xml

    
    <bean id="bookService" name="service service4 bookEbi" class="com.itheima.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
    bean>

    
    <bean id="bookDao" name="dao" class="com.itheima.dao.impl.BookDaoImpl"/>
beans>

步骤2：根据名称容器中获取bean对象

public class AppForName {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //此处根据bean标签的id属性和name属性的任意一个值来获取bean对象
        BookService bookService = (BookService) ctx.getBean("service4");
        bookService.save();
    }
}

bean作用范围scope配置

代码实现

1). 单例

1	<bean id="bookDao" name="dao" class="com.itheima.dao.impl.BookDaoImpl" scope="singleton"/>

2). 非单例

1	<bean id="bookDao" name="dao" class="com.itheima.dao.impl.BookDaoImpl" scope="prototype"/>

bean实例化

构造方法实例化

① 编写运行程序

public class AppForInstanceBook {
    public static void main(String[] args) {
        ApplicationContext ctx = new 
            ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();

    }
}

② BookDaoImpl

在BookDaoImpl类中添加一个无参构造函数，并打印一句话，方便观察结果。

public class BookDaoImpl implements BookDao {
    public BookDaoImpl() {
        System.out.println("book dao constructor is running ....");
    }
    public void save() {
        System.out.println("book dao save ...");
    }

}

无参构造方法是在执行 new ClassPathXmlApplicationContext("applicationContext.xml") 这行代码时被 Spring 调用的

第一步：执行new ClassPathXmlApplicationContext(...)时，Spring 会做这些事：

解析applicationContext.xml，找到这个配置；
通过反射获取BookDaoImpl的 Class 对象；
调用BookDaoImpl的无参构造方法创建实例（这就是 “构造方法实例化” 的核心步骤）；
把创建好的实例存入容器，等待后续获取。✅ 这一步，你写在BookDaoImpl无参构造里的System.out.println("book dao constructor is running ....")就会执行 —— 控制台打印这句话，就是无参构造被调用的铁证。

第二步：执行ctx.getBean("bookDao")

Spring 从自己的 “对象仓库” 里，找到id=bookDao的对象（就是刚才创建好的BookDaoImpl实例），把它返回给你。

第三步：执行bookDao.save()

调用这个对象的save()方法，控制台打印：book dao save ...。

静态工厂实例化（了解即可）

① 准备一个OrderDao和OrderDaoImpl类

public interface OrderDao {
    public void save();
}

public class OrderDaoImpl implements OrderDao {
    public void save() {
        System.out.println("order dao save ...");
    }
}

② 创建一个工厂类OrderDaoFactory并提供一个静态方法

//静态工厂创建对象
public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        return new OrderDaoImpl();
    }
}

③ 编写AppForInstanceOrder运行类，在类中通过工厂获取对象

public class AppForInstanceOrder {
    public static void main(String[] args) {
        //通过静态工厂创建对象
        OrderDao orderDao = OrderDaoFactory.getOrderDao();
        orderDao.save();
    }
}

④ 在spring的配置文件中添加以下内容

1	<bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>

1). 关键部分解析：

**class：**工厂类的类全名

**factory-mehod：**具体工厂类中创建对象的方法名

2). 对应关系如下图：

⑤ 在AppForInstanceOrder运行类，使用从IoC容器中获取bean的方法进行运行测试

public class AppForInstanceOrder {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");

        orderDao.save();

    }
}

Spring 加载OrderDaoFactory类（无需创建工厂类实例，因为方法是静态的）；
调用OrderDaoFactory.getOrderDao()静态方法；
将方法返回的OrderDaoImpl实例存入容器，标识为orderDao；
后续ctx.getBean("orderDao")获取的就是这个实例。

实例工厂与FactoryBean

① 准备一个UserDao和UserDaoImpl类

public interface UserDao {
    public void save();
}

public class UserDaoImpl implements UserDao {

    public void save() {
        System.out.println("user dao save ...");
    }
}

② 创建一个工厂类OrderDaoFactory并提供一个普通方法，注意此处和静态工厂的工厂类不一样的地方是方法，关键在于此处不是静态方法

public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

③ 编写AppForInstanceUser运行类，在类中通过工厂获取对象

public class AppForInstanceUser {
    public static void main(String[] args) {
        //创建实例工厂对象
        UserDaoFactory userDaoFactory = new UserDaoFactory();
        //通过实例工厂对象创建对象
        UserDao userDao = userDaoFactory.getUserDao();
        userDao.save();
}

④ 在spring的配置文件中添加以下内容

1 2	<bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/> <bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>

实例化工厂运行的顺序是:

创建实例化工厂对象,对应的是第一行配置
调用对象中的方法来创建bean，对应的是第二行配置
- factory-bean：工厂的实例对象
- factory-method：工厂对象中的具体创建对象的方法名,对应关系如下:

FactoryBean的使用（重要）

① 创建一个UserDaoFactoryBean的类，实现FactoryBean接口，重写接口的方法

public class UserDaoFactoryBean implements FactoryBean {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }
    //返回所创建类的Class对象
    public Class getObjectType() {
        return UserDao.class;
    }
}

② 在Spring的配置文件中进行配置

1	<bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>

bean的生命周期

思路分析

bean创建之后，想要添加内容，比如用来初始化需要用到资源
bean销毁之前，想要添加内容，比如用来释放用到的资源

代码实现

① 添加初始化和销毁方法

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
    //表示bean初始化对应的操作
    public void init(){
        System.out.println("init...");
    }
    //表示bean销毁前对应的操作
    public void destory(){
        System.out.println("destory...");
    }
}

② 配置生命周期

1	<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destory-method="destory"/>

Spring 创建bookDao这个 Bean 实例后，会自动调用BookDaoImpl类中名为init的方法（初始化逻辑）；当 Spring 容器关闭、销毁bookDao实例前，会自动调用类中名为destroy的方法（销毁 / 清理逻辑）。

③ close关闭容器

1 2	ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

DI相关内容

setter注入

注入简单数据类型

需求：给BookDaoImpl注入一些简单数据类型的数据

在BookDaoImpl类中声明对应的简单数据类型的属性
为这些属性提供对应的setter方法
在applicationContext.xml中配置

① 声明属性并提供setter方法

public class BookDaoImpl implements BookDao {

    private String databaseName;
    private int connectionNum;

    public void setConnectionNum(int connectionNum) {
        this.connectionNum = connectionNum;
    }

    public void setDatabaseName(String databaseName) {
        this.databaseName = databaseName;
    }

    public void save() {
        System.out.println("book dao save ..."+databaseName+","+connectionNum);
    }
}

② 配置文件中进行注入配置

    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <property name="databaseName" value="mysql"/>
     <property name="connectionNum" value="10"/>
    bean>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
        <property name="userDao" ref="userDao"/>
    bean>
beans>

对于引用数据类型使用的是
对于简单数据类型使用的是

构造器注入引用数据类型

(1) 思路分析

将bookDao的setter方法删除掉
添加带有bookDao参数的构造方法
在applicationContext.xml中配置

(2) 代码实现

① 删除setter方法并提供构造方法

原来的 BookServiceImpl

public class BookServiceImpl implements BookService {
    private BookDao bookDao;

    // 原来的 setter 方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

现在改成构造方法注入后：

public class BookServiceImpl implements BookService{
    private BookDao bookDao;

    public BookServiceImpl(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

**核心逻辑：**这个构造方法怪怪的，返回值是什么，方法名又是什么？

1
2
3

public BookServiceImpl(BookDao bookDao) {
    this.bookDao = bookDao;
}

构造方法和普通方法的核心区别

特征	普通方法（比如 setter 方法）	构造方法（你问的这段代码）
方法名	任意（通常 set/get 开头）	必须和类名完全一致
返回值类型	必须声明（void/int/String 等）	不能声明任何返回值（连 void 都不能写）
作用	执行特定功能（比如赋值）	创建对象时初始化对象
调用方式	对象创建后手动调用（obj.setXxx ()）	由 JVM 自动调用（new）

逐行解释：

方法名 BookServiceImpl：必须和类名完全一致（你的类名就是 BookServiceImpl），这是构造方法的 “身份标识”，少一个字母、大小写不一样都不行。
没有返回值类型：你看不到 void、int 等返回值声明，这是构造方法的强制规则 —— 因为构造方法的 “返回值” 是创建好的当前类对象，这个返回值由 JVM 自动处理，不需要你手动写。比如你写 new BookServiceImpl(bookDao) 时，JVM 会执行这个构造方法，然后自动返回一个 BookServiceImpl 类型的对象，你不用管返回值的声明。

② 配置文件中进行配置构造方式注入

    "bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
    "bookService" class="com.itheima.service.impl.BookServiceImpl">
        "bookDao" ref="bookDao"/>

**核心逻辑：**内层标签

这是构造方法注入的关键，专门用来 “给构造方法传参数”：

name="bookDao"：指定要传给构造方法的参数名（对应你之前写的 public BookServiceImpl(BookDao bookDao) 里的 bookDao 参数）；
ref="bookDao"：指定参数的值—— 这里的 ref 是 “引用” 的意思，告诉 Spring：“这个参数的值，不是新造的，而是去我的对象仓库里找那个名字叫 bookDao 的对象”。

Spring 启动后，会按顺序执行配置里的指令：

1. 执行：

调用 BookDaoImpl 的无参构造（如果没写，编译器会默认生成），创建 BookDaoImpl 对象；
把这个对象存到容器里，标记为 “id=bookDao”。

2. 执行：

先看里面有，知道要调用 BookServiceImpl 的带参构造方法；
去容器里找到 “id=bookDao” 的那个对象（就是第一步造的）；
调用 new BookServiceImpl(bookDao) 创建 BookServiceImpl 对象；
把这个对象存到容器里，标记为 “id=bookService”。

构造器注入多个简单数据类型

思路分析

提供一个包含这两个参数的构造方法
在applicationContext.xml中进行注入配置

代码实现

① 提供多个属性的构造函数

public class BookDaoImpl implements BookDao {
    private String databaseName;
    private int connectionNum;

    public BookDaoImpl(String databaseName, int connectionNum) {
        this.databaseName = databaseName;
        this.connectionNum = connectionNum;
    }

    public void save() {
        System.out.println("book dao save ..."+databaseName+","+connectionNum);
    }
}

② 在applicationContext.xml中配置注入

    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <constructor-arg name="databaseName" value="mysql"/>
        <constructor-arg name="connectionNum" value="666"/>
    bean>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="userDao" ref="userDao"/>
    bean>
beans>

为什么构造器一定是强制依赖的，setter 不是（重点）

setter 有参但不用传参：本质是 “我压根不调用这个方法”

setter 方法（比如 setBookDao(BookDao bookDao)）的参数规则是：如果调用这个方法，就必须传 BookDao 参数；但我可以选择不调用这个方法。

public class BookServiceImpl implements BookService {
    private BookDao bookDao; // 初始值为 null

    // 有参的 setter 方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public void save() {
        bookDao.save(); // 没调用 setter 的话，这里会空指针
    }

    // 测试代码
    public static void main(String[] args) {
        // 1. 创建对象：调用无参构造，完全不用管 setter
        BookServiceImpl service = new BookServiceImpl();
        
        // 2. 可选操作：我可以调用 setter（传参），也可以不调用（不传参）
        // service.setBookDao(new BookDaoImpl()); // 注释掉=不传参、不调用
        
        // 3. 运行方法：没调 setter 的话，bookDao 是 null，运行时报错
        service.save();
    }
}

区分：

setter 方法和构造方法是两码事：setter 是用来给成员变量赋值的普通方法（要声明返回值），构造方法是用来创建对象的特殊方法（不用声明返回值）

构造器有参就必须传参 —— 因为 “创建对象必须调用构造器”

public class BookServiceImpl implements BookService {
    private BookDao bookDao;

    // 有参的构造器
    public BookServiceImpl(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    // 测试代码
    public static void main(String[] args) {
        // 编译报错！因为创建对象必须调用构造器，而构造器要求传 BookDao 参数
        BookServiceImpl service = new BookServiceImpl(); 
    }
}

这里的关键是：创建对象的动作（new）和构造器的调用是绑定的 —— 只要 new 对象，就必须调构造器，构造器要参数就必须传，躲不开；而 setter 是 new 完对象之后的 “额外动作”，调不调全看你。

自动装配（了解即可）

代码实现

项目中添加BookDao、BookDaoImpl、BookService和BookServiceImpl类

public interface BookDao {
    public void save();
}

public class BookDaoImpl implements BookDao {
    
    private String databaseName;
    private int connectionNum;
    
    public void save() {
        System.out.println("book dao save ...");
    }
}
public interface BookService {
    public void save();
}

public class BookServiceImpl implements BookService{
    private BookDao bookDao;

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

resources下提供spring的配置文件

    <bean class="com.itheima.dao.impl.BookDaoImpl"/>
    
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>

beans>

**核心逻辑：**按类型（byType）自动装配时，Spring 匹配的 “类型” 是什么

① 先找到 “要注入的成员变量”，在 BookServiceImpl 类里，有一个需要注入的成员变量：

public class BookServiceImpl implements BookService {
    // 这个成员变量的类型是 BookDao
    private BookDao bookDao; 

    // 必须有 setter 方法（自动装配 byType/byName 都依赖 setter）
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

这里的关键是：成员变量 bookDao 声明的类型是 BookDao（接口），这就是 Spring 要去匹配的 “目标类型”。

② Spring 会做这几件事：

检查 BookServiceImpl 里所有需要注入的成员变量（这里就是 bookDao）。
拿到它的类型：BookDao。
去整个 IoC 容器里，找所有类型是 BookDao 或其子类 / 实现类的 bean。
如果找到恰好 1 个，就自动调用 setBookDao() 把它注入进去；
如果找到 0 个或多个，就报错（0 个注入失败，多个报 NoUniqueBeanDefinitionException）。

集合注入（了解即可）

代码实现

注入数组类型数据

<property name="array">
    <array>
        <value>100value>
        <value>200value>
        <value>300value>
    array>
property>

注入List类型数据

<property name="list">
    <list>
        <value>itcastvalue>
        <value>itheimavalue>
        <value>boxueguvalue>
        <value>chuanzhihuivalue>
    list>
property>

注入Map类型数据

<property name="map">
    <map>
        <entry key="country" value="china"/>
        <entry key="province" value="henan"/>
        <entry key="city" value="kaifeng"/>
    map>
property>

注入Properties类型数据

<property name="properties">
    <props>
        <prop key="country">chinaprop>
        <prop key="province">henanprop>
        <prop key="city">kaifengprop>
    props>
property>

IoC / DI 配置管理第三方bean

思路分析

(1) 使用第三方的技术，需要在pom.xml添加依赖

(2) 在配置文件中将【第三方的类】制作成一个bean，让IoC容器进行管理

(3) 数据库连接需要基础的四要素驱动、连接、用户名和密码，【如何注入】到对应的bean中

(4) 从IoC容器中获取对应的bean对象，将其打印到控制台查看结果

代码实现

导入`druid`的依赖

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>druidartifactId>
    <version>1.1.16version>
dependency>

配置第三方bean


    <bean class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/spring_db"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    bean>
beans>

说明：

driverClassName:数据库驱动
url:数据库连接地址
username:数据库连接用户名
password:数据库连接密码
数据库连接的四要素要和自己使用的数据库信息一致。

加载properties文件

思路分析

① 在resources下创建一个jdbc.properties(文件的名称可以任意)

② 将数据库连接四要素配置到配置文件中

③ 在Spring的配置文件中加载properties文件

④ 使用加载到的值实现属性注入

其中第3，4步骤是需要大家重点关注，具体是如何实现。

代码实现

① 准备properties配置文件

resources下创建一个jdbc.properties文件,并添加对应的属性键值对

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db
jdbc.username=root
jdbc.password=root

② 开启context命名空间

"1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
beans>

③ 加载properties配置文件

在配置文件中使用context命名空间下的标签来加载properties配置文件

1	<context:property-placeholder location="jdbc.properties"/>

④ 完成属性注入

    <context:property-placeholder location="jdbc.properties"/>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    bean>
beans>

读取单个属性

思路分析

① 在项目中添加BookDao和BookDaoImpl类

② 为BookDaoImpl添加一个name属性并提供setter方法

③ 在jdbc.properties中添加数据注入到bookDao中打印方便查询结果

④ 在applicationContext.xml添加配置完成配置文件加载、属性注入(${key})

代码实现

① 在项目中添对应的类

BookDao和BookDaoImpl类，并在BookDaoImpl类中添加name属性与setter方法

public interface BookDao {
    public void save();
}

public class BookDaoImpl implements BookDao {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public void save() {
        System.out.println("book dao save ..." + name);
    }
}

② 完成配置文件的读取与注入

    <context:property-placeholder location="jdbc.properties"/>
    
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <property name="name" value="${jdbc.driver}"/>
    bean>
beans>

当有多个properties配置文件需要被加载，该如何配置?

    
    <context:property-placeholder location="jdbc.properties,jdbc2.properties" system-properties-mode="NEVER"/>
    
    <context:property-placeholder location="*.properties" system-properties-mode="NEVER"/>
    
    <context:property-placeholder location="classpath:*.properties" system-properties-mode="NEVER"/>
    
    <context:property-placeholder location="classpath*:*.properties" system-properties-mode="NEVER"/>
beans>

说明：

方式一：可以实现，如果配置文件多的话，每个都需要配置
方式二：*.properties代表所有以properties结尾的文件都会被加载，可以解决方式一的问题，但是不标准
方式三：标准的写法，classpath:代表的是从根路径下开始查找，但是只能查询当前项目的根路径
方式四：不仅可以加载当前项目还可以加载当前项目所依赖的所有项目的根路径下的properties配置文件

核心容器

Bean的三种获取方式

方式一：

1	BookDao bookDao = (BookDao) ctx.getBean("bookDao");

这种方式存在的问题是每次获取的时候都需要进行类型转换

方式二：

1	BookDao bookDao = ctx.getBean("bookDao"，BookDao.class);

这种方式可以解决类型强转问题，但是参数又多加了一个，相对来说没有简化多少。

方式三：

1	BookDao bookDao = ctx.getBean(BookDao.class);

这种方式就类似我们之前所学习依赖注入中的按类型注入。必须要确保IoC容器中该类型对应的bean对象只能有一个。

BeanFactory的使用（了解即可）

使用BeanFactory来创建IoC容器的具体实现方式为

public class AppForBeanFactory {
    public static void main(String[] args) {
        Resource resources = new ClassPathResource("applicationContext.xml");
        BeanFactory bf = new XmlBeanFactory(resources);
        BookDao bookDao = bf.getBean(BookDao.class);
        bookDao.save();
    }
}

BeanFactory 和 ApplicationContext 之间的区别

BeanFactory是延迟加载，只有在获取bean对象的时候才会去创建
ApplicationContext是立即加载，容器加载的时候就会创建bean对象
ApplicationContext要想成为延迟加载，只需要按照如下方式进行配置

1 2	<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" lazy-init="true"/> beans>

IOC / DI 注解开发

注解开发定义bean

代码实现

① 删除原XML配置

1	<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>

② Dao上添加注解

在BookDaoImpl类上添加@Component注解

@Component("bookDao")
public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ..." );
    }
}

注意：@Component注解不可以添加在接口上，因为接口是无法创建对象的。

XML与注解配置的对应关系：

③ 配置Spring的注解包扫描

为了让Spring框架能够扫描到写在类上的注解，需要在配置文件上进行包扫描

1 2	<context:component-scan base-package="com.itheima"/> beans>

说明：

component-scan

component：组件，Spring将管理的bean视作自己的一个组件
scan：扫描

base-package指定Spring框架扫描的包路径，它会扫描指定包及其子包中的所有类上的注解。

包路径越多[如:com.itheima.dao.impl]，扫描的范围越小速度越快
包路径越少[如:com.itheima]，扫描的范围越大速度越慢
一般扫描到项目的组织名称即Maven的groupId下[如:com.itheima]即可。

④ *Service上添加注解*

在BookServiceImpl类上也添加@Component交给Spring框架管理

@Component
public class BookServiceImpl implements BookService {
    private BookDao bookDao;

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

@Component 及其衍生注解

名称	@Component/@Controller/@Service/@Repository
类型	类注解
位置	类定义上方
作用	设置该类为spring管理的bean
属性	value（默认）：定义bean的id

纯注解开发模式

思路分析

将配置文件applicationContext.xml删除掉，使用类来替换。

代码实现

① 创建配置类

创建一个配置类SpringConfig

1 2	public class SpringConfig { }

② *标识该类为配置类*

在配置类上添加@Configuration注解，将其标识为一个配置类,替换applicationContext.xml

1
2
3

@Configuration
public class SpringConfig {
}

③ 用注解替换包扫描配置

在配置类上添加包扫描注解@ComponentScan替换

@Configuration
@ComponentScan("com.itheima")
public class SpringConfig {
}

④ 创建运行类并执行

public class AppForAnnotation {

    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        System.out.println(bookDao);
        BookService bookService = ctx.getBean(BookService.class);
        System.out.println(bookService);
    }
}

执行流程

① 配置类的作用（替代 xml 文件）

@Configuration
@ComponentScan("com.itheima")
public class SpringConfig {
}

@Configuration注解：相当于给这个类贴上 “Spring 核心配置文件” 的标签，告诉 Spring 框架：“这个类不是普通的 Java 类，它是用来替代原来的 applicationContext.xml 的配置类”
@ComponentScan("com.itheima")注解：告诉 Spring“去com.itheima这个包（包括子包）里找所有带@Component/@Service/@Repository的类”

② 运行类的执行流程（核心）

public class AppForAnnotation {
    public static void main(String[] args) {
        // 1. 初始化Spring容器，加载配置类
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        // 2. 从容器中获取BookDao对象
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        System.out.println(bookDao);
        // 3. 从容器中获取BookService对象
        BookService bookService = ctx.getBean(BookService.class);
        System.out.println(bookService);
    }
}

逐行拆解执行逻辑：

1	ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

第一步：识别SpringConfig类上的@Configuration注解，确认这是核心配置类；
第二步：读取@ComponentScan("com.itheima")，去指定包下扫描所有带注解的类（比如BookDao带@Repository、BookService带@Service）；
第三步：自动创建这些类的实例（对象），并把对象存入 Spring 的 “容器”（ApplicationContext）中管理

@Configuration、@ComponentScan

知识点1：@Configuration

名称	@Configuration
类型	类注解
位置	类定义上方
作用	设置该类为spring配置类
属性	value（默认）：定义bean的id

知识点2：@ComponentScan

名称	@ComponentScan
类型	类注解
位置	类定义上方
作用	设置spring配置类扫描路径，用于加载使用注解格式定义的bean
属性	value（默认）：扫描路径，此路径可以逐层向下扫描

注解开发依赖注入

注解实现按照名称注入

(1) 当根据类型在容器中找到多个bean,注入参数的属性名又和容器中bean的名称不一致，这个时候该如何解决，就需要使用到@Qualifier来指定注入哪个名称的bean对象。

@Service
public class BookServiceImpl implements BookService {
    @Autowired
    @Qualifier("bookDao1")
    private BookDao bookDao;
    
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

@Qualifier注解后的值就是需要注入的bean的名称。

注意：@Qualifier不能独立使用，必须和@Autowired一起使用

简单数据类型注入

使用`@Value`注解，将值写入注解的参数中

@Repository("bookDao")
public class BookDaoImpl implements BookDao {
    @Value("itheima")
    private String name;
    public void save() {
        System.out.println("book dao save ..." + name);
    }
}

注解读取properties配置文件

@Value一般会被用在从properties配置文件中读取内容进行使用

① resource下准备properties文件

jdbc.properties

1	name=itheima888

② 使用注解加载properties配置文件

在配置类上添加@PropertySource注解

@Configuration
@ComponentScan("com.itheima")
@PropertySource("jdbc.properties")
public class SpringConfig {
}

③ 使用@Value读取配置文件中的内容

@Repository("bookDao")
public class BookDaoImpl implements BookDao {
    @Value("${name}")
    private String name;
    public void save() {
        System.out.println("book dao save ..." + name);
    }
}

注册开发管理第三方bean

注解开发管理第三方bean

代码实现

① 在配置类中添加一个方法（后续里面的数据库信息会用另外一个类承接）

注意该方法的返回值就是要创建的Bean对象类型

@Configuration
public class SpringConfig {
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
        ds.setUsername("root");
        ds.setPassword("root");
        return ds;
    }
}

DataSource 是 javax.sql 包下的一个接口，它是 Java 官方定义的 “数据源” 标准规范，核心作用是：

统一管理数据库连接（替代传统的 DriverManager）
支持连接池技术，复用数据库连接，提升性能

② 在方法上添加@Bean注解

@Bean注解的作用是将方法的返回值制作为Spring管理的一个bean对象

@Configuration
public class SpringConfig {
@Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
        ds.setUsername("root");
        ds.setPassword("root");
        return ds;
    }
}

引入外部配置类

使用`@Import`引入

这种方案可以不用加@Configuration注解，但是必须在Spring配置类上使用@Import注解手动引入需要

加载的配置类

① 去除JdbcConfig类上的注解

public class JdbcConfig {
@Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
        ds.setUsername("root");
        ds.setPassword("root");
        return ds;
    }
}

② 在Spring配置类中引入

@Configuration
//@ComponentScan("com.itheima.config")
@Import({JdbcConfig.class})
public class SpringConfig {

}

注解开发实现为第三方bean注入资源

简单数据类型

代码实现

① 类中提供四个属性

public class JdbcConfig {
    private String driver;
    private String url;
    private String userName;
    private String password;
@Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
        ds.setUsername("root");
        ds.setPassword("root");
        return ds;
    }
}

② 使用@Value注解引入值

public class JdbcConfig {
    @Value("com.mysql.jdbc.Driver")
    private String driver;
    @Value("jdbc:mysql://localhost:3306/spring_db")
    private String url;
    @Value("root")
    private String userName;
    @Value("password")
    private String password;
@Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

引用数据类型

需求分析

假设在构建DataSource对象的时候，需要用到BookDao对象，该如何把BookDao对象注入进方法内让其使用呢?

代码实现

① 在SpringConfig中扫描BookDao

扫描的目的是让Spring能管理到BookDao,也就是说要让IoC容器中有一个bookDao对象

@Configuration
@ComponentScan("com.itheima.dao")
@Import({JdbcConfig.class})
public class SpringConfig {
}

② 在JdbcConfig类的方法上添加参数

@Bean
public DataSource dataSource(BookDao bookDao){
    System.out.println(bookDao);
    DruidDataSource ds = new DruidDataSource();
    ds.setDriverClassName(driver);
    ds.setUrl(url);
    ds.setUsername(userName);
    ds.setPassword(password);
    return ds;
}

执行流程

① 识别 SpringConfig 上的 @Configuration，确认这是主配置。

② 执行 @ComponentScan("com.itheima.dao")：

去 com.itheima.dao 包下扫描，找到 BookDaoImpl（它上面有 @Repository 或 @Component 注解）。
自动创建 BookDaoImpl 对象，作为 bookDao Bean 存入 IoC 容器。

③ 执行 @Import(JdbcConfig.class)：

主动加载 JdbcConfig 类，准备解析它里面的 @Bean 方法。

④ Spring 发现这个方法需要一个 BookDao 类型的参数。

⑤ 它会去 IoC 容器中查找：“有没有类型为 BookDao 的 Bean？”找到之前扫描创建的 bookDao 对象，确认可以作为参数传入。

Spring 整合 MyBatis

代码实现

创建Spring的主配置类

//配置类注解
@Configuration
//包扫描，主要扫描的是项目中的AccountServiceImpl类
@ComponentScan("com.itheima")
public class SpringConfig {
}

创建数据源的配置类

在配置类中完成数据源的创建

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

主配置类中读properties并引入数据源配置类

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import(JdbcConfig.class)
public class SpringConfig {
}

创建Mybatis配置类并配置SqlSessionFactory

public class MybatisConfig {
    //定义bean，SqlSessionFactoryBean，用于产生SqlSessionFactory对象
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        //设置模型类的别名扫描
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        //设置数据源
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
    //定义bean，返回MapperScannerConfigurer对象
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}

说明：

① 使用SqlSessionFactoryBean封装SqlSessionFactory需要的环境信息

图里的代码，其实就是把 XML 配置里的关键部分 “翻译” 成了 Java 方法调用：

原生 MyBatis XML 配置	Spring Java 配置 (SqlSessionFactoryBean)	作用
	`setTypeAliasesPackage("com.itheima.domain")`	为实体类设置别名，简化 SQL 映射文件中的类名书写
	`setDataSource(dataSource)`	注入数据源，MyBatis 用它来建立数据库连接

② 为什么 dataSource 参数不用自己 new？

这是 Spring 的依赖注入（DI）特性在起作用：

你的项目里肯定已经配置了一个 Druid 数据源（DruidDataSource），并且它已经被注册成了一个 Spring Bean。
当 Spring 初始化 sqlSessionFactory() 这个方法时，发现它需要一个 DataSource 类型的参数，就会自动在容器里寻找一个符合类型的 Bean（也就是你的 Druid 数据源），并自动注入进来。

③ 使用MapperScannerConfigurer加载Dao接口，创建代理对象保存到IoC容器中

主配置类中引入Mybatis配置类

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}

执行流程

执行`new AnnotationConfigApplicationContext(SpringConfig.class)`时，Spring 开始启动：

@ComponentScan("com.itheima")：扫描指定包下所有带@Service/@Repository等注解的类，准备创建 Bean；
@PropertySource("classpath:jdbc.properties")：加载数据库配置文件，读取jdbc.driver/url等配置项；
@Import(...)：导入数据源配置类（JdbcConfig）和 MyBatis 配置类（MybatisConfig），触发这两个类的解析。

Spring 整合 Junit

代码实现

编写测试类

在test \ java下创建一个AccountServiceTest

//设置类运行器
@RunWith(SpringJUnit4ClassRunner.class)
//设置Spring环境对应的配置类
@ContextConfiguration(classes = {SpringConfiguration.class}) //加载配置类
//@ContextConfiguration(locations={"classpath:applicationContext.xml"})//加载配置文件
public class AccountServiceTest {
    //支持自动装配注入bean
    @Autowired
    private AccountService accountService;
    @Test
    public void testFindById(){
        System.out.println(accountService.findById(1));

    }
    @Test
    public void testFindAll(){
        System.out.println(accountService.findAll());
    }
}

核心逻辑：

① @RunWith(SpringJUnit4ClassRunner.class)

作用：指定用 Spring 提供的专用类运行器来执行测试。
为什么需要它：
- 普通的 JUnit 运行器只会执行你的测试方法，不会启动 Spring 容器。
- 这个特殊的运行器会先启动 Spring 容器，然后再运行你的测试方法，这样 Spring 的所有功能（如@Autowired）才能生效。

② @ContextConfiguration(classes = {SpringConfiguration.class})

作用：告诉 Spring 容器，应该加载哪些配置来创建 Bean。
classes：如果你的配置是用 Java 类写的（比如@Configuration注解的类），就用这个属性，指定配置类。
locations：如果你的配置是用 XML 文件写的（比如applicationContext.xml），就用这个属性，指定 XML 文件路径。

知识点

@RunWith

名称	@RunWith
类型	测试类注解
位置	测试类定义上方
作用	设置JUnit运行器
属性	value（默认）：运行所使用的运行期

@ContextConfiguration

名称	@ContextConfiguration
类型	测试类注解
位置	测试类定义上方
作用	设置JUnit加载的Spring核心配置
属性	classes：核心配置类，可以使用数组的格式设定加载多个配置类 locations:配置文件，可以使用数组的格式设定加载多个配置文件名称

AOP 核心概念

连接点

程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等。在SpringAOP中，理解为方法的执行，可以直接理解成所有的方法

切入点

匹配连接点的式子，在SpringAOP中，一个切入点可以描述一个具体方法，也可也匹配多个方法。

连接点范围要比切入点范围大，是切入点的方法也一定是连接点，但是是连接点的方法就不一定要被增强，所以可能不是切入点。

通知

在切入点处执行的操作，也就是共性功能。在SpringAOP中，功能最终以方法的形式呈现

通知类

定义通知的类

切面

描述通知与切入点的对应关系。

AOP 入门案例

代码实现

定义通知类和通知

public class MyAdvice {
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

定义切入点

public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

切入点定义依托一个**不具有实际意义的方法进行，**即无参数、无返回值、方法体无实际逻辑。

制作切面

public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    
    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

绑定切入点与通知关系，并指定通知添加到原始连接点的具体执行位置

说明：@Before翻译过来是之前，也就是说通知会在切入点方法执行之前执行

将通知类配给容器并标识其为切面类

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    
    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

开启注解格式AOP功能

@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy
public class SpringConfig {
}

知识点

@EnableAspectJAutoProxy

名称	@EnableAspectJAutoProxy
类型	配置类注解
位置	配置类定义上方
作用	开启注解格式AOP功能

@Aspect

名称	@Aspect
类型	类注解
位置	切面类定义上方
作用	设置当前类为AOP切面类

@Pointcut

名称	@Pointcut
类型	方法注解
位置	切入点方法定义上方
作用	设置切入点方法
属性	value（默认）：切入点表达式

AOP 配置管理

切入点表达式

语法格式

execution(访问修饰符返回值包名.类/接口名.方法名(参数) 异常名）

示例

1	execution(public User com.itheima.service.UserService.findById(int))

execution：动作关键字，描述切入点的行为动作，例如execution表示执行到指定切入点
public：访问修饰符,还可以是public，private等，可以省略
User：返回值，写返回值类型
com.itheima.service：包名，多级包使用点连接
UserService：类/接口名称
findById：方法名
int：参数，直接写参数的类型，多个类型用逗号隔开
异常名：方法定义中抛出指定异常，可以省略

通配符

① *：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现

1	execution（public * com.itheima..UserService.find(*))

② ..：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写

1	execution（public User com..UserService.findById(..))

匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法

书写技巧

① 描述切入点通常描述接口，而不描述实现类，如果描述到实现类，就出现紧耦合了

② 访问控制修饰符针对接口开发均采用public描述（可省略访问控制修饰符描述）

③ 通常不使用异常作为匹配规则

④ 接口名/类名书写名称与模块相关的采用*匹配，例如UserService书写成*Service，绑定业务层接口名

AOP 通知类型

AOP通知共分为5种类型

前置通知
后置通知
环绕通知(重点)
返回后通知(了解)
抛出异常后通知(了解)

通知类型的使用

① 前置通知

修改MyAdvice，在before方法上添加@Before注解

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    
    @Before("pt()")
    //此处也可以写成 @Before("MyAdvice.pt()"),不建议
    public void before() {
        System.out.println("before advice ...");
    }
}

② 后置通知

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    
    @Before("pt()")
    public void before() {
        System.out.println("before advice ...");
    }
    @After("pt()")
    public void after() {
        System.out.println("after advice ...");
    }
}

③ 环绕通知

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    
    @Pointcut("execution(int com.itheima.dao.BookDao.select())")
    private void pt2(){}
    
    @Around("pt2()")
    public Object aroundSelect(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("around before advice ...");
        //表示对原始操作的调用
        Object ret = pjp.proceed();
        System.out.println("around after advice ...");
        return ret;
    }
}

说明：

为什么返回的是Object而不是int的主要原因是Object类型更通用。
在环绕通知中是可以对原始方法返回值就行修改的。

环绕通知注意事项

① 环绕通知必须依赖形参ProceedingJoinPoint才能实现对原始方法的调用，进而实现原始方法调用前后同时添加通知

② 通知中如果未使用ProceedingJoinPoint对原始方法进行调用将跳过原始方法的执行

③ 对原始方法的调用可以不接收返回值，通知方法设置成void即可，如果接收返回值，最好设定为Object类型

业务层接口执行效率

需求分析

任意业务层接口执行均可显示其执行效率（执行时长）

代码实现

① 开启SpringAOP的注解功能

在Spring的主配置文件SpringConfig类中添加注解

1	@EnableAspectJAutoProxy

② 创建AOP的通知类

该类要被Spring管理，需要添加@Component
要标识该类是一个AOP的切面类，需要添加@Aspect
配置切入点表达式，需要添加一个方法，并添加@Pointcut

@Component
@Aspect
public class ProjectAdvice {
    //配置业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}
    
    public void runSpeed(){
        
    } 
}

③ 添加环绕通知

在runSpeed()方法上添加@Around

@Component
@Aspect
public class ProjectAdvice {
    //配置业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}
    //@Around("ProjectAdvice.servicePt()") 可以简写为下面的方式
    @Around("servicePt()")
    public Object runSpeed(ProceedingJoinPoint pjp){
        Object ret = pjp.proceed();
        return ret;
    } 
}

④ 完成核心业务，记录万次执行的时间

@Component
@Aspect
public class ProjectAdvice {
    //配置业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}
    //@Around("ProjectAdvice.servicePt()") 可以简写为下面的方式
    @Around("servicePt()")
    public void runSpeed(ProceedingJoinPoint pjp){
        
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
           pjp.proceed();
        }
        long end = System.currentTimeMillis();
        System.out.println("业务层接口万次执行时间: "+(end-start)+"ms");
    } 
}

⑤ 程序优化

目前程序所面临的问题是，多个方法一起执行测试的时候，控制台都打印的是：

1	业务层接口万次执行时间:xxxms

我们没有办法区分到底是哪个接口的哪个方法执行的具体时间，具体如何优化?

@Component
@Aspect
public class ProjectAdvice {
    //配置业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}
    //@Around("ProjectAdvice.servicePt()") 可以简写为下面的方式
    @Around("servicePt()")
    public void runSpeed(ProceedingJoinPoint pjp){
        //获取执行签名信息
        Signature signature = pjp.getSignature();
        //通过签名获取执行操作名称(接口名)
        String className = signature.getDeclaringTypeName();
        //通过签名获取执行操作名称(方法名)
        String methodName = signature.getName();
        
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
           pjp.proceed();
        }
        long end = System.currentTimeMillis();
        System.out.println("万次执行："+ className+"."+methodName+"---->" +(end-start) + "ms");
    } 
}

AOP通知获取数据

返回后通知获取返回值

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    private void pt(){}

    @AfterReturning(value = "pt()",returning = "ret")
    public void afterReturning(Object ret) {
        System.out.println("afterReturning advice ..."+ret);
    }
//其他的略
}

注意：

参数名的问题

afterReturning方法参数类型的问题

参数类型可以写成String，但是为了能匹配更多的参数类型，建议写成Object类型

afterReturning方法参数的顺序问题

为什么这里必须显示写上 value = “pt( )”

所有注解的核心属性都会命名为value；
如果给注解赋值时，只给 value 属性赋值，没有其他属性需要设置，就可以省略value=，直接写值；
如果需要给多个属性赋值（比如同时给value和returning赋值），就必须显式写出所有属性名，不能省略。

百度网盘密码数据兼容处理

开启SpringAOP的注解功能

@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy
public class SpringConfig {
}

编写通知类

@Component
@Aspect
public class DataAdvice {
    @Pointcut("execution(boolean com.itheima.service.*Service.*(*,*))")
    private void servicePt(){}
    
}

添加环绕通知

@Component
@Aspect
public class DataAdvice {
    @Pointcut("execution(boolean com.itheima.service.*Service.*(*,*))")
    private void servicePt(){}
    
    @Around("DataAdvice.servicePt()")
    // @Around("servicePt()")这两种写法都对
    public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
        Object ret = pjp.proceed();
        return ret;
    }
    
}

完成核心业务，处理参数中的空格

@Component
@Aspect
public class DataAdvice {
    @Pointcut("execution(boolean com.itheima.service.*Service.*(*,*))")
    private void servicePt(){}
    
    @Around("DataAdvice.servicePt()")
    // @Around("servicePt()")这两种写法都对
    public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
        //获取原始方法的参数
        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            //判断参数是不是字符串
            if(args[i].getClass().equals(String.class)){
                args[i] = args[i].toString().trim();
            }
        }
        //将修改后的参数传入到原始方法的执行中
        Object ret = pjp.proceed(args);
        return ret;
    }
    
}

AOP事务管理

需求分析

(1) 需求：实现任意两个账户间转账操作

(2) 需求微缩：A账户减钱，B账户加钱

代码实现

在需要被事务管理的方法上添加注解

public interface AccountService {
    /**
     * 转账操作
     * @param out 传出方
     * @param in 转入方
     * @param money 金额
     */
    //配置当前接口方法具有事务
    public void transfer(String out,String in ,Double money) ;
}

@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;
@Transactional
    public void transfer(String out,String in ,Double money) {
        accountDao.outMoney(out,money);
        int i = 1/0;
        accountDao.inMoney(in,money);
    }

}

在JdbcConfig类中配置事务管理器

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }

    //配置事务管理器，mybatis使用的是jdbc事务
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

**注意：**事务管理器要根据使用技术进行选择，Mybatis框架使用的是JDBC事务，可以直接使用DataSourceTransactionManager

开启事务注解

在SpringConfig的配置类中开启

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class
//开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}

Spring事务属性

事务配置

上面这些属性都可以在@Transactional注解的参数上进行设置。

① readOnly：true只读事务，false读写事务，增删改要设为false，查询设为true。

② timeout：设置超时时间单位秒，在多长时间之内事务没有提交成功就自动回滚，-1表示不设置超时时间。

③ rollbackFor：当出现指定异常进行事务回滚

转账业务追加日志案例

① 需求分析

需求：实现任意两个账户间转账操作，并对每次转账操作在数据库进行留痕
需求微缩：A账户减钱，B账户加钱，数据库记录日志

② 代码实现

1). 添加LogDao接口

public interface LogDao {
    @Insert("insert into tbl_log (info,createDate) values(#{info},now())")
    void log(String info);
}

2). 添加LogService接口与实现类

public interface LogService {
    void log(String out, String in, Double money);
}
@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogDao logDao;
@Transactional
    public void log(String out,String in,Double money ) {
        logDao.log("转账操作由"+out+"到"+in+",金额："+money);
    }
}

3). 在转账的业务中添加记录日志

@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogDao logDao;
//propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void log(String out,String in,Double money ) {
        logDao.log("转账操作由"+out+"到"+in+",金额："+money);
    }
}

关于@Transactional

@Transactional是事务管理注解，核心作用是控制业务层的数据库操作原子性，因此只应该写在业务层（Service 层），且优先写在「实现类 / 实现类方法」上，绝对不要写在 Controller 层或 DAO 层。

事务的传播行为

看前两个就行