Wang-nine的小站

01 前向预测与 MSE：从 batch 输入到标量损失

Mon, 26 Oct 2026 00:00:00 GMT

复习提纲，对应 M2.1 形状与 M2.5 broadcasting 基础；不是掌握记录，也不是练习答案。

1. 本课位置

把一批样本的线性预测写成矩阵乘法，再把预测与目标的差压成一个标量 loss。只算数值与 shape，不推导梯度。

2. 术语与三个身份

feature：一列输入，共 D 个。
sample：一行输入，一个样本。
batch：一次算的 N 个样本，矩阵 X 形状 (N, D)。

名称	角色	是否随样本变化
`X (N, D)`	输入 input	是
`w (D, 1)`、`b ()`	模型参数 parameters	否，全样本共用
`y (N, 1)`	目标 target	是，只在 loss 里出现

b 是显式 bias，不占 X 的列，只给所有样本同一个偏移。

3. 形状链

X (N, D) @ w (D, 1) -> z (N, 1)
z + b               -> p (N, 1)      b 广播到每行
p - y               -> residual (N, 1)
residual ** 2       -> squared (N, 1)
mean(squared)       -> MSE ()

p = X @ w + b、residual = p - y、MSE = mean(residual ** 2)。

名称	形状	含义
`X`	`(N, D)`	batch 输入
`w`	`(D, 1)`	每个 feature 一个权重
`b`	`()`	标量 bias，广播到每行
`p`	`(N, 1)`	每个样本一个预测
`y`	`(N, 1)`	目标，须与 `p` 对齐
`residual`	`(N, 1)`	`p - y`，逐样本误差
`MSE`	`()`	所有平方误差的平均，标量

(N, D) @ (D, 1) -> (N, 1) 不是维度抵消：D 是每个输出内部的求和长度，p_i = sum_j X[i, j] * w[j, 0] + b。

4. 一个 batch 的手算

X = [[2, 1], [4, 2]]    w = [[2], [3]]    b = 5    y = [[13], [17]]
p = [[12], [19]]         # 2*2 + 1*3 + 5, 4*2 + 2*3 + 5
residual = p - y = [[-1], [2]]
MSE = mean([1, 4]) = 2.5

y 必须写成 (2, 1)；写成 [13, 17] 就是 (2,)，减法会进另一套 broadcasting。residual 为正表示预测高于目标，为负表示低于目标，MSE 会把符号丢掉。

5. 易错点

MSE 的单位与平均抵消。 MSE = (1 / M) * sum residual_i ** 2，M 是参与平均的元素个数（当前 p (N, 1) 时 M = N）。若 p、y 以元计，residual 是元，residual ** 2 与 MSE 是元²，不能说"MSE 是 2.5 元"。residual = [+3, -3] 时 mean(residual) = 0，但 MSE = (9 + 9) / 2 = 9：正负抵消不代表预测准，比较模型看 MSE。MSE 为 0 当且仅当所有 residual 都为 0。

size 与 shape[0]。 X.size = N * D 是元素总数，shape[0] = N 只是第一轴长度，第一轴是否表示样本取决于任务约定。p (N, 1) 的 size = N 只因输出宽度为 1；若 p (N, K)，全元素平均的分母是 N * K，不是 N。

三种 size 1。

np.array([5])    -> (1,)    ndim 1
np.array([[5]])  -> (1, 1)  ndim 2
np.array(5)      -> ()      ndim 0

元素个数相同，但轴的划分与能参与的运算不同。

broadcasting。 从最右轴对齐，逐轴长度相等或其中一个为 1，缺的左侧轴当作 1。最大的坑是 p (N, 1) - y (N,) -> (N, N)：y 被当作 (1, N)，每个预测都去减每个目标。N = 1 时结果可能仍是 (1, 1)，错误被藏起来，所以单样本测试不能替代多样本检查。shape 相等也不等于样本对齐，还要核对样本顺序与含义。

reshape 与 guard。 reshape 只改轴划分、元素总数不变；broadcasting 只扩展运算视角、不改输入 shape。任务要求先确认 p.shape == y.shape 再相减：打印一行警告不是 guard，residual 与 MSE 必须放在合法分支里，形状不匹配时整个 loss 都不执行。

6. 速查与入口

X (N, D)、w (D, 1)、b ()、p 与 y (N, 1)、MSE ()。
p 与 y 表示同样的 N 个样本，顺序一一对应。
不是只打印警告：mismatch 时下游 loss 完全不执行，不留下半成品结果。
MSE 是有限的标量；np.mean(residual ** 2) 的分母是元素总数。
N = 1 通过不代表多样本形状正确。

来源：NumPy: the absolute basics for beginners、numpy.mean。

本文于2026-10-26整理公开，日期为导入日期。

02 bias 与损失：局部变化率与导数入门

Mon, 26 Oct 2026 00:00:00 GMT

复习提纲，对应 M2.4 局部变化率入门，以及 M2.1/M2.5 的预测与 MSE 应用；不是掌握记录，也不是练习答案。正式 chain rule 尚未讲，本课不等同 M3 通过。

1. 本课位置

固定 X、w、y，只动一个标量参数 b，观察 MSE 怎样随它变化：先扫点看趋势，再用差商逼近斜率，最后用导数判断该往哪边挪一小步。

2. 术语

bias b：本课固定数据中单独加减的标量参数，形状 ()，给所有样本加同一个偏移。这里说的是本课的显式 bias，不是对所有模型中 bias 是否独立于 feature 的普遍断言。
shared shift：改 b 时每个预测一起平移，不是只改某一行。
控制变量：X、w、y 全部固定，只让 b 变。

p = X @ w + b        # (N, 1)
r = p - y            # residual
b -> b + h   =>  每个 r_i 都增加 h

所以 residual 整体平移，MSE 是它们平方的平均。

3. 扫点：共享指标与单样本

用本课固定数据扫 b：

b          4    5    6    7    8
L = MSE    6    3    2    3    6

测过的候选 4..8 中 b = 6 的 MSE 最低，两侧对称上升；全局最小见第 5 节。b = 5 时 residual 是 [1, -2, -2]，b = 6 时是 [2, -1, -1]：MSE 从 3 降到 2，但第一个样本的 |r| 从 1 升到 2。共享指标变好，不代表每个样本都变好。

4. 差商与导数

对这份固定数据，MSE 恰好是下面这个二次函数：

L(b) = 2 + (b - 6)^2
L'(b) = 2(b - 6)
[L(b + h) - L(b)] / h = 2(b - 6) + h,   h != 0

h -> 0 时差商趋于导数。不能直接代 h = 0，那是除以 0；差商只是有限 h 上可算的近似。局部有 ΔL ≈ L'(b) Δb，只在小步长附近成立，不是全局恒等式。

b     h=0.1    h=0.01    h=0.001    差商极限
5     -1.9     -1.99     -1.999     -2
6      0.1      0.01      0.001      0
7      2.1      2.01      2.001      2

以上展开由教师给出，不是学生证明。符号规则：L'(b) > 0 时 b 略减可降 L，L'(b) < 0 时 b 略增可降 L。前提是足够局部且可导，步长不能任意大；本课不教正式 gradient descent 算法。

5. 导数为零不等于最小

b = 6 左侧取 Δb = -0.1 得 ΔL = +0.01、差商 -0.1；右侧取 Δb = +0.1 也得 ΔL = +0.01、差商 +0.1。两边 L 都升高，不是两边变化率都为正；导数 0 时 L 仍可按 h^2 变化。

L'(6) = 0 只说明该点切线水平，不保证最小值。教师给过的反例是 f(b) = -b^2 在 b = 0 取最大值。对这份固定 X、w、y，直接配方即可判定：

L(6 + h) = 2 + h^2 >= 2 = L(6)

所以 b = 6 是全局最小。但 L = 2 不是 0：residual 为 [2, -1, -1]。完美预测当且仅当所有 r_i = 0，不是导数等于 0。扫点只说明测过的候选里谁最好，不证明所有实数上都最好；有限 h 的差商是近似，不等于精确导数。

6. 实现易错点

h = 0 那行只作基线，不能拿去除以 offset；基线必须配对同一个 b。
res[(bias - 4) * 4] 这种索引依赖起始值、循环顺序和每组 4 个 offset，条件一改就会取错基线。

7. 速查

b 是共享偏移，增加 h 就给每个 residual 加 h。
差商要求 h != 0，导数取 h -> 0；L'(b) 的符号只指示局部挪动方向。
L'(b) = 0 不保证最小，也不保证预测完美；判定最小值要看函数值比较。

来源：数组与广播基础沿用 NumPy: the absolute basics for beginners；本课的变化率、导数与二次函数推导为教师补充，未新增外部微积分来源。

上一课：01 前向预测与 MSE。

本文于2026-10-26整理公开，日期为导入日期。

03 驻点与局部极值：导数为零说明什么

Mon, 26 Oct 2026 00:00:00 GMT

复习提纲，对应 M2.4 的驻点与局部极值；不是掌握记录，也不是练习答案。正式 chain rule 与 gradient descent 尚未讲。

1. 本课位置

只在一元函数、可导点的范围内讨论：导数为零的点和局部极值是什么关系。结论不能直接套到多变量，也不处理不可导点。

2. 术语与定义

stationary point（驻点）：定义域内点 a，且 f'(a) = 0。
local minimum（局部最小）：若存在 δ > 0，使定义域内所有满足 |x - a| < δ 的 x 都有 f(x) >= f(a)，则 a 是 local minimum。
local maximum（局部最大）：同样条件下 f(x) <= f(a)。strict 版本要求 0 < |x - a| < δ，即排除 x = a 自身；只把 >= 换成 > 且仍包含中心点，会在 x = a 处出现 f(a) > f(a) 的矛盾。本课不强制 strict。

f'(a) = 0 的含义是局部变化率为 0、切线水平。它不表示函数在 a 附近是常数，也不直接说明 a 是最小还是最大。

3. 三个函数在 0 的差商

function     f(h)     [f(h)-f(0)]/h, h!=0   极限 h->0   0 处身份
A(t)=t^2     h^2      h                      0           local min
B(t)=-t^2    -h^2     -h                     0           local max
C(t)=t^3     h^3      h^2                    0           都不是

三者导数在 0 都为 0，身份却不同，所以 f'(0) = 0 不能单独判定极值。反过来，可导 + 定义域内点 + 局部极值 => f'(a) = 0 成立；逆命题不成立。

不可导的尖角与定义域端点不在本课结论范围内：它们可能取到极值，但不能用 f' = 0 来分析。

4. 平均变化率

Δf/Δt = (f(t0 + Δt) - f(t0)) / Δt,   Δt != 0

分子分母都是变化量，都按“新值减旧值”计算，不是 f/Δt。以 C(t) = t^3、t0 = 0 向左走 Δt = -0.1 为例：Δf = -0.001，差商 (-0.001)/(-0.1) = +0.01。两个负数相除得正，所以只看 Δf < 0 不能断定差商为负，还要看 Δt 的符号。

5. 导数为零不等于全局最小：一个反例

F(t) = (t^2 - 1)^2 >= 0，且 F(0) = 1、F(±0.1) = 0.9801。存在更小的函数值，所以 0 不是全局最小。教师补充的判定：

F(h) - F(0) = h^2 (h^2 - 2) < 0,   0 < |h| < 1

邻域内 F(h) < F(0)，故 0 是 strict local maximum，不是 minimum。函数值非负、导数又为 0，仍可能是局部最大。

就本例而言，F(0) 与 F(±0.1) 的有限采样足以反驳“0 是全局最小”，但不能只靠这两个点证明 0 是局部最大；局部结论需要邻域内任意接近的 h 都满足的不等式，本课已由上面的因式分解给出。

6. 导数为零与 MSE 为零

有限实数、精确算术、非空 batch 下，MSE = 0 当且仅当所有 residual 都为 0；而驻点只保证 dMSE/db = 0，不保证预测完美，它可能对应非零的极小值。

7. 速查

驻点 f'(a) = 0：局部变化率为 0，切线水平，不等于附近常数。
可导内点取局部极值 => f'(a) = 0；反过来不成立。
差商是 Δf/Δt，分子分母都按“新减旧”计算。
有限点比较能反驳某个全局断言，不足以证明局部结论；局部结论要靠邻域不等式。
导数 0 与 MSE 0 是两件事。

8. 自测

[f(0.2) - f(0)] / 0.2 与 f(0.2) / 0.2 差在哪？
可导点 f'(a) = 0 能否推出 a 是局部最小？举一个反例。
F(t) = (t^2 - 1)^2 在 t = 0 为什么不是全局最小？

来源：本课数学与反例为教师补充，未新增外部微积分来源。

上一课：02 bias 与损失。

本文于2026-10-26整理公开，日期为导入日期。

SpringCloud09-MQ

Sun, 24 Dec 2023 09:00:00 GMT

简单的介绍了SpringCloud中的MQ。

初识MQ

同步调用

原理示意：同步调用的调用方需要等待本次请求的处理结果，才能继续依赖该结果的流程。若多个调用串行发生，端到端延迟会累积；一处变慢或失败还可能沿依赖链传播，因此需要明确超时、错误处理与隔离边界，不能仅凭同步方式就推断系统一定发生级联故障。

优点

时效性较强，可以立即得到结果

缺点

耦合度高
- 每次加入新的需求，都要修改原来的代码
性能下降
- 调用者需要等待服务提供者响应，如果调用链过长则晌应时间等于每次调用的时间之和
资源浪费
- 调用链中的每个服务在等待响应过程中，不能释故请求占用的资源，高并发场录下会极度浪费系统资源
级联失败
- 如果服务提供者出现问题,所有调用方都会跟着出问题,如同多米诺骨牌一样，迅速导致整个微服务群故障

异步调用

原理示意：异步调用把消息提交与后续业务处理分开，消费者按自己的处理能力消费队列中的消息。生产者收到发布确认，并不等于消费者已经完成业务；故障隔离和流量削峰也依赖 Broker 容量、消息持久化、失败重试及消费者幂等。需要最终结果时，可另行设计结果事件或状态查询。

优点

耦合度低
吞吐量提升
故障隔离
流量削峰

缺点

依赖于Broker的可靠性、安全性、吞吐能力
架构复杂了，业务没有明显的流程线，不好追踪管理

MQ

MQ（MessageQueue），中文是消息队列，字面来看就是存放消息的队列。也就是事件驱动架构中的Broker。

	RabbitMQ	ActiveMQ	RocketMQ	Kafka
公司/社区	Rabbit	Apache	阿里	Apache
开发语言	Erlang	Java	Java	Scala&Java
协议支持	AMQP,XMPP,SMTP,STOMP	Openwire,STOMP,REST,XMPP,AMQP	自定义协议	自定义协议
可用性	高	一般	高	高
单机吞吐量	一般	差	高	非常高
消息延迟	微秒级	毫秒级	毫秒级	毫秒以内
消息可靠性	高	一般	高	一般

RabbitMQ快速入门

RabbitMQ概述和安装

常见消息模型

快速入门

SpringAMQP

SpringCloud08-Docker

Wed, 20 Dec 2023 06:30:00 GMT

简单的介绍了SpringCloud中的Docker。

初识Docker

Docker如何解决大型项目依赖关系复杂，不同组件依赖的兼容性问题?

Docker允许开发中将应用、依赖、函数库、配置一起打包，形成可移植镜像
Docker应用运行在容器中，使用沙箱机制，相互隔离

Docker如何解决开发、测试、生产环境有差异的问题

Docker镜像中包含完整运行环境，包括系统函数库，仅依赖系统的Linux内公核，因此可以在任意Linux操作系统上运行

Docker与虚拟机

原理示意：Linux 容器隔离应用进程与资源，但共享其运行宿主的 Linux 内核；虚拟机则在虚拟化层上运行各自的客户机系统。这里比较的是隔离层次，不是性能测试：启动耗时、占用空间和性能仍取决于镜像、负载与平台，Docker Desktop 运行 Linux 容器时通常还包含 Linux 虚拟机这一层。

特性	Docker	虚拟机
性能	接近原生	性能较差
硬盘占用	一般为 MB	一般为 GB
启动	秒级	分钟级

镜像与容器

镜像（lmage）：Docker将应用程序及其所需的依赖、函数库、环境、配置等文件打包在一起，称为镜像。
容器（Container）：镜像中的应用程序运行后形成的进程就是容器，只是Docker会给容器做隔离，对外不可见。

Docker和DockerHub

DockerHub：DockerHub是一个Docker镜像的托管平台。这样的平台称为Docker Registry。
国内也有类似于DockerHub的公开服务，比如网易云镜像服务、阿里云镜像库等。

Docker架构

Docker是一个CS架构的程序，由两部分组成

服务端（server）：Docker守护进程，负责处理Docker指令，管理镜像、容器等
客户端（client）：通过命令或RestAPI向Docker服务端发送指令。可以在本地或远程向服务端发送指令。

原理示意：客户端把命令交给 Docker daemon，实际的镜像拉取、容器创建和资源管理发生在守护进程所在主机。Registry 保存可分发的镜像，pull 与 push 分别拉取与推送镜像内容；镜像到达本机后，还需要创建并启动容器才能运行应用。

Docker的基本操作

Docker,DockerCompose,Docker镜像仓库的安装

0.安装Docker

Docker 分为 CE 和 EE 两大版本。CE 即社区版（免费，支持周期 7 个月），EE 即企业版，强调安全，付费使用，支持周期 24 个月。

Docker CE 分为 stable test 和 nightly 三个更新频道。

官方网站上有各种环境下的安装指南，这里主要介绍 Docker CE 在 CentOS上的安装。

1.CentOS安装Docker

Docker CE 支持 64 位版本 CentOS 7，并且要求内核版本不低于 3.10， CentOS 7 满足最低内核的要求，所以我们在CentOS 7安装Docker。

1.1.卸载（可选）

如果之前安装过旧版本的Docker，可以使用下面命令卸载：

yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-selinux \
                  docker-engine-selinux \
                  docker-engine \
                  docker-ce

1.2.安装docker

首先需要大家虚拟机联网，安装yum工具

yum install -y yum-utils \
           device-mapper-persistent-data \
           lvm2 --skip-broken

然后更新本地镜像源：

# 设置docker镜像源
yum-config-manager \
    --add-repo \
    https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    
sed -i 's/download.docker.com/mirrors.aliyun.com\/docker-ce/g' /etc/yum.repos.d/docker-ce.repo

yum makecache fast

然后输入命令：

yum install -y docker-ce

docker-ce为社区免费版本。稍等片刻，docker即可安装成功。

1.3.启动docker

Docker应用需要用到各种端口，逐一去修改防火墙设置。非常麻烦，因此建议大家直接关闭防火墙！

启动docker前，一定要关闭防火墙后！！

# 关闭
systemctl stop firewalld
# 禁止开机启动防火墙
systemctl disable firewalld

通过命令启动docker：

systemctl start docker  # 启动docker服务

systemctl stop docker  # 停止docker服务

systemctl restart docker  # 重启docker服务

然后输入命令，可以查看docker版本：

docker -v

1.4.配置镜像加速

docker官方镜像仓库网速较差，我们需要设置国内镜像服务：

参考阿里云的镜像加速文档：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

2.CentOS7安装DockerCompose

2.1.下载

Linux下需要通过命令下载：

# 安装
curl -L https://github.com/docker/compose/releases/download/1.23.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

2.2.修改文件权限

修改文件权限：

# 修改权限
chmod +x /usr/local/bin/docker-compose

2.3.Base自动补全命令：

# 补全命令
curl -L https://raw.githubusercontent.com/docker/compose/1.29.1/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose

如果这里出现错误，需要修改自己的hosts文件：

echo "199.232.68.133 raw.githubusercontent.com" >> /etc/hosts

3.Docker镜像仓库

搭建镜像仓库可以基于Docker官方提供的DockerRegistry来实现。

官网地址：https://hub.docker.com//registry

3.1.简化版镜像仓库

Docker官方的Docker Registry是一个基础版本的Docker镜像仓库，具备仓库管理的完整功能，但是没有图形化界面。

搭建方式比较简单，命令如下：

docker run -d \
    --restart=always \
    --name registry	\
    -p 5000:5000 \
    -v registry-data:/var/lib/registry \
    registry

命令中挂载了一个数据卷registry-data到容器内的/var/lib/registry 目录，这是私有镜像库存放数据的目录。

访问http://YourIp:5000/v2/_catalog 可以查看当前私有镜像服务中包含的镜像

3.2.带有图形化界面版本

使用DockerCompose部署带有图象界面的DockerRegistry，命令如下：

version: '3.0'
services:
  registry:
    image: registry
    volumes:
      - ./registry-data:/var/lib/registry
  ui:
    image: joxit/docker-registry-ui:static
    ports:
      - 8080:80
    environment:
      - REGISTRY_TITLE=传智教育私有仓库
      - REGISTRY_URL=http://registry:5000
    depends_on:
      - registry

3.3.配置Docker信任地址

我们的私服采用的是http协议，默认不被Docker信任，所以需要做一个配置：

# 打开要修改的文件
vi /etc/docker/daemon.json
# 添加内容：
"insecure-registries":["http://192.168.150.101:8080"]
# 重加载
systemctl daemon-reload
# 重启docker
systemctl restart docker

镜像相关命令

镜像名称一般分两部分组成：[repository]:[tag]。
在没有指定tag时，默认是latest，代表最新版本的镜像

镜像操作按目的区分：docker pull 从仓库拉取镜像，docker images 查看本地镜像，docker image inspect 查看元数据，docker tag 为已有镜像增加引用，docker push 推送到指定仓库，docker rmi 删除本地镜像引用。归档迁移使用下面的 save 与 load，它们不是创建或启动容器的命令。省略标签通常使用 latest，但这个标签只是约定名称，不保证始终对应时间上最新或兼容的版本。

docker --help

主要还是查看帮助文档进行

# 例子
docker save -o nginx.tar nginx:latest
docker load -i nginx.tar

容器相关命令

原理示意：run 基于镜像创建并启动新容器，stop 停止已有容器，start 重新启动同一个容器，rm 删除容器。镜像、容器可写层与外部数据卷是不同对象；再次执行 run 不等于恢复原容器，删除容器也不等于删除镜像或命名数据卷。

常用指令：

以 Nginx 为例，可使用 docker run --name web -p 8080:80 -d nginx:latest 创建一个后台容器：web 是容器名称，8080:80 把宿主机端口映射到容器内端口，-d 表示后台运行。运行前确认宿主端口未被占用；随后可用 docker ps 查看状态，用 docker logs web 排查启动问题。需要保留同一个容器时使用 stop 与 start，不要重复创建同名容器。

docker run命令的常见参数：

—name：指定容器名称
-p：指定端口映射
-d：让容器后台运行

查看容器日志的命令：

docker logs
添加-f参数可以持续查看日志

查看容器状态：

docker ps
添加-a参数查看所有状态的容器

删除容器：

docker rm
不能删除运行中的容器，除非添加-f参数

进入容器：

命令是docker exec -it[容器名][要执行的命令]
exec命令可以进入容器修改文件，但是在容器内修改文件是不推荐的

数据卷相关命令

容器与数据耦合的问题

不便于修改
- 当我们要修改Nginx的html内容时，需要进入容器内部修改，很不方便。
数据不可复用
- 在容器内的修改对外是不可见的。所有修改对新创建的容器是不可复用的。
升级维护困难
- 数据在容器内，如果要升级容器必然删除旧容器，所有数据都跟着删除了。

原理示意：把网页、数据库文件等需要保留的数据挂载到容器外部，使容器升级与数据生命周期分离。命名卷由 Docker 管理，绑定挂载指向指定宿主路径；删除容器通常不删除这些外部数据，但主动删除卷或宿主文件仍会造成数据丢失，挂载不能替代备份。

两种挂载方式可通过来源区分：-v html:/usr/share/nginx/html 使用名为 html 的数据卷，-v /srv/site:/usr/share/nginx/html 则直接绑定宿主目录。前者由 Docker 管理存储位置，后者依赖宿主目录结构与权限，更适合直接编辑网站文件。冒号右侧始终是容器路径；只需读取的内容可增加 :ro。挂载会遮蔽目标目录原有内容，部署前应确认来源数据和访问权限。

数据卷操作常见命令：

docker volume create 创建一个volume
docker volume ls 列出所有的volume
docker volume inspect 显示一个或多个volume的信息
docker volume rm 删除一个或多个指定的volume
docker volume prune 删除未使用的volume

数据卷挂载方式：

-v volumeName: /targetContainerPath
如果容器运行时volume不存在，会自动被创建出来

```shell
docker run —name mn -p 80:80 -v htm1:/usr/share/nginx/html -d nginx


**docker run的命令中通过-v参数挂载文件或目录到容器中：**

+ -v volume名称:容器内目录
+ -宿主机文件:容器内文件
+ -v宿主机目录:容器内目录

**数据卷挂载与目录直接挂载的**

+ 数据卷挂载耦合度低，由docker来管理目录。但是目录较深，不好找

# Dockerfile自定义镜像

**镜像是将应用程序及其需要的系统函数库、环境、配置、依赖打包而成。**

![image-20231224140745581](https://wang-nine.cn//images/SpringCloud08-06%E9%95%9C%E5%83%8F%E7%9A%84%E7%BB%93%E6%9E%84.png)

**镜像是分层结构，每一层称为一个Lager**

+ Baselmage层:包含基本的系统函数库、环境变量、文件系统
+ Entrypoint: 入口，是镜像中应用启动的命令
+ 其它:在Baselmage基础上添加依赖、安装程序、完成整个应用的安装和配置

**Dockerfile就是一个文本文件，其中包含一个个的指令(Instruction)，用指令来说明要执行什么操作来构建镜像。每一个指令都会形成一层Layer。**

|    指令    |                     说明                     |            示例             |
| :--------: | :------------------------------------------: | :-------------------------: |
|    FROM    |                 指定基础镜像                 |        FROM centos:6        |
|    ENV     |        设置环境变量，可在后面指令使用        |        ENV key value        |
|    COPY    |         拷贝本地文件到镜像的指定目录         |  COPY ./mysql-5.7.rpm /tmp  |
|    RUN     |  执行Linux的shell命令，一般是安装过程的命令  |     RUN yum install gcc     |
|   EXPOSE   | 指定容器运行时监听的端口，是给镜像使用者看的 |         EXPOSE 8080         |
| ENTRYPOINT |     镜像中应用的启动命令，容器运行时调用     | ENTRYPOINT java -jar xx.jar |

+ Dockerfile的本质是一个文件，通过指令描述镜像的构建过程
+ Dockerfile的第一行必须是FROM，从一个基础镜像来构建
+ 基础镜像可以是基本操作系统，如Ubuntu。也可以是其他人制作好的镜像，例如: java:8-alpine

# Docker-Compose

+ Docker Compose可以基于Compose文件帮我们快速的部署分布式应用，而无需手动一个个创建和运行容器!
+ Compose文件是一个文本文件，通过指令定义集群中的每个容器如何运行。
+ 指令写法

```shell
# MySQL容器
docker run \
--name mysql \
-e MYSQL_ROOT_PASSwORD=123 \
-p 3306:3306 \
-v /tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf \
-v /tmp/mysql/data:/var/lib/mysql \
-d \
mysql:5.7.25

# 构建镜像
docker build -t web:1.0 . # 注意，这个"." 表示是在当前目录下运行
# 运行容器
docker run --name web -p 8090:8090 -d web: 1.0

compose写法

version: "3.8"

services:
  mysql:
	image: mysql:5.7.25
	environment:
	  MYSQL_ROOT_PASSWORD:123
	volumes:
	  - /tmp/mysql/data:/var/lib/mysql
	  - /tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf
  web:
	build: .
	ports:
	  - 8090: 8090

Docker镜像服务

镜像仓库（Docker Registry ）有公共的和私有的两种形式：

公共仓库：例如Docker官方的Docker Hub，国内也有一些云服务商提供类似于Docker Hub的公开服务，比如网易云镜像服务、DaoCloud镜像服务、阿里云镜像服务等。
除了使用公开仓库外，用户还可以在本地搭建私有Docker Registry。企业自己的镜像最好是采用私有DockerRegistry来实现。

私有 Registry 的工作流程是：先为本地镜像设置包含仓库地址的名称，再按仓库要求完成认证并推送；其他主机使用同一地址拉取镜像，再创建容器。前文的 registry-data:/var/lib/registry 用来持久化仓库内容，图形管理页面只是访问仓库的入口，不是镜像本身的存储位置。生产部署应配置 TLS、访问控制与备份，不应把学习环境中的 HTTP 信任配置直接当作生产方案。

SpringCloud07-Gateway

Mon, 18 Dec 2023 05:00:00 GMT

简单的介绍了SpringCloud中的Gateway。

为什么需要网关？

原理示意：网关集中承接外部流量，把认证、权限校验、限流与路由等入口职责组织起来。本文的 /user/** 匹配用户服务，lb://userservice 表示通过服务发现与负载均衡选择实例；这些策略需要相应配置或实现，不会仅因引入网关依赖便全部自动生效。

网关的技术实现
在SpringCloud中网关的实现包括两种：

gateway
Zuul
- Zuul是基于Servlet的实现，属于阻塞式编程。而SpringCloudGateway则是基于Spring5中提供的WebFlux，属于响应式编程的实现，具备更好的性能。

网关的作用

对用户请求做身份认证、权限校验
将用户请求路由到微服务，并实现负载均衡
对用户请求做限流

搭建网关的步骤

创建新的module，引入SpringCloudGateway的依赖和nacos的服务发现依赖:

<!--nacos服务注册发现依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!--网关gateway依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

编写路由配置及nacos地址

server:
  port: 10010 # 网关端口
spring:
  application:
	name: gateway # 服务名称
  cloud:
	nacos:
	  server-addr: localhost:8848 # nacos地址
	gateway:
	  routes: # 网关路由配置
		- id: user-service # 路由id，自定义，只要唯一即可
		  # uri: http://127.0.0.1:8081 #路由的目标地址http就是固定地址
		  uri: lb://userservice # 路由的目标地址lb就是负载均衡，后面跟服务名称
		  predicates: # 路由断言，也就是判断请求是否符合路由规则的条件
			- Path=/user/** # 这个是按照路径匹配，只要以/user/开头就符合要求

路由配置

网关路由可以配置的内容包括

路由id：路由唯一标示
uri：路由目的地，支持lb和http两种
predicates：路由断言，判断请求是否符合要求，符合则转发到路由目的地
filters：路由过滤器，处理请求或响应

路由断言工厂Route Predicate Factory

名称	说明	示例
After	是某个时间点后的请求	- After=2037-01-20T17:42:47.789-07:00[America/Denver]
Before	是某个时间点之前的请求	- Before=2031-04-13T15:14:47.433+08:00[Asia/Shanghai]
Between	是某两个时间点之前的请求	- Between=2037-01-20T17:42:47.789-07:00[America/Denver], 2037-01-21T17:42:47.789-07:00[America/Denver]
Cookie	请求必须包含某些cookie	- Cookie=chocolate, ch.p
Header	请求必须包含某些header	- Header=x-Request-ld,\d+
Host	请求必须是访问某个host（域名)	- Host=.somehost.org,.anotherhost.org
Method	请求方式必须是指定方式	- Method=GET,POST
Path	请求路径必须符合指定规则	- Path=/red/{segment},/blue/**
Query	请求参数必须包含指定参数	- Query=name, Jack或者-Query=name
RemoteAddr	请求者的ip必须是指定范围	- RemoteAddr=192.168.1.1/24
weight	权重处理

路由过滤器GatewayFilter

GatewayFilter是网关中提供的一种过滤器，可以对进入网关的请求和微服务返回的响应做处理，共计三十一中，具体配置官网查看

路由过滤器配置在某条路由的 filters 下，只处理匹配该路由的请求。理解时分清三个步骤：predicates 判断请求是否匹配，uri 指定转发目标，filters 在转发前后处理请求或响应。例如统一添加请求头、调整路径或补充响应头，属于过滤器职责而不是新的业务接口。配置语法与可用工厂以当前 Gateway 版本为准，不把过滤器数量当作固定常量。

当多条路由需要相同的过滤规则时，可以把公共规则放到 spring.cloud.gateway.default-filters，避免在每条路由中重复声明。它表示默认应用的路由过滤器配置，并不是替请求选择目标的“默认路由器”。单条路由仍可声明自己的 filters；需要自定义通用逻辑时，再考虑下面介绍的 GlobalFilter，并检查公共规则与局部规则是否产生重复处理。

全局过滤器

全局过滤器的作用也是处理一切进入网关的请求和微服务响应，与GatewayFilter的作用一样。区别在于GatewayFilter通过配置定义，处理逻辑是固定的。而GlobalFilter的逻辑需要自己写代码实现。定义方式是实现GlobalFilter接口。

举例如下：

需求：

定义全局过滤器，拦截请求，判断请求的参数是否满足下面条件：

参数中是否有authorization
authorization参数值是否为admin

如果同时满足则放行，否则拦截

//@Order(-1) //过滤器顺序，越小越优先
@Component
public class AuthorizeFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 1.获取请求参数
        ServerHttpRequest request = exchange.getRequest();
        MultiValueMap<String, String> params = request.getQueryParams();
        // 2.获取参数中的 authorization 参数
        String auth = params.getFirst("authorization");
        // 3.判断参数值是否等于 admin
        if ("admin".equals(auth)) {
            // 4.是，放行
            return chain.filter(exchange);
        }
        // 5.否，拦截
        // 5.1.设置状态码
        exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
        // 5.2.拦截请求
        return exchange.getResponse().setComplete();
    }
    
    @Override
    public int getOrder() {
        return -1;
    }
}

过滤器链执行顺序

原理示意：正常放行时，前置处理按 order 从小到大进入过滤器链，响应的后置处理沿已建立的嵌套顺序返回。直接结束响应会短路后续处理；同一 order 下的类型顺序需结合版本和实际注册方式核对，不能仅依赖类型名称判断。

过滤器执行顺序

每一个过滤器都必须指定一个int类型的order值,order值越小，优先级越高，执行顺序越靠前。
GlobalFilter通过实现Ordered接口，或者添加@Order注解来指定order值，由我们自己指定
路由过滤器和defaultFilter的order由Spring指定，默认是按照声明顺序从1递增。
当过滤器的order值一样时，会按照 defaultFilter > 路由过滤器 > GlobalFilter的顺序执行。

跨域问题处理

跨域:域名不一致就是跨域，主要包括：

域名不同：www.taobao.com 和 www.taobao.org 和 www.jd.com 和 miaosha.jd.com
域名相同，端口不同：localhost:8080和localhost8081

跨域问题：浏览器禁止请求的发起者与服务端发生跨域ajax请求，请求被浏览器拦截的问题

解决方案：CORS

spring:
  cloud:
    gateway:
	  #。。。
	  globalcors: # 全局的跨域处理
		add-to-simple-url-handler-mapping: true # 解决options请求被拦截问题
		corsConfigurations:
		  '[/**]':
			allowed0rigins: # 允许哪些网站的跨域请求
			  - "http://localhost:8090"
			  - "http://www.leyou.com"
			allowedMethods: # 允许的跨域ajax的请求方式
			  - "GET"
			  - "POST"
			  - "DELETE"
			  - "PUT"
			  - "OPTIONS"
			allowedHeaders: "*” # 允许在请求中携带的头信息
			allowCredentials: true # 是否允许携带
			cookiemaxAge: 360000 # 这次跨域检测的有效期

SpringCloud06-Feign

Sat, 16 Dec 2023 09:00:00 GMT

简单的介绍了SpringCloud中的Feign。

http客户端Feign

restTemplate方式调用存在的问题

String url = "http://userservice/user/" + order.getUserId();
User user = restTemplate.getForObject(url, User.class);

存在以下的问题：

代码可读性差，编程体验不统一
参数复杂URL难以维护

Feign的使用方法

引入依赖

<!--feign客户端依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

在order-service的启动类添加注解开启Feign的功能

@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication
@EnableFeignClients(clients = UserClient.class,defaultConfiguration = DefaultFeignConfiguration.class)
public class OrderApplication {

    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
}

编写Feign客户端

@FeignClient("userservice")
public interface UserClient {
    @GetMapping("/user/{id}")
    User findById(@Pathvariable("id") Long id);
}

主要是基于SpringMVC的注解来声明远程调用的信息，比如：

服务名称：userservice
请求方式：GET
请求路径：/user/{id}
请求参数：Long id
返回值类型：User

自定义Feign的参数配置

类型	作用	说明
feign.Logger.Level	修改日志级别	包含四种不同的级别：NONE、BASIC、HEADERS、FULL
feign.codec.Decoder	响应结果的解析器	http远程调用的结果做解析，例如解析json字符串为java对象
feign.codec.Encoder	请求参数编码	将请求参数编码，便于通过http请求发送
feign.Contract	支持的注解格式	默认是SpringMVC的注解
feign.Retryer	失败重试机制	请求失败的重试机制，默认是没有，不过会使用Ribbon的重试

一般我们需要配置的就是日志级别，有两种配置方法

方式一：配置文件方式

全局生效

feign:
	client:
		config:
			default: #这里用default就是全局配置，如果是写服务名称，则是针对某个微服务的配置
				loggerLevel: FULL #日志级别

局部生效

feign:
	client:
		config:
			userservice: #这里用default就是全局配置，如果是写服务名称，则是针对某个微服务的配置
				loggerLevel: FULL #日志级别

方式二：java代码方式

需要先声明一个Bean

public class FeignclientConfiguration {
	@Bean
	public Logger.Level feignLogLevel() {
		return Logger.Level.BASIC;
	}
}

如果是全局配置,则把它放到@EnableFeignclients这个注解中

@EnableFeignclients(defaultConfiguration = FeignclientConfiguration.class)

如果是局部配置，则把它放到@Feignclient这个注解中

@FeignClient(value = "userservice", configuration = FeignClientConfiguration.class)

总结

Feign的日志配置：

方式一是配置文件，feign.client.config.xxx.loggerLevel

如果xxx是default则代表全局
如果xxx是服务名称，例如userservice则代表某服务

方式二是java代码配置Logger.Level这个Bean

如果在@EnableFeignClients注解声明则代表全局
如果在@FeignClient注解中声明则代表某服务

Feign的性能优化

Feign底层的客户端实现：

URLConnection:：默认实现，不支持连接池
Apache HttpClient：支持连接池
OKHttp：支持连接池

因此优化Feign的性能主要包括：

使用连接池代替默认的URLConnection
日志级别，最好用basic或none

Feign的性能优化-连接池配置

引入依赖

<!--引入HttpClient依赖-->
<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-httpclient</artifactId>
</dependency>

配置连接池

feign:
  client:
	config:
	  default: #default全局的配置
		loggerLevel: BASIC #日志级别，BASIC就是基本的请求和响应信息
  httpclient:
    enabled: true # 支持HttpClient的开关
    max-connections: 200 # 最大连接数
    max-connections-per-route: 50 # 单个路径的最大连接数

实践分析

方式一（继承）：给消费者的Feignclient和提供者的controller定义统一的父接口作为标准。

原理示意：公共父接口统一方法契约，两端分别继承或实现，但运行时仍是跨进程的 HTTP 调用。接口复用会把契约变更传递到两端；尤其要核对当前版本对映射注解继承的支持，不能只凭 Java 接口继承就认定远程路由已经正确配置。

方式二（抽取）：将FeignClient抽取为独立模块，并且把接口有关的PO]O、默认的Feign配置都放到这个模块中，提供给所有消费者使用

原理示意：把客户端接口、相关传输对象和默认配置抽成独立模块供消费者依赖，服务端保留自己的 Controller 实现。模块依赖只解决代码可见性；还要让 @EnableFeignClients 的扫描范围或显式客户端列表覆盖该接口，才能注册并注入调用代理。

当定义的FeignClient不在SpringBootApplication的扫描包范围时，这些FeignClient无法使用。有两种方式解决:

方式一：指定FeignClient所在包

@EnableFeignclients(basePackages = "cn.itcast.feign.clients")

方式二：指定FeignClient字节码

@EnableFeignclients(clients = {Userclient.class})

HTML5+CSS305-移动端Web

Thu, 07 Dec 2023 05:30:00 GMT

第十天笔记

移动端Web

JavaScript总览

Fri, 01 Dec 2023 15:00:00 GMT

JavaScript01-基础

Fri, 01 Dec 2023 15:00:00 GMT

JavaScript基础

1.JavaScript 是什么（是什么？）

是一种运行在客户端（浏览器）的编程语言，实现人机交互效果。

2.作用（做什么?）

网页特效（监听用户的一些行为让网页作出对应的反馈）
表单验证（针对表单数据的合法性进行判断）
数据交互（获取后台的数据,渲染到前端）
服务端编程（node.js）

3.JavaScript的组成（有什么?）

ECMAScript：规定了 js 基础语法核心知识。
Web APIs
- DOM：操作文档，比如对页面元素进行移动、大小、添加删除等操作
- BOM：操作浏览器，比如页面弹窗，检测窗口宽度、存储数据到浏览器等等

JavaScript书写位置

与 CSS 相同

CSS

行内样式表
内部样式表
外部样式表

JavaScript

行内样式表
内部样式表
外部样式表

内部 JavaScript

直接写在html文件里，用script标签包住

规范：script标签写在\</body>上面

拓展：alert(‘你好，js’) 页面弹出警告对话框

注意事项：我们将\<script>放在HTML文件的底部附近的原因是浏览器会按照代码在文件中的顺序加载 HTML。如果先加载的 JavaScript 期望修改其下方的 HTML，那么它可能由于 HTML 尚未被加载而失效。因此，将 JavaScript 代码放在 HTML 页面的底部附近通常是最好的策略。

外部 JavaScript

代码写在以.js结尾的文件里

语法：通过script标签，引入到html页面中。

注意事项：

script 标签中间无需写代码，否则会被忽略!
外部 JavaScript 会使代码更加有序，更易于复用，且没有了脚本的混合，HTML也会更加易读，因此这是个好的习惯。

内联 JavaScript

代码写在标签内部

语法：先不做了解

注意：此处作为了解即可，但是后面vue框架会用这种模式

JavaScript 注释

单行注释
- 符号：//
- 作用：右边这一行的代码会被忽略
- 快捷键：ctrl + /
块注释
- 符号：/* */
- 作用：在/*和*/之间的所有内容都会被忽略
- 快捷键：shift + alt + a

JavaScript 结束符

结束符
- 作用：使用英文的;代表语句结束
- 实际情况：实际开发中，可写可不写，浏览器（JavaScript引擎）可以自动推断语句的结束位置
- 现状：在实际开发中，越来越多的人主张，书写 JavaScript 代码时省略结束符
- 约定：为了风格统一，结束符要么每句都写，要么每句都不写（按照团队要求）

JavaScript 输入与输出语法

输出语法

语法1

document.write('输出的内容')

作用：向 body 内输出内容

注意：如果输出的内容写的是标签，也会被解析成网页元素

语法2

alert('输出的内容')

作用：页面弹出警告框

语法3

console.log('控制台打印')

输入语法

语法：

prompt('请输入您的姓名：')

作用：显示一个对话框，对话框中包含一条文字信息，用来提示用户输入文字

代码执行顺序

按 HTML 文档流顺序执行 JavaScript 代码
alert() 和 prompt() 它们会跳过页面渲染先被执行（目前作为了解，后期讲解详细执行过程）

变量

声明

let 变量名

赋值

变量名 = 值

更新

变量名 = 值

注意：let 不允许多次声明一个变量

声明多个变量（不推荐）

let age = 18, uname = 'pink'

let 和 var 的区别

在较旧的JavaScript，使用关键字var来声明变量，而不是let。

var现在开发中一般不再使用它，只是我们可能再老版程序中看到它。

let为了解决var 的一些问题。

var声明：

可以先使用在声明(不合理)
var声明过的变量可以重复声明(不合理)
比如变量提升、全局变量、没有块级作用域等等

常量

const 变量名 = 值

注意：声明时必须初始化

数组

声明语法

let 数组名 = [数据1, 数据2, ..., 数据n]

取值语法

数组名[索引号]

和其他语言一样从零开始
数组里面可以存储任意类型的数据
数组的长度可以使用其属性获得，和 java 一样，数组名.length

数据类型

基本数据类型

number 数字型
string 字符串型
boolean 布尔型
undefined 未定义型
null 空类型

number - 数字型

有关于 NaN（Not a Number）的注意：

NaN代表一个计算错误，它是一个不正确的或者一个未定义的数学操作所得到的结果
NaN是粘性的，任何对NaN的操作都会返回NaN
NaN != NaN

string - 字符串型

通过单引号(‘’)、双引号(“”)或反引号(`)包裹的数据都叫字符串，单引号和双引号没有本质上的区别，推荐使用单引号

字符串 + 变量写法

写法1（较为麻烦）

let name = wang
let age = 21
document.write('大家好，我叫’+ name + '，今年' +age +'岁')

写法2（较为简单）

let name = wang
let age = 21
document.write(`大家好，我叫${name}，今年${age}岁`)

写法2注意事项：

``反引号包裹
拼接变量时，用 ${}包裹变量

boolean - 布尔型

true
false

undefined - 未定义型

只声明变量，不赋值的情况下，变量的默认值为undefined，一般很少直接为某个变量赋值为undefined。

null - 空类型

如果一个变量里面确定存放的是对象，如果还没准备好对象，可以放个null

Javascript 中的 null 仅仅是一个代表“无”、“空”或“值未知”的特殊值

null 和 undefined 区别：

undefined 表示没有赋值
null 表示赋值了，但是内容为空

typeof - 检测数据类型

typeof运算符可以返回被检测的数据类型。它支持两种语法形式

作为运算符：typeof x（常用的写法）
函数形式：typeof(x)

换言之，有括号和没有括号，得到的结果是一样的，所以我们直接使用运算符的写法。

类型转换

1.隐式转换

某些运算符被执行时，系统内部自动将数据类型进行转换，这种转换称为隐式转换。

规则:

- 号两边只要有一个是字符串，都会把另外一个转成字符串
除了 + 以外的算术运算符比如 - * / 等都会把数据转成数字类型

缺点:

转换类型不明确，靠经验才能总结

小技巧:

+号作为正号解析可以转换成数字型
任何数据和字符串相加结果都是字符串

2.显示转换

转换为数字型
- Number(数据)
- parseInt(数据)
- parseFloat(数据)

引用数据类型

object 对象

HTML5+CSS304-前端项目学习

Fri, 01 Dec 2023 12:00:00 GMT

第九天笔记

前端项目学习

项目目录

xtx-pc
- images文件夹：存放固定使用的图片素材，例如：logo、样式修饰图等等
- uploads文件夹：存放非固定使用的图片素材，例如：商品图、宣传图、需要上传的图片
- iconfont文件夹：字体图标素材
- css 文件夹：存放CSS文件(link标签引入)
  - base.css：基础公共样式(最先引入)
  - common.css：各个网页相同模块的重复样式，例如：头部、底部
  - index.css：首页CSS样式
- index.html：首页HTML文件

SEO（搜索引擎优化）

提升 SEO 的常见方法：

竞价排名
将网页制作成 html 后缀
标签语义化
……

网页头部 SEO 标签

title：网页标题标签
description：网页描述
keywords：网页关键词

<meta name="description" content="xxx">
<meta name="keywords" content="xxx">
<title>xxx</title>

Favicon 图标

Favicon图标：网页图标，出现在浏览器标题栏，增加网站辨识度。

图标：favition.ico 一般存放到网站的根目录里面

<link rel="shortcut icon" href="favicon.ico" type="image/x-icon">

版心

wrapper 版心宽度：1240px

common.css 设置即可

头部

结构：.header > logo + 导航（nav） + 搜索（search） + 购物车（cart）

注意

logo：使用 h1 > a，a放关键字并设置字号 0px 来提升搜索引擎优化
导航：下边界线加给 a 而不是 hover，确保悬停时从下间距开始显示边界线
搜索：浏览器解析 input 优先生效自己的默认宽度，宽度设置为 0 重置宽度使 flex: 1生效
购物车：子绝父相中 left 默认向右撑开，right默认向左撑开

底部

index 区域

新鲜好物（goods）

结构：标题（title） + 内容（bd）

提示：多区域样式共用

人气推荐（recommend）

同上

生鲜（fresh）

标题结构：右侧（right） > 菜单（ul） ＋查看全部

代码

base.css

/* 去除常见标签默认的 margin 和 padding */
* {
  margin: 0;
  padding: 0;
  box-sizing: border-box;
}

/* 设置网页统一的字体大小、行高、字体系列相关属性 */
body {
  font: 16px/1.5  "Microsoft Yahei",
    "Hiragino Sans GB", "Heiti SC", "WenQuanYi Micro Hei", sans-serif;
  color: #333;
}

/* 去除列表默认样式 */
ul,
ol {
  list-style: none;
}

/* 去除默认的倾斜效果 */
em,
i {
  font-style: normal;
}

/* 去除a标签默认下划线，并设置默认文字颜色 */
a {
  text-decoration: none;
  color: #333;
}

/* 设置img的垂直对齐方式为居中对齐，去除img默认下间隙 */
img {
  width: 100%;
  height: 100%;
  vertical-align: middle;
}

/* 去除input默认样式 */
input {
  border: none;
  outline: none;
  color: #333;
}

h1,
h2,
h3,
h4,
h5,
h6 {
  font-weight: 400;
}

common.css

/* 头尾各个页面相同的样式 */
/* 版心 */
.wrapper {
  margin: 0 auto;
  width: 1240px;
}

/* 快捷导航 */
.shortcut {
  height: 52px;
  background-color: #333;
}

.shortcut .wrapper {
  display: flex;
  justify-content: end;

  height: 52px;
  /* background-color: pink; */
}

.shortcut ul {
  display: flex;
  line-height: 52px;
}


.shortcut li a {
  padding: 0 15px;
  border-right: 1px solid #999;
  font-size: 14px;
  color: #fff;
}

.shortcut li:last-child a {
  border-right: none;
}

.shortcut li .iconfont {
  margin-right: 4px;
  vertical-align: middle;
}

.shortcut li .login {
  color: #5Eb69c;
}


/* 头部区域 */
.header {
  display: flex;
  margin-top: 22px;
  margin-bottom: 22px;
  height: 88px;
  /* background-color: pink; */
}

/* logo区域 */
.logo {
  margin-right: 40px;
  width: 200px;
  height: 88px;
  /* background-color: blue; */
}

.logo a {
  display: block;
  width: 200px;
  height: 88px;
  font-size: 0px;
  background-image: url(../images/logo.png);
}

/* 导航区域 */
.nav {
  margin-top: 33px;
  margin-right: 28px;
}

.nav ul {
  display: flex;
}

.nav li {
  margin-right: 47px;
}

.nav li a {
  padding-bottom: 10px;
}

.nav li a:hover {
  border-bottom: 2px solid #5EB69C;
  color: #5EB69C;
}

/* 搜索区域 */
.search {
  display: flex;
  margin-top: 33px;
  margin-right: 45px;
  width: 170px;
  height: 34px;
  border-bottom: 2px solid #F4F4F4;
}

.search .iconfont {
  margin-right: 8px;
  width: 18px;
  height: 18px;
  color: #CCC;
}

.search input {
  flex: 1;
  width: 0;
}

.search input::placeholder {
  font-size: 16px;
  color: #CCC;
}


/* 购物车区域 */
.cart {
  position: relative;
  margin-top: 32px;
}

.cart .iconfont {
  font-size: 24px;
}

.cart i {
  position: absolute;
  top: 1px;
  left: 15px;
  padding: 0 6px;
  height: 15px;
  background-color: #E26237;
  border-radius: 8px;
  font-size: 14px;
  color: #FFFEFE;
  line-height: 15px;
}


/* 底部区域 */
.footer {
  height: 580px;
  background-color: #F5F5F5;
}

/* 服务区域 */
.service {
  padding: 60px 0;
  height: 178px;
  border-bottom: 1px solid #E8E8E8;
}

.service ul {
  display: flex;
  justify-content: space-evenly;
}

.service li {
  display: flex;
  width: 190px;
  height: 58px;
  /* background-color: pink; */
}

.service li h5 {
  margin-right: 20px;
  width: 58px;
  height: 58px;
  background-image: url(../images/sprite.png);
}

.service li p {
  font-size: 28px;
  line-height: 58px;
}

.service li:nth-child(2) h5 {
  background-position: 0 -58px;
}

.service li:nth-child(3) h5 {
  background-position: 0 -116px;
}

.service li:nth-child(4) h5 {
  background-position: 0 -174px;
}

/* 帮助中心区域 */
.help {
  padding-top: 60px;
  display: flex;
  justify-content: space-between;
  padding: 60px 0;
  height: 300px;
  /* background-color: pink; */
}

.help .left {
  display: flex;
}

.help .left dl {
  margin-right: 84px;
}

.help .left dl:last-child {
  margin-right: 0;
}

.help .left dt {
  margin-bottom: 30px;
  font-size: 18px;
}

.help .left dd {
  margin-bottom: 10px;
}

.help .left a {
  color: #969696
}

.help .left a:hover {
  color: #5Eb69c
}

.help .left .iconfont {
  color: #5Eb69c;
}

.help .right ul {
  display: flex;
}

.help .right li:first-child {
  margin-right: 55px;
}

.help .right .pic {
  margin-bottom: 10px;
  width: 120px;
  height: 120px;
}

.help .right p {
  color: #969696;
  text-align: center;
}

/* 版权区域 */
.copywrite {
  text-align: center;
}

.copywrite p {
  margin-bottom: 10px;
  color: #969696;
}

.copywrite p a {
  margin: 0 10px;
  color: #969696;
}

index.css

/* 首页内容的样式 */

/* banner 区域 */
.banner {
  height: 500px;
  background-color: #f5f5f5;
}

.banner .wrapper {
  position: relative;
  height: 500px;
  /* background-color: pink; */
  /* 为了避免三张图片都显示，父级可以设置溢出隐藏属性 */
  overflow: hidden;
}

.banner .pic {
  display: flex;
  /* flex布局的关系。子级图片会被挤小，想要原图的效果则加宽 */
  width: 3720px;
}

/* 侧导航区域 */
.subnav {
  position: absolute;
  left: 0;
  top: 0;
  width: 250px;
  height: 500px;
  background-color: rgba(0, 0, 0, 0.42);
}

.subnav li {
  display: flex;
  justify-content: space-between;
  padding-left: 30px;
  padding-right: 12px;
  height: 50px;
  /* background-color: pink; */
  line-height: 50px;
  color: #FFF;

  cursor: pointer;
}

.subnav li a {
  margin-right: 5px;
  font-size: 14px;
  color: #fff;    
}

.subnav li .classify {
  margin-right: 14px;
  font-size: 16px;
}

.subnav li .iconfont {
  font-size: 14px;
}

.subnav li:hover {
  background-color: #00be9a;
}

/* 圆点指示器 */
.banner ol {
  display: flex;
  position: absolute;
  bottom: 17px;
  right: 16px;
}

.banner ol li {
  margin-left: 8px;
  width: 22px;
  height: 22px;
  /* background-color: pink; */
  border-radius: 50%;
  cursor: pointer;
}

.banner ol li i {
  display: block;
  margin: 4px;
  width: 14px;
  height: 14px;
  background-color: rgba(255, 255, 255, 0.5);
  border-radius: 50%;
}

/* 选中转态 li 半透明，i 白色 */
.banner ol .current {
  background-color: rgba(255, 255, 255, 0.5);
}

.banner ol .current i {
  background-color: rgba(255, 255, 255);
}


/* 公共样式 */
/* 新鲜好物区域 */
.title {
  display: flex;
  justify-content: space-between;
  margin-top: 40px;
  margin-bottom: 30px;
  height: 42px;
  /* background-color: pink; */
}

.title .left {
  display: flex;
}

.title .left h3 {
  margin-right: 35px;
  font-size: 30px;
}

.title .left p {
  align-self: flex-end;
  color: #A1A1A1;
}

.title .right .more {
  line-height: 42px;
  color: #A1A1A1;
}

.title .right .more .iconfont {
  margin-left: 10px;
}

/* 好物内容 */
.bd ul {
  display: flex;
  justify-content: space-between;
}

.bd li {
  width: 304px;
  height: 404px;
  background-color: #EEF9F4;
}

.bd li pic {
  width: 304px;
  height: 304px;
}

.bd li .txt {
  text-align: center;
}

.bd li h4 {
  margin-top: 18px;
  margin-bottom: 8px;
  font-size: 20px;
}

.goods .bd p {
  font-size: 18px;
  color: #AA2113;
}

.goods .bd p span {
  margin-left: 3px;
  font-size: 22px;
}

/* 人气推荐区域 */
.recommend bd li {
  background-color: #fff;
}

.recommend bd p {
  color: #A1A1A1;
}

/* 热门品牌区域 */
.brand {
  margin-top: 60px;
  height: 468px;
  background-color: #F5F5F5;
}

.brand .wrapper {
  overflow: hidden;
  height: 468px;
  /* background-color: pink; */
}

.brand .title {
  position: relative;
  margin-bottom: 40px;
}

.brand .button {
  display: flex;
  position: absolute;
  bottom: -25px;
  right: 0;
}

.brand .button a {
  margin-left: 12px;
  width: 20px;
  height: 20px;
  text-align: center;
  line-height: 20px;
  color: #fff;
}

.brand .button .prev {
  background-color: #ddd;
}

.brand .button .next {
  background-color: #00BE9A;
}

.brand .bd li {
  width: 244px;
  height: 306px;
}

/* 生鲜区域 */
.fresh .title {
  margin-top: 60px;
  margin-bottom: 20px;
}

.title .right {
  display: flex;
}

.title .right ul {
  display: flex;
  margin-right: 58px;
  margin-top: 10px;
}

.title .right a {
  display: block;
  margin-left: 6px;
  padding: 0 7px;
  height: 20px;
  line-height: 20px;
}

.title .right ul .active {
  background-color: #00BE9A;
  color: #fff;
}

/* 生鲜内容区域 */
.content {
  display: flex;
  justify-content: space-between;
}

.content .left {
  width: 248px;
  height: 610px;
}

.content .right {
  width: 968px;
  height: 610px;
}

.content .right ul {
  display: flex;
  flex-wrap: wrap;
}

.content .right li {
  position: relative;
  padding: 10px 21px 0;
  width: 242px;
  height: 305px;
  border: 2px solid #fff;
  
  /* 为了隐藏绿色的cover */
  overflow: hidden;
}

.content .pic {
  width: 200px;
  height: 180px;
}

.content .info {
  margin-top: 14px;
  margin-bottom: 5px;
  height: 60px;
  line-height: 19px;
}

.content .price {
  color: #AF2F22;
}

.content .price span {
  font-size: 22px;
}

/* 产品底部绿色区域 */
.content li .cover {
  position: absolute;
  left: 0;
  bottom: -86px;
  padding-top: 15px; 
  width: 242px;
  height: 84px;
  background-color: #00BE9A;
  text-align: center;
  color: #fff;
  transition: all 0.5s;
}

.content .cover p:nth-child(1) {
  font-size: 18px;
}

.content .cover p:nth-child(2) {
  margin: 3px auto 6px;
  width: 120px;
  height: 1px;
  background-color: rgba(255, 255, 255, 0.11);
}

.content .cover p:nth-child(3) {
  font-size: 13px;
}

.content .cover p:nth-child(3) .iconfont {
  font-size: 14px;
}

/* 默认鼠标悬停到 li 显示cover */
.content .right li:hover .cover {
  bottom: 0;
}

.content .right li:hover {
  border: 2px solid #00BE9A;
}


/* 最新专题区域 */
.topic {
  margin-bottom: 40px;
}

.topic .title {
  margin-top: 100px;
}

.topic-bd ul {
  display: flex;
  justify-content: space-between;
}

.topic-bd li {
  width: 405px;
  height: 355px;
  /* background-color: pink; */
}

.topic-bd .pic {
  position: relative;
  width: 405px;
  height: 288px;
}

.topic-bd .txt {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 0 15px;
  width: 405px;
  height: 67px;
  font-size: 14px;
  color: #666;
}

.topic-bd .txt .left {
  display: flex;
}

.topic-bd .txt .left p {
  margin-right: 20px;
}

.topic-bd .txt .left p:nth-child(1) {
  color: #AF2F22;
}

/* 定位区域 - 文字 */
.topic-bd .cover {
  position: absolute;
  left: 0;
  bottom: 0;

  display: flex;
  justify-content: space-between;
  align-items: center;

  padding: 0 15px;
  width: 405px;
  height: 90px;
  background-image: linear-gradient(180deg, rgba(137,137,137,0.00) 0%, rgba(0,0,0,0.90) 100%);
}

.topic-bd .cover .left {
  color: #fff;
}

.topic-bd .cover .left h4 {
  margin-bottom: 4px;
  font-size: 20px;
}

.topic-bd .cover .right {
  padding: 0 7px;
  height: 25px;
  background-color: #fff;
  color: #AA2113;
  font-size: 15px;
}

.topic-bd .cover .right span {
  font-size: 18px;
}

index.html

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="description" content="小兔鲜儿官网，致力于打造全球最大的食品、生鲜电商购物平台。">
  <meta name="keywords" content="小兔鲜儿,食品,生鲜,服装,家电,电商,购物">
  <title>小兔鲜儿-新鲜、惠民、快捷！</title>
  <link rel="shortcut icon" href="favicon.ico" type="image/x-icon">
  <link rel="stylesheet" href="./iconfont/iconfont.css">
  <link rel="stylesheet" href="./css/base.css">
  <link rel="stylesheet" href="./css/common.css">
  <link rel="stylesheet" href="./css/index.css">
</head>
<body>
  <!-- 导航区域 -->
  <div class="shortcut">
    <div class="wrapper">
      <ul>
        <li><a href="#" class="login">请先登录</a></li>
        <li><a href="#">免费注册</a></li>
        <li><a href="#">我的订单</a></li>
        <li><a href="#">会员中心</a></li>
        <li><a href="#">购物中心</a></li>
        <li><a href="#">在线客服</a></li>
        <li><a href="#"><span class="iconfont icon-mobile-phone"></span>请先登录</a></li>
      </ul>
    </div>
  </div>

  <!-- 头部区域 -->
  <div class="header wrapper">
    <!-- logo区域 -->
    <div class="logo">
      <h1><a href="#">小兔鲜</a></h1>
    </div>
    <!-- 导航区域 -->
    <div class="nav">
      <ul>
        <li><a href="#">首页</a></li>
        <li><a href="#">生鲜</a></li>
        <li><a href="#">美食</a></li>
        <li><a href="#">餐厨</a></li>
        <li><a href="#">电器</a></li>
        <li><a href="#">居家</a></li>
        <li><a href="#">洗护</a></li>
        <li><a href="#">孕婴</a></li>
        <li><a href="#">服装</a></li>
      </ul>
    </div>
    <!-- 搜索区域 -->
    <div class="search">
      <span class="iconfont icon-search"></span>
      <input type="text" placeholder="搜一搜">
    </div>
    <!-- 购物车区域 -->
    <div class="cart">
      <span class="iconfont icon-cart-full"></span>
      <i>2</i>
    </div>
  </div>

  <!-- banner 区域 -->
  <div class="banner">
    <div class="wrapper">
      <!-- 图片 --> 
      <ul class="pic">
        <li><a href="#"><img src="./uploads/banner1.png" alt=""></a></li>
        <li><a href="#"><img src="./uploads/banner1.png" alt=""></a></li>
        <li><a href="#"><img src="./uploads/banner1.png" alt=""></a></li>
      </ul>
      <!-- 侧导航 -->
      <div class="subnav">
        <ul>
          <li>
            <div><a href="#" class="classify">生鲜</a><a href="#">水果</a><a href="#">蔬菜</a></div>
            <span class="iconfont icon-arrow-right-bold"></span>
          </li>
          <li>
            <div><a href="#" class="classify">没事</a><a href="#">面点</a><a href="#">干果</a></div>
            <span class="iconfont icon-arrow-right-bold"></span>
          </li>
          <li>
            <div><a href="#" class="classify">餐厨</a><a href="#">数码产品</a></div>
            <span class="iconfont icon-arrow-right-bold"></span>
          </li>
          <li>
            <div><a href="#" class="classify">电器</a><a href="#">床品</a><a href="#">四件套</a><a href="#">被枕</a></div>
            <span class="iconfont icon-arrow-right-bold"></span>
          </li>
          <li>
            <div><a href="#" class="classify">居家</a><a href="#">玩具</a><a href="#">奶粉</a><a href="#">辅食</a></div>
            <span class="iconfont icon-arrow-right-bold"></span>
          </li>
          <li>
            <div><a href="#" class="classify">洗护</a><a href="#">洗发</a><a href="#">洗护</a><a href="#">美妆</a></div>
            <span class="iconfont icon-arrow-right-bold"></span>
          </li>
          <li>
            <div><a href="#" class="classify">孕婴</a><a href="#">奶粉</a><a href="#">玩具</a></div>
            <span class="iconfont icon-arrow-right-bold"></span>
          </li>
          <li>
            <div><a href="#" class="classify">服饰</a><a href="#">女装</a><a href="#">男装</a></div>
            <span class="iconfont icon-arrow-right-bold"></span>
          </li>
          <li>
            <div><a href="#" class="classify">杂货</a><a href="#">户外</a><a href="#">图书</a></div>
            <span class="iconfont icon-arrow-right-bold"></span>
          </li>
          <li>
            <div><a href="#" class="classify">品牌</a><a href="#">品牌制造</a></div>
            <span class="iconfont icon-arrow-right-bold"></span>
          </li>
        </ul>
      </div>
      <!-- 圆点指示器 -->
      <ol>
        <li class="current"><i></i></li>
        <li><i></i></li>
        <li><i></i></li>
      </ol>
    </div>
  </div>

  <!-- 新鲜好物区域 -->
  <div class="goods wrapper">
    <!-- 标题 -->
    <div class="title">
      <div class="left">
        <h3>新鲜好物</h3>
        <p>新鲜出炉 品质靠谱</p>
      </div>
      <div class="right">
        <a href="#" class="more">查看全部<span class="iconfont icon-arrow-right-bold"></span></a>
      </div>
    </div>
    <!-- 内容 -->
    <div class="bd">
      <ul>
        <li>
          <a href="#">
            <div class="pic"><img src="./uploads/goods1.png" alt=""></div>
            <div class="txt">
              <h4>KN95级莫兰迪色防护口罩</h4>
              <p>￥<span>79</span></p>
            </div>
          </a>
        </li>
        <li>
          <a href="#">
            <div class="pic"><img src="./uploads/goods2.png" alt=""></div>
            <div class="txt">
              <h4>紫檀外独板三层普洱茶盒</h4>
              <p>￥<span>566</span></p>
            </div>
          </a>
        </li>
        <li>
          <a href="#">
            <div class="pic"><img src="./uploads/goods1.png" alt=""></div>
            <div class="txt">
              <h4>法拉蒙高颜值记事本可定制</h4>
              <p>￥<span>58</span></p>
            </div>
          </a>
        </li>
        <li>
          <a href="#">
            <div class="pic"><img src="./uploads/goods1.png" alt=""></div>
            <div class="txt">
              <h4>科技布布艺沙发</h4>
              <p>￥<span>3579</span></p>
            </div>
          </a>
        </li>
      </ul>
    </div>
  </div>

  <!-- 人气推荐区域 -->
  <div class="recommend wrapper">
    <!-- 标题 -->
    <div class="title">
      <div class="left">
        <h3>人气推荐</h3>
        <p>人气爆款 不容错过</p>
      </div>
    </div>
    <!-- 内容 -->
    <div class="bd">
      <ul>
        <li>
          <a href="#">
            <div class="pic"><img src="./uploads/recommend1.png" alt=""></div>
            <div class="txt">
              <h4>特惠推荐</h4>
              <p>￥<span>我猜得到 你的想要</span></p>
            </div>
          </a>
        </li>
        <li>
          <a href="#">
            <div class="pic"><img src="./uploads/recommend2.png" alt=""></div>
            <div class="txt">
              <h4>爆款推荐</h4>
              <p>￥<span>人气好物推荐</span></p>
            </div>
          </a>
        </li>
        <li>
          <a href="#">
            <div class="pic"><img src="./uploads/recommend3.png" alt=""></div>
            <div class="txt">
              <h4>节日礼品一站买全</h4>
              <p>￥<span>编辑尽心整理推荐</span></p>
            </div>
          </a>
        </li>
        <li>
          <a href="#">
            <div class="pic"><img src="./uploads/recommend4.png" alt=""></div>
            <div class="txt">
              <h4>鲜花园艺</h4>
              <p>￥<span>给生活增加仪式感</span></p>
            </div>
          </a>
        </li>
      </ul>
    </div>
  </div>

  <!-- 热门品牌区域 -->
  <div class="brand">
    <div class="wrapper">
      <!-- 标题 -->
      <div class="title">
        <div class="left">
          <h3>热门品牌</h3>
          <p>国际经典 品质认证</p>
        </div>
        <div>
          <div class="button">
            <a href="#" class="prev">
              <i class="iconfont icon-arrow-left-bold"></i>
            </a>
            <a href="#" class="next">
              <i class="iconfont icon-arrow-right-bold"></i>
            </a>
          </div>
        </div>
      </div>
      <!-- 内容 -->
       <div class="bd">
        <ul>
          <li><a href="#"><img src="./uploads/hot1.png" alt=""></a></li>
          <li><a href="#"><img src="./uploads/hot2.png" alt=""></a></li>
          <li><a href="#"><img src="./uploads/hot3.png" alt=""></a></li>
          <li><a href="#"><img src="./uploads/hot4.png" alt=""></a></li>
          <li><a href="#"><img src="./uploads/hot5.png" alt=""></a></li>
        </ul>
       </div>
    </div>
  </div>

  <!-- 生鲜区域 -->
  <div class="fresh wrapper">
    <!-- 标题 -->
    <div class="title">
      <div class="left">
        <h3>生鲜</h3>
      </div>
      <div class="right">
        <ul>
          <li><a href="#" class="active">热门</a></li>
          <li><a href="#">蔬菜</a></li>
          <li><a href="#">肉禽蛋</a></li>
          <li><a href="#">水果</a></li>
          <li><a href="#">海鲜</a></li>
          <li><a href="#">零食</a></li>
          <li><a href="#">饮料</a></li>
        </ul>
        <a href="#" class="more">查看全部<span class="iconfont icon-arrow-right-bold"></span></a>
      </div>
    </div>
    <!-- 内容 -->
    <div class="content">
      <div class="left">
        <a href="#"><img src="./uploads/fresh_left.png" alt=""></a>
      </div>
      <div class="right">
        <ul>
          <li>
            <a href="#">
              <div class="pic"><img src="./uploads/fresh1.png" alt=""></div>
              <div class="txt">
                <div class="info">
                  <h4>双味千层，手抓饼烤肉组合</h4>
                  <p>240g/袋 4片装</p>
                  <p>加热即食</p>
                </div>
                <p class="price">￥<span>89.99</span></p>
              </div>
            </a>
            <div class="cover">
              <p>找相似</p>
              <p></p>
              <p>发现更多宝贝<span class="iconfont icon-arrow-right-bold"></span></p>
            </div>
          </li>
          <li>
            <a href="#">
              <div class="pic"><img src="./uploads/fresh2.png" alt=""></div>
              <div class="txt">
                <div class="info">
                  <h4>云南甘蔗慢熬红糖馒头</h4>
                  <p>220g/袋 5个装</p>
                  <p>加热即食</p>
                </div>
                <p class="price">￥<span>9.00</span></p>
              </div>
            </a>
            <div class="cover">
              <p>找相似</p>
              <p></p>
              <p>发现更多宝贝<span class="iconfont icon-arrow-right-bold"></span></p>
            </div>
          </li>
          <li>
            <a href="#">
              <div class="pic"><img src="./uploads/fresh3.png" alt=""></div>
              <div class="txt">
                <div class="info">
                  <h4>日式风味小圆饼</h4>
                  <p>圆形【海盐味】</p>
                  <p>糖果零食</p>
                </div>
                <p class="price">￥<span>588.00</span></p>
              </div>
            </a>
            <div class="cover">
              <p>找相似</p>
              <p></p>
              <p>发现更多宝贝<span class="iconfont icon-arrow-right-bold"></span></p>
            </div>
          </li>
          <li>
            <a href="#">
              <div class="pic"><img src="./uploads/fresh4.png" alt=""></div>
              <div class="txt">
                <div class="info">
                  <h4>全麦奶油浓香小面包</h4>
                  <p>50g*12袋</p>
                  <p>美味西点</p>
                </div>
                <p class="price">￥<span>69.00</span></p>
              </div>
            </a>
            <div class="cover">
              <p>找相似</p>
              <p></p>
              <p>发现更多宝贝<span class="iconfont icon-arrow-right-bold"></span></p>
            </div>
          </li>
          <li>
            <a href="#">
              <div class="pic"><img src="./uploads/fresh5.png" alt=""></div>
              <div class="txt">
                <div class="info">
                  <h4>秘制外皮五福摩提大福点心</h4>
                  <p>150g/盒</p>
                  <p>美味西点</p>
                </div>
                <p class="price">￥<span>39.99</span></p>
              </div>
            </a>
            <div class="cover">
              <p>找相似</p>
              <p></p>
              <p>发现更多宝贝<span class="iconfont icon-arrow-right-bold"></span></p>
            </div>
          </li>
          <li>
            <a href="#">
              <div class="pic"><img src="./uploads/fresh6.png" alt=""></div>
              <div class="txt">
                <div class="info">
                  <h4>水果面膜韩国蜂蜜柚子茶</h4>
                  <p>560g/瓶</p>
                  <p>冲调饮品</p>
                </div>
                <p class="price">￥<span>89.99</span></p>
              </div>
            </a>
            <div class="cover">
              <p>找相似</p>
              <p></p>
              <p>发现更多宝贝<span class="iconfont icon-arrow-right-bold"></span></p>
            </div>
          </li>
          <li>
            <a href="#">
              <div class="pic"><img src="./uploads/fresh7.png" alt=""></div>
              <div class="txt">
                <div class="info">
                  <h4>浓情比利时巧克力礼盒装</h4>
                  <p>2406g/盒</p>
                  <p>糖果零食</p>
                </div>
                <p class="price">￥<span>120.00</span></p>
              </div>
            </a>
            <div class="cover">
              <p>找相似</p>
              <p></p>
              <p>发现更多宝贝<span class="iconfont icon-arrow-right-bold"></span></p>
            </div>
          </li>
          <li>
            <a href="#">
              <div class="pic"><img src="./uploads/fresh8.png" alt=""></div>
              <div class="txt">
                <div class="info">
                  <h4>抹茶奶油小蛋糕礼盒装</h4>
                  <p>220g/盒</p>
                  <p>加热即食</p>
                </div>
                <p class="price">￥<span>60.00</span></p>
              </div>
            </a>
            <div class="cover">
              <p>找相似</p>
              <p></p>
              <p>发现更多宝贝<span class="iconfont icon-arrow-right-bold"></span></p>
            </div>
          </li>
        </ul>
      </div>
    </div>
  </div>

  <!-- 最新专题区域 -->
  <div class="topic wrapper">
    <!-- 标题 -->
    <div class="title">
      <div class="left">
        <h3>最新专题</h3>
      </div>
      <div class="right">
        <a href="#" class="more">查看全部<span class="iconfont icon-arrow-right-bold"></span></a>
      </div>
    </div>
    <!-- 内容 -->
    <div class="topic-bd">
      <ul>
        <li>
          <div class="pic">
            <img src="./uploads/topic1.png" alt="">
            <!-- 定位区域 -->
            <div class="cover">
              <div class="left">
                <h4>吃这些美食才不算辜负自己</h4>
                <p>餐厨起居洗护好物</p>
              </div>
              <div class="right">￥<span>29.9</span><span>起</span></div>
            </div>
          </div>
          <div class="txt">
            <div class="left">
              <p>
                <i class="iconfont icon-favorites-fill"></i>
                <span>1220</span>
              </p>
              <p>
                <i class="iconfont icon-browse"></i>
                <span>1800</span>
              </p>
            </div>
            <div class="right">
              <p>
                <i class="iconfont icon-comment"></i>
                <span>246</span>
              </p>
            </div>
          </div>
        </li>
        <li>
          <div class="pic">
            <img src="./uploads/topic2.png" alt="">
            <!-- 定位区域 -->
            <div class="cover">
              <div class="left">
                <h4>吃这些美食才不算辜负自己</h4>
                <p>餐厨起居洗护好物</p>
              </div>
              <div class="right">￥<span>29.9</span><span>起</span></div>
            </div>
          </div>
          <div class="txt">
            <div class="left">
              <p>
                <i class="iconfont icon-favorites-fill"></i>
                <span>1220</span>
              </p>
              <p>
                <i class="iconfont icon-browse"></i>
                <span>1800</span>
              </p>
            </div>
            <div class="right">
              <p>
                <i class="iconfont icon-comment"></i>
                <span>246</span>
              </p>
            </div>
          </div>
        </li>
        <li>
          <div class="pic">
            <img src="./uploads/topic3.png" alt="">
            <!-- 定位区域 -->
            <div class="cover">
              <div class="left">
                <h4>吃这些美食才不算辜负自己</h4>
                <p>餐厨起居洗护好物</p>
              </div>
              <div class="right">￥<span>29.9</span><span>起</span></div>
            </div>
          </div>
          <div class="txt">
            <div class="left">
              <p>
                <i class="iconfont icon-favorites-fill"></i>
                <span>1220</span>
              </p>
              <p>
                <i class="iconfont icon-browse"></i>
                <span>1800</span>
              </p>
            </div>
            <div class="right">
              <p>
                <i class="iconfont icon-comment"></i>
                <span>246</span>
              </p>
            </div>
          </div>
        </li>
      </ul>
    </div>
  </div>

  <!-- 底部区域 -->
  <div class="footer">
    <div class="wrapper">
      <!-- 服务区域 -->
      <div class="service">
        <ul>
          <li>
            <h5></h5>
            <p>价格亲民</p>
          </li>
          <li>
            <h5></h5>
            <p>物流快捷</p>
          </li>
          <li>
            <h5></h5>
            <p>品质新鲜</p>
          </li>
          <li>
            <h5></h5>
            <p>售后无忧</p>
          </li>
        </ul>
      </div>
      <!-- 帮助中心区域 -->
      <div class="help">
        <div class="left">
          <dl>
            <dt>购物指南</dt>
            <dd><a href="#">购物流程</a></dd>
            <dd><a href="#">支付方式</a></dd>
            <dd><a href="#">售后规则</a></dd>
          </dl>
          <dl>
            <dt>配送方式</dt>
            <dd><a href="#">配送运费</a></dd>
            <dd><a href="#">配送范围</a></dd>
            <dd><a href="#">配送时间</a></dd>
          </dl>
          <dl>
            <dt>关于我们</dt>
            <dd><a href="#">平台规则</a></dd>
            <dd><a href="#">联系我们</a></dd>
            <dd><a href="#">问题反馈</a></dd>
          </dl>
          <dl>
            <dt>售后服务</dt>
            <dd><a href="#">售后政策</a></dd>
            <dd><a href="#">退款说明</a></dd>
            <dd><a href="#">取消订单</a></dd>
          </dl>
          <dl>
            <dt>服务热线</dt>
            <dd><a href="#">在线客服<span class="iconfont icon-customer-service"></span></a></dd>
            <dd><a href="#">客服电话 400-0000-000</a></dd>
            <dd><a href="#">工作时间 周一至周日 8:00-18:00</a></dd>
          </dl>
        </div>
        <div class="right">
          <ul>
            <li>
              <div class="pic"><img src="./images/wechat.png" alt=""></div>
              <p>微信公众号</p>
            </li>
            <li>
              <div class="pic"><img src="./images/app.png" alt=""></div>
              <p>APP下载二维码</p>
            </li>
          </ul>
        </div>
      </div>
      <!-- 版权区域 -->
      <div class="copywrite">
        <p>
          <a href="#">关于我们</a>|
          <a href="#">帮助中心</a>|
          <a href="#">售后服务</a>|
          <a href="#">配送与验收</a>|
          <a href="#">商务合作</a>|
          <a href="#">搜索推荐</a>|
          <a href="#">友情链接</a>
        </p>
        <p>CopyRight © 小兔鲜</p>
      </div>
    </div>
  </div>
</body>
</html>

总结

如代码中注释

HTML5+CSS303-综合页面设计

Tue, 28 Nov 2023 05:30:00 GMT

第七天笔记

综合页面设计

项目目录

网站根目录是指存放网站的第一层文件夹，内部包含当前网站的所有素材，包含HTML、cSS、图片、JavaScript等等。

study
- images 文件夹：存放固定使用的图片素材，例如：logo、样式修饰图等等
- uploads 文件夹：存放非固定使用的图片素材，例如：商品图、宣传图需要上传的图片
- css 文件夹：存放 CSS 文件（ link 标签引入）
  - base.css：基础公共样式，例如：清除默认样式、设置网页基本样式
  - index.css：首页 CSS 样式
- index.html：首页 HTML 文件

网页制作思路

布局思路：先整体再局部，从外到内，从上到下，从左到右
css 实现思路
画盒子，调整盒子范围 → 宽高背景色
调整盒子位置 → flex 布局、内外边距
控制图片、文字内容样式

网页预览

页面从上到下由页头、横幅、精品推荐、课程列表和页脚组成。页头版心内依次安排 logo、导航、搜索与用户信息；横幅左侧放分类导航，右侧放课程表；下方课程区用可换行的 Flex 列表组织卡片。阅读后面的代码时，先核对各区域的嵌套关系，再检查宽度、间距和文字样式。示例 CSS 使用固定 1200px 版心，窄屏时需要另行设计适配，不能把桌面布局直接视为响应式布局。

布局设计

header 区域 - 布局与功能

通栏：宽度与浏览器窗口相同的盒子
标签结构：通栏 > 版心 > logo ＋导航＋搜索＋用户

logo 区域 - 布局与功能

logo功能

单击跳转到首页
搜索引擎优化：提升网站百度搜索排名

实现方法

标签结构：h1 > a > 网站名称（搜索关键字）
css 样式

导航（nav）区域 - 布局与功能

导航功能

单击跳转页面

实现方法

标签结构：ul > li * 3 > a
优势：避免堆砌 a 标签，网站搜索排名降级
布局思路
- li 设置右侧 margin
- a 设置左右 padding

搜索（search）区域 - 布局与功能

实现方法

标签结构：.search > input + a / button

用户（user）区域 - 布局与功能

实现方法

标签结构：.user > a > img + span

banner 区域 - 布局与功能

实现方法

标签结构：通栏 banner > 版心 > .left + .right

左侧导航栏（left）

实现方法

标签结构：.left > ul > li * 9 > a
布局思路：a 默认状态：背景图为白色右箭头

右侧课程表（right）

实现方法

标签结构：.right > h3 + .content

精品推荐（recommend）区域 - 布局和功能

实现方法

标签结构：.recommend > h3 + ul + a.modify
布局思路：flex 布局

精品课程（course）区域 - 布局和功能

实现方法

标签结构：.hd + .bd
布局思路：盒子模型

base.css

* {
    margin: 0;
    padding: 0;
    box-sizing: border-box;
}

li {
    list-style: none;
}

body {
    font: 14px/1.5 "Microsoft Yahei", "Hiragino Sans GB", "Heiti SC", "WenQuanYi Micro Hei", sans-serif;
    color: #333;
}

a {
    color: #333;
    text-decoration: none;
}

index.css

/* 首页样式 */

/* 版心样式 */
.wrapper {
    margin: 0 auto;
    width: 1200px;
}

body {
    background-color: #f3f5f7;
}


/* 头部区域样式 */
.header {
    height: 100px;
    background-color: #fff;
}

.header .wrapper {
    padding-top: 29px;
    display: flex;
}


/* logo 区域 */
.logo a {
    display: block;

    width: 195px;
    height: 41px;
    background-image: url(../images/logo.png);

    /* 隐藏文字 */
    font-size: 0;
}


/* 导航区域 */
.nav {
    margin-left: 102px;
}

.nav ul {
    display: flex;
}

.nav ul li {
    margin-right: 24px;
}

.nav ul a {
    display: block;
    padding: 6px 8px;

    line-height: 27px;
    font-size: 19px;
}

/* active 类选择器，表示默认选中的 a */
.nav li .active,
.nav li a:hover {
    border-bottom: 2px solid #00a4ff;
}


/* 搜索区域 */
.search {
    display: flex;
    margin-left: 64px;
    padding-left: 19px;
    padding-right: 12px;
    width: 412px;
    height: 40px;
    background-color: #f3f5f7;
    border-radius: 20px;
}

.search input {
    flex: 1;
    border: 0;
    background-color: transparent;
    outline: none;
}

.search::placeholder {
    font-size: 14px;
    color: #999;
}

/* 父级 flex 布局，子集的宽高生效 */
.search a {
    align-self: center;

    width: 16px;
    height: 16px;
    background-image: url(../images/search.png);
}


/* 用户区域 */
.user {
    margin-left: 32px;
    margin-top: 4px;
}

.user img {
    margin-right: 7px;
    /* vertical-align 行内块和行内垂直方向对齐方式 */
    vertical-align: middle;
}

.user span {
    font-size: 16px;
    color: #666
}


/* banner区域 */
.banner {
    height: 420px;
    background-color: #0092cd;
}

.banner .wrapper {
    display: flex;
    justify-content: space-between;
    height: 420px;
    background-image: url(../uploads/banner.png);
}


/* 侧导航区域 */
.banner .left {
    padding: 3px 20px;

    width: 191px;
    height: 420px;
    background-color: rgba(0, 0, 0, 0.42);
}

.banner .left a {
    /* 块级：宽度是父级的 100% */
    display: block;

    height: 46px;
    background: url(../images/right.png) no-repeat right center;

    line-height: 46px;

    font-size: 16px;
    color: #fff;
}

.banner .left a:hover {
    background-image: url(../images/right-hover.png);
    color: #00a4ff;
}


/* 课程表区域 */
.banner .right {
    margin-top: 60px;
    width: 218px;
    height: 305px;
    background-color: #209dd5;
    border-radius: 10px;
}

.banner .right h3 {
    margin-left: 14px;
    height: 48px;
    line-height: 48px;
    font-size: 15px;
    color: #fff;
    font-weight: 400;
}

.right .content {
    padding: 14px;
    height: 257px;
    background-color: #fff;
    border-radius: 10px;
}

.banner .right dl {
    margin-bottom: 12px;
    border-bottom: 1px solid #e0e0e0;
}

.banner .right dt {
    margin-bottom: 8px;
    font-size: 14px;
    line-height: 20px;
    font-weight: 700;
}

.banner .right dd {
    margin-bottom: 8px;
    font-size: 12px;
    line-height: 16px;
}

.banner .right dd span {
    color: #00a4ff;
}

.banner .right dd strong {
    color: #7d7d7d;
    font-weight: 400;
}

.banner .right a {
    display: block;
    height: 32px;
    background-color: #00a4ff;
    text-align: center;
    line-height: 32px;
    font-size: 14px;
    color: #fff;
    border-radius: 15px;
}


/* 精品推荐区域 */
.recommend {
    display: flex;
    margin-top: 11px;
    padding: 0 20px;
    height: 60px;
    background-color: #fff;
    box-shadow: 0px 1px 2px 0px rgba(211, 211, 211, 0.5);
    line-height: 60px;
}

.recommend h3 {
    font-size: 18px;
    color: #00a4ff;
    font-weight: 400;
}

.recommend ul {
    display: flex;
    /* 除去标题和修改兴趣的尺寸，父级剩余尺寸都给ul，实现把修改兴趣挤到最右侧 */
    flex: 1;
}

.recommend ul li a {
    padding: 0 24px;
    border-right: 1px solid #e0e0e0;;
    font-size: 18px;
}

.recommend ul li:last-child a {
    border-right: none;
}

.recommend .modify {
    font-size: 16px;
    color: #00a4ff;
}


/* 精品推荐课程区域 */
.course {
    margin-top: 15px;
}

/* 标题，公共类，与其他的标题共用 */
.hd {
    display: flex;
    justify-content: space-between;
    height: 60px;
    line-height: 60px;
}

.hd h3 {
    font-size: 21px;
    font-weight: 400;
}

.hd .more {
    padding-right: 20px;
    background: url(../images/more.png) no-repeat right center;
    font-size: 14px;
    color: #999;
}

/* 课程内容，公共类 */
.bd ul {
    display: flex;
    flex-wrap: wrap;
    justify-content: space-between;
}

.bd li {
    margin-bottom: 14px;
    width: 228px;
    height: 271px;
    background-color: pink;
}

.bd li .pic {
    height: 156px;
}

.bd li .text {
    padding: 20px;
    height: 115px;
    background-color: #fff;
}

.bd li .text h4 {
    margin-bottom: 13px;
    height: 40px;
    font-size: 14px;
    line-height: 20px;
    font-weight: 400;
}

.bd li .text p {
    font-size: 14px;
    line-height: 20px;
    color: #999;
}

.bd li .text p span {
    color: #fa6400;
}

.bd li .text p i {
    font-style: normal;
}


/* 前端开发工程师 */
.hd ul {
    display: flex;
}

.hd li {
    margin-right: 60px;
    font-size: 16px;
}

.hd li .active {
    color: #00a4ff;
}

.hd li a:hover {
    color: #00a4ff;
}

.bd {
    display: flex;
    justify-content: space-between;
}

.bd .left {
    width: 228px;
}

.bd .right {
    width: 957px;
}

.bd .right .top {
    margin-bottom: 15px;
    height: 100px;
}


/* 版权区域 */
.footer {
    margin-top: 60px;
    padding-top: 60px;
    height: 273px;
    background-color: #fff;
}

.footer .wrapper {
    display: flex;
    justify-content: space-between;
}

.footer .left {
    width: 440px;
}

.footer .left p {
    margin-top: 24px;
    margin-bottom: 14px;
    font-size: 12px;
    line-height: 17px;
    color: #666;
}

.footer .left .download {
    display: block;
    width: 120px;
    height: 36px;
    border: 1px solid #00a4ff;
    text-align: center;
    line-height: 34px;
    font-size: 16px;
    color: #00a4ff;
}

.footer .right {
    display: flex;
}

.footer .right dl {
    margin-left: 130px;
}

.footer .right dt {
    margin-bottom: 12px;
    font-size: 16px;
    line-height: 23px;
}

.footer .right a {
    font-size: 14px;
    color: #666;
    line-height: 24px;
}

.footer .right a:hover {
    color: #00a4ff;
}

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>学成在线</title>
    <!-- 注意！！！顺序要求：先清除，再设置 -->
    <link rel="stylesheet" href="./css/base.css">
    <link rel="stylesheet" href="./css/index.css">
</head> 
<body>
    <!-- 头部区域 -->
    <div class="header">
        <div class="wrapper">
            <!-- logo -->
            <div class="logo">
                <h1><a href="#">学成在线</a></h1>
            </div>
            <!-- 导航 -->
            <div class="nav">
                <ul>
                    <li><a href="#" class="active">首页</a></li>
                    <li><a href="#">课程</a></li>
                    <li><a href="#">职业规划</a></li>
                </ul>
            </div>
            <!-- 搜索 -->
            <div class="search">
                <input type="text" placeholder="请输入关键字词">
                <a href="#"></a>
            </div>
            <!-- 用户 -->
            <div class="user">
                <a href="#">
                    <img src="./uploads/user.png" alt="">
                    <span>前端用户</span>
                </a>
            </div>
        </div>
    </div>

    <!-- banner 区域 -->
    <div class="banner">
        <div class="wrapper">
            <div class="left">
                <ul>
                    <li><a href="#">前端开发</a></li>
                    <li><a href="#">后端开发</a></li>
                    <li><a href="#">移动开发</a></li>
                    <li><a href="#">人工智能</a></li>
                    <li><a href="#">商业预测</a></li>
                    <li><a href="#">云计算&大数据</a></li>
                    <li><a href="#">运维&测试</a></li>
                    <li><a href="#">UI设计</a></li>
                    <li><a href="#">产品</a></li>
                </ul>
            </div>
            <div class="right">
                <h3>我的课程表</h3>
                <div class="content">
                    <dl>
                        <dt>数据可视化课程</dt>
                        <dd><span>正在学习</span>-<strong>echarts使用步骤</strong></dd>
                    </dl>
                    <dl>
                        <dt>Vue3医疗项目课程</dt>
                        <dd><span>正在学习</span>-<strong>认识组合式API</strong></dd>
                    </dl>
                    <dl>
                        <dt>React核心技术课程</dt>
                        <dd><span>正在学习</span>-<strong>rudex配合TS使用</strong></dd>
                    </dl>
                    <a href="#">全部课程</a>
                </div>
            </div>
        </div>
    </div>

    <!-- 精品推荐区域 -->
    <div class="recommend wrapper">
        <h3>精品推荐</h3>
        <ul>
            <li><a href="#">HTML</a></li>
            <li><a href="#">CSS</a></li>
            <li><a href="#">JavaScript</a></li>
            <li><a href="#">Node.js</a></li>
            <li><a href="#">Ajax</a></li>
            <li><a href="#">Vue2.0</a></li>
            <li><a href="#">Vue3.0</a></li>
            <li><a href="#">TypeScript</a></li>
            <li><a href="#">React</a></li>
        </ul>
        <a href="#" class="modify">修改兴趣</a>
    </div>

    <!-- 精品课程推荐区域 -->
    <div class="course wrapper">
        <!-- 标题 -->
        <div class="hd">
            <h3>精品推荐</h3>
            <a href="#" class="more">查看全部</a>
        </div>
        <!-- 课程 -->
        <div class="bd">
            <ul>
                <li>
                    <a href="#">
                        <div class="pic"><img src="./uploads/course01.png" alt=""></div>
                        <div class="text">
                            <h4>JavaScript数据看板项目实战</h4>
                            <p><span>高级</span> - <i>1126</i>人在学习</p>
                        </div>
                    </a>
                </li>
                <li>
                    <a href="#">
                        <div class="pic"><img src="./uploads/course01.png" alt=""></div>
                        <div class="text">
                            <h4>JavaScript数据看板项目实战</h4>
                            <p><span>高级</span> - <i>1126</i>人在学习</p>
                        </div>
                    </a>
                </li>
                <li>
                    <a href="#">
                        <div class="pic"><img src="./uploads/course01.png" alt=""></div>
                        <div class="text">
                            <h4>JavaScript数据看板项目实战</h4>
                            <p><span>高级</span> - <i>1126</i>人在学习</p>
                        </div>
                    </a>
                </li>
                <li>
                    <a href="#">
                        <div class="pic"><img src="./uploads/course01.png" alt=""></div>
                        <div class="text">
                            <h4>JavaScript数据看板项目实战</h4>
                            <p><span>高级</span> - <i>1126</i>人在学习</p>
                        </div>
                    </a>
                </li>
                <li>
                    <a href="#">
                        <div class="pic"><img src="./uploads/course01.png" alt=""></div>
                        <div class="text">
                            <h4>JavaScript数据看板项目实战</h4>
                            <p><span>高级</span> - <i>1126</i>人在学习</p>
                        </div>
                    </a>
                </li>
                <li>
                    <a href="#">
                        <div class="pic"><img src="./uploads/course01.png" alt=""></div>
                        <div class="text">
                            <h4>JavaScript数据看板项目实战</h4>
                            <p><span>高级</span> - <i>1126</i>人在学习</p>
                        </div>
                    </a>
                </li>
                <li>
                    <a href="#">
                        <div class="pic"><img src="./uploads/course01.png" alt=""></div>
                        <div class="text">
                            <h4>JavaScript数据看板项目实战</h4>
                            <p><span>高级</span> - <i>1126</i>人在学习</p>
                        </div>
                    </a>
                </li>
                <li>
                    <a href="#">
                        <div class="pic"><img src="./uploads/course01.png" alt=""></div>
                        <div class="text">
                            <h4>JavaScript数据看板项目实战</h4>
                            <p><span>高级</span> - <i>1126</i>人在学习</p>
                        </div>
                    </a>
                </li>
                <li>
                    <a href="#">
                        <div class="pic"><img src="./uploads/course01.png" alt=""></div>
                        <div class="text">
                            <h4>JavaScript数据看板项目实战</h4>
                            <p><span>高级</span> - <i>1126</i>人在学习</p>
                        </div>
                    </a>
                </li>
                <li>
                    <a href="#">
                        <div class="pic"><img src="./uploads/course01.png" alt=""></div>
                        <div class="text">
                            <h4>JavaScript数据看板项目实战</h4>
                            <p><span>高级</span> - <i>1126</i>人在学习</p>
                        </div>
                    </a>
                </li>
            </ul>
        </div>
    </div>

    <!-- 前端开发工程师 -->
    <div class="wrapper">
        <div class="hd">
            <h3>前端开发工程师</h3>
            <ul>
                <li><a href="#" class="active">热门</a></li>
                <li><a href="#">初级课程</a></li>
                <li><a href="#">中级课程</a></li>
                <li><a href="#">高级课程</a></li>
            </ul>
            <a href="#" class="more">查看全部</a>
        </div>
        <div class="bd">
            <div class="left">
                <img src="./uploads/web_left.png" alt="">
            </div>
            <div class="right">
                <div class="top"><img src="./uploads/web_top.png" alt=""></div>
                <div class="bottom">
                    <ul>
                        <li>
                            <a href="#">
                                <div class="pic"><img src="./uploads/course01.png" alt=""></div>
                                <div class="text">
                                    <h4>JavaScript数据看板项目实战</h4>
                                    <p><span>高级</span> - <i>1126</i>人在学习</p>
                                </div>
                            </a>
                        </li>
                        <li>
                            <a href="#">
                                <div class="pic"><img src="./uploads/course01.png" alt=""></div>
                                <div class="text">
                                    <h4>JavaScript数据看板项目实战</h4>
                                    <p><span>高级</span> - <i>1126</i>人在学习</p>
                                </div>
                            </a>
                        </li>
                        <li>
                            <a href="#">
                                <div class="pic"><img src="./uploads/course01.png" alt=""></div>
                                <div class="text">
                                    <h4>JavaScript数据看板项目实战</h4>
                                    <p><span>高级</span> - <i>1126</i>人在学习</p>
                                </div>
                            </a>
                        </li>
                        <li>
                            <a href="#">
                                <div class="pic"><img src="./uploads/course01.png" alt=""></div>
                                <div class="text">
                                    <h4>JavaScript数据看板项目实战</h4>
                                    <p><span>高级</span> - <i>1126</i>人在学习</p>
                                </div>
                            </a>
                        </li>
                    </ul>
                </div>
            </div>
        </div>
    </div>

    <!-- 版权区域 -->
    <div class="footer">
        <div class="wrapper">
            <div class="left">
                <a href="#"><img src="./images/logo.png" alt=""></a>
                <p>学成在线致力于普及中国最好的教育它与中国一流大学和机构合作提供在线课程。
                    © 2017年XTCG Inc.保留所有权利。-沪ICP备15025210号</p>
                <a href="#" class="download">下载APP</a>
            </div>
            <div class="right">
                <dl>
                    <dt>合作伙伴</dt>
                    <dd><a href="#">合作机构</a></dd>
                    <dd><a href="#">合作导师</a></dd>
                </dl>
                <dl>
                    <dt>合作伙伴</dt>
                    <dd><a href="#">合作机构</a></dd>
                    <dd><a href="#">合作导师</a></dd>
                </dl>
                <dl>
                    <dt>合作伙伴</dt>
                    <dd><a href="#">合作机构</a></dd>
                    <dd><a href="#">合作导师</a></dd>
                </dl>
            </div>
        </div>
    </div>
</body>
</html>

总结

如代码中注释

HTML5+CSS302-CSS

Thu, 23 Nov 2023 11:30:00 GMT

第三天笔记

CSS

层叠样式表(Cascading Style Sheets，缩写为CSS)，是一种样式表语言，用来描述HTML文档的呈现(美化内容)

书写位置：title标签下方添加style双标签，style标签里面书写CSS代码。

示例代码如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>CSS</title>
</head>
<style>
    /* CSS 代码 */
    /* 选择器 { CSS 属性 } */
    /* 属性名和属性值成对出现 -> 键值对 */
    p {
        color: red; /* 修改字体颜色 */
        font-size: 30px; /* 修改字体大小 */
    }
</style>
<body>
    <p>体验css</p>
</body>
</html>

CSS 引入方式

内部样式表：学习使用
- CSS代码写在style标签里面
外部样式表：开发使用
- CSS代码写在单独的CSS文件中（.css）
- 在 .html 文件中使用 link 标签引入
```
<link rel="stylesheet" href="./my.css">
```
行内样式：配合JavaScript使用
- CSS代码写在style属性里面
```
<div style="color: red; font-size: 30px">
    xxx
</div>
```

CSS选择器

作用：查找标签，设置样式

基础选择器：

标签选择器
类选择器
id选择器
通配符选择器

标签选择器

作用：使用标签名作为选择器 → 选中同名标签设置相同的样式。因此无法差异化同名标签的样式

例如：p h1 div a

类选择器

作用：查找标签，差异化设置标签的显示效果。

步骤：

定义类选择器 —> .类名
使用类选择器 —> 标签加 class=“类名”

示例代码：（一个类选择器可以个多个标签使用，一个标签也可以使用多个类名）

<style>
	/* 定义类选择器 */
    .red {
        color: red;
    }
    .size {
        font-size: 30px;
    }
</style>

<!-- 使用类选择器 -->
<div class="red size">
    芝士div标签
</div>

开发习惯：类名见名知意，多个单词可以用–连接，例如:news-hd（新闻头部）

id选择器

作用：查找标签，差异化设置标签的显示效果。

场景：id选择器一般配合JavaScript使用，很少用来设置CSS样式

步骤：

定义 id 选择器 —> #id名
使用 id 选择器 —> 标签加 id=“id名”

规则：同一个id选择器在一个页面只能使用一次

示例代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<style>
    #red {
        color: red; /* 修改字体颜色 */
        font-size: 30px; /* 修改字体大小 */
    }
</style>
<body>
    <div id="red">芝士div标签</div>
</body>
</html>

通配符选择器

作用：查找页面所有标签，设置相同样式。

通配符选择器：*，不需要调用，浏览器自动查找页面所有标签，设置相同的样式

示例代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<style>
    * {
        color: red; /* 修改字体颜色 */
        font-size: 30px; /* 修改字体大小 */
    }
</style>
<body>
    <div id="red">芝士div标签</div>
</body>
</html>

画盒子

目标：使用合适的选择器画盒子

新属性：

属性名	作用
width	宽度
height	高度
background-color	背景色

字体修饰属性

字体修饰可以按职责分开记忆：font-size 控制字号，font-weight 控制粗细，font-style 控制倾斜，line-height 控制行高，font-family 指定字体与回退顺序。先分别调整这些属性观察差异，再使用 font 简写；简写中的字号与字体族不可省略，行高紧随字号并用斜杠连接。多字体列表从左向右匹配，最后保留通用字体族作为回退。

字体粗细

属性名：font-weight
属性值：
- 数字（开发使用） | 大小 | 数值 |
  | — | —- |
  | 正常 | 400 |
  | 加粗 | 700 |
- 关键字 | 大小 | 关键字 |
  | — | ——— |
  | 正常 | normal |
  | 加粗 | bold |

字体倾斜

作用：清除文字默认的倾斜效果
属性名：font-style
属性值：
- 正常（不倾斜）：normal
- 倾斜：italic

行高

作用：调整多行文本间的间距
属性名：line-height
属性值：
- 数字+px
- 数字（当前标签 font-size 属性值的倍数）

行高的垂直居中技巧：行高属性值等于盒子的高度属性值

注意：只适用于单行区域

字体族

属性名：font-family
属性值：字体名

font-family: 楷体;

font-family: Microsoft YaHlei, Heiti SC, tahoma, arial, Hiragino Sans GB, “\5B8B\4F53”, sans-serif;

拓展（了解）：font-family属性值可以书写多个字体名，各个字体名用逗号隔开，执行顺序是从左向右依次查找
font-family 属性最后设置一个字体族名，网页开发建议使用无衬线字体

font 复合属性

使用场景：设置网页文字公共样式
复合属性：属性的简写方式，一个属性对应多个值的写法，各个属性值之间用空格隔开。
font：是否倾斜是否加粗字号/行高字体族（必须按顺序书写)

div{
font: italic 700 30px/2 楷体;
}

字号和字体值必须书写，否则font属性不生效

文本缩进

属性名：text-indent
属性值
- 数字+px
- 数字+em（推荐：1 em = 当前标签的字号大小）

文本对齐

作用：控制内容水平对齐方式
属性名：text-align
属性值

属性值	效果
left	左对齐（默认）
center	居中对齐
right	右对齐

修饰线

属性名：text-decoration
属性值

属性值	效果
none	无
underline	下划线
line-through	删除线
overline	上划线

颜色

属性名：color
属性值

颜色表示方式	属性值	说明	使用场景
颜色关键字	颜色英文单词	red、green、blue…	学习测试
rgb表示法	rgb(r, g, b)	r，g，b表示红绿蓝三原色，取值：0~255	了解
rgba表示法	rgba(r, g, b, a)	a表示透明度，取值：0~1	开发使用，实现透明色
十六进制表示法	#RRGGBB	#000000，#ffcc00，简写：#000，#fc0	开发使用（从设计稿复制）

复合选择器

定义：由两个或多个基础选择器，通过不同的方式组合而成。
作用：更准确、更高效的选择目标元素（标签）。

后代选择器

后代选择器：选中某元素的后代元素。

选择器写法：父选择器子选择器 {CSS属性} 父子选择器之间用空格隔开

<style>
	div span {
		color: red;
	}
<style>

<span>span标签</span>
<div>
	<span>这是div的儿子</span>
</div>

子代选择器

子代选择器：选中某元素的子代元素。

选择器写法：父选择器 > 子选择器 {CSS属性} 父子选择器之间用 > 隔开

<style>
	div > span {
		color: red;
	}
<style>

<div>
	<span>这是div里面的</span>
	<p>
		<span>这是div里面的p里面的</span>
	</p>
</div>

并集选择器

并集选择器：选中多组标签设置相同的样式。

选择器写法：选择器1，选择器2，…，选择器n {CSS属性}，选择器之间用逗号隔开

<style>
	div,
	p,
	span {
		color: red;
	}
<style>

<div>div标签</div>
<p>p标签</p>
<span>span标签</span>

交集选择器—-了解

交集选择器：选中同时满足多个条件的元素。

选择器写法：选择器1选择器2 {CSS属性}，选择器之间连写，没有任何符号

注意：如果交集选择器中有标签选择器，标签选择器必须书写在最前面

<style>
	p.box {
		color: red;
	}
<style>

<p class="box">p标签，使用了类选择器 box</p>
<p>p标签</p>
<div class="box">div标签，使用了类选择器 box</div>

伪类选择器

伪类选择器：伪类表示元素状态，选中元素的某个状态设置样式。

鼠标悬停状态：选择器:hover {SSS属性}

<style>
	a:hover {
		color: red;
	}

	.box:hover {
		color: green;
	}
</style>

<a href="#">a标签</a>
<div> class="box">div 标签</div>

伪类：超链接

超链接一共有四个状态

选择器	作用
:link	访问前
:visited	访问后
:hover	鼠标悬停
:active	点击时: 激活

提示：如果要给超链接设置以上四个状态，需要按 LVHA 的顺序书写。

CSS 特性

CSS 特性：化简代码 / 定位问题，并解决问题

继承性
层叠性
优先级

继承性

继承性：子级标签默认继承父级的文字控制属性

注意：若标签自己有属性则不继承

层叠性

特点：

相同的属性会覆盖：后面的 CSS 属性覆盖前面的 CSS 属性
不同的属性会叠加：不同的 CSS 属性都生效

优先级

优先级：也叫权重，当一个标签使用了多种选择器时，基于不同种类的选择器的匹配规则。

规则：选择器优先级高的样式生效。

公式：通配符选择器 < 标签选择器 < 类选择器 < id 选择器 < 行内样式 < !Important

(选中标签的范围越大，优先级越低)

优先级 - 叠加计算原则

叠加计算：如果是复合选择器，则需要权重叠加计算。

公式：（每一级之间不存在进位）

（行内样式,，id 选择器个数，类选择器个数，标签选择器个数）

规则：

从左向右依次比较选个数，同一级个数多的优先级高，如果个数相同，则向后比较
!Important 权重最高
继承权重最低

Emmet 写法

Emmet 写法: 代码的简写方式，输入缩写 VS code 会自动生成对应的代码。

HTML

<table> <thead> <tr> <th>说明</th> <th>标签结构</th> <th>Emmet</th> </tr> </thead> <tbody> <tr> <td>类选择器</td> <td><div class="box"></div></td> <td>标签名.类名</td> </tr> <tr> <td>id 选择器</td> <td><div id="box"></div></td> <td>标签名#id名</td> </tr> <tr> <td>同级标签</td> <td><div></div><p></p></td> <td>div+p</td> </tr> <tr> <td>父子级标签</td> <td><div><p></p></div></td> <td>div>p</td> </tr> <tr> <td>多个相同标签</td> <td><span>1</span><span>2</span><span>3</span></td> <td>span*3</td> </tr> <tr> <td>有内容的标签</td> <td><div>内容</div></td> <td>div{内容}</td> </tr> </tbody> </table>

首字母写法

背景属性

描述	属性
背景色	background-color
背景图	background-image
背景图平铺方式	background-repeat
背景图位置	background-position
背景图缩放	background-size
背景图固定	background-attachment
背景复合属性	background

背景图

网页中，使用背景图实现装饰性的图片效果。

属性名： background-image (bgi)

属性值：url (背景图 URL)

注意：背景图默认平铺效果

背景图平铺方式

属性名：background-repeat (bgr)

属性值：

属性值	效果
no-repeat	不平铺，盒子左上角显示一张背景图
repeat	平铺，默认效果
repeat-x	水平方向平铺
repeat-y	垂直方向平铺

背景图位置

属性名：background-position (bgp)

属性值：水平方向位置（正数右移，负数左移），垂直方向位置（正数下移，负数上移）

关键字

关键字	位置
left	左侧
right	右侧
center	居中
top	顶部
bottom	底部

坐标（数字+px，正负都可以）

示例代码：

div{
	width: 400px;
	height: 400px;
	background-color: pink;
	background-image: url(./image/pic.jpg);
	background-repeat: no-repeat;

	background-position: center bottom;
	background-position: 50px -100px
	background-position: 50px center;

	background-attachedment: fixed;
}

提示：

关键字取值方式写法，可以颠倒取值顺序
可以只写一个关键字，另一个方向默认为居中数字只写一个值表示水平方向，垂直方向为居中

背景图缩放

属性名：background-size (bgz)

常用属性值：

关键字：
- cover：等比例缩放背景图片以完全覆盖背景区，可能背景图片部分看不见
- contain：等比例缩放背景图片以完全装入背景区，可能背景区部分空白
百分比：根据盒子尺寸计算图片大小（100%图片的宽度跟盒子宽度一样，图片的高度按照图片比例等比缩放）
数字+单位（例如：px）（较少用）

背景图固定

属性名：background-attachment (bga)

属性值：fixed

背景复合属性

属性名：background（bg）

属性值：背景色背景图背景图平铺方式背景图位置/背景图缩放背景图固定
（空格隔开各个属性值，不区分顺序)

显示模式

显示模式：标签（元素）的显示方式。

作用：布局网页的时候，根据标签的显示模式选择合适的标签摆放内容。

块级元素（例如 div）

独占一行
宽度默认是父级的 100%
添加宽高属性生效

行内元素（例如 span）

一行可以显示多个
设置宽高属性不生效
宽高尺寸由内容撑开
vertical-align 行内块和行内垂直方向对齐方式

行内块元素（例如 img）

一行可以显示多个
设置宽高尺寸生效
宽高尺寸默认由内容撑开
vertical-align 行内块和行内垂直方向对齐方式

转换显示模式

属性名：display

属性值：

属性值	效果
block	块级
inline-block	行内块
inline	行内

选择器	说明
E: first-child	查找第一个 E 元素
E: last-child	查找最后一个 E 元素
E: nth-child (N)	查找第 N 个 E 元素（第一个元素的 N 值为 1）

: nth-child (公式)

作用：根据元素结构关系查找多个元素

功能	公式
偶数标签	2n
奇数标签	2n+1; 2n-1
找到 5 的倍数的标签	5n
找到第 5 个以后的标签	n+5
找到第 5 个以前的标签	-n+5

伪元素选择器

作用：创建虚拟元素（伪元素），用来摆放装饰性的内容。

选择器	作用
E::before	在 E 元素里面最前面添加一个伪元素
E::after	在 E 元素里面最后面添加一个伪元素

注意点：

必须设置 content: “ “ 属性用来设置伪元素的内容，如果没有内容，则引号留空即可
伪元素默认是行内显示模式
权重和标签选择器相同

PxCook 软件

PxCook（像素大厨）是一款切图设计工具软件。支持 PSD 文件的文字、颜色、距离自动智能识别。

开发面板（自动智能识别）
设计面板（手动测量尺寸和颜色）

盒子模型

作用：布局网页，摆放盒子和内容

盒子模型 - 组成

盒子模型的重要组成部分：

内容区域 - wedth & height
内边距 - padding （出现在内容和盒子边距之间）
边框线 - border
外边距 - margin （出现在盒子外面，常用来拉开两个盒子之间的距离）

盒子模型 - 边框线

属性名：border（bd）

属性值：边框线粗细线条样式颜色（不区分顺序）

常用线条样式：

属性值	线条样式
solid	实线
dashed	虚线
dotted	点线

盒子模型 - 设置单方向边框线

属性名：border-方位名词 (bd+方位首字母，例如 bdl)

属性值：边框线粗细线条样式颜色（不区分顺序）

样例代码

div{
	border-top: 2px solid red;
	border-right: 3px dashed green;
	border-bottom: 4px dotted blue;
	border-left: 5px solid orange;

	width: 200px;
	height: 200px;
	background-color: pink;
}

盒子模型 - 内边距

作用：设置内容与盒子边缘之间的距离

属性名：padding / padding+方位名词（p+方位首字母）

样例代码：

div{
	padding-top: 2px solid red;
	padding-right: 3px dashed green;
	padding-bottom: 4px dotted blue;
	padding-left: 5px solid orange;

	width: 200px;
	height: 200px;
	background-color: pink;
}

盒子模型 - 内边距 - 多值写法

Padding 多值写法

取值个数	示例	含义
一个值	padding: 10px	四个方向内边距均为 10 px
四个值	padding: 10px 20px 30px 40px	上：10 px；右：20 px；下：30 px；左：40 px
三个值	padding: 10px 20px 30px	上：10 px；左右：20 px；下：30 px
两个值	padding: 10px 20px	上下：10 px；左右：20 px

==记忆方法：上右下左，没数看对面==

盒子模型 - 尺寸计算

默认情况：盒子尺寸 = 内容尺寸 + border 尺寸 + 内边距尺寸

结论：给盒子加 border / padding 会撑大盒子

解决：

手动做减法，减掉 border / padding 的尺寸
內减模式：box-sizing: border-box

盒子模型 - 外边距

作用：拉开两个盒子之间的距离

属性名：margin

提示：与 padding 的属性值、含义相同

注意：外边距不会撑大盒子

版心居中

div {
	margin: 0px auto;
}

浏览器计算宽度先减去盒子宽度，此时左右都是 auto，即为水平居中，因此做到了自适应版心居中

清除默认样式

清除标签默认的样式，比如：默认的内外边距

两种做法：

京东

* {
	margin: 0;
	padding: 0;
	box-sizing: border-box;
}

淘宝

blockquote, body, button, dd, dl, dt, fieldset, form, h1, h2, h3, h4, h5, h6, hr, input, legend, li, ol, p, pre, td,, extarea, th, ul {
	margin: 0;
	padding: 0;
	box-sizing: border-box;
}

注意：去掉列表的项目符号属性 list-style: none;

盒子模型 - 元素溢出

作用：控制溢出元素的内容的显示方式。

属性名：overflow

属性值：

属性值	效果
hidden	溢出隐藏
scroll	溢出滚动（无论是否溢出，都显示滚动条位置）
auto	溢出滚动（溢出才显示滚动条位置）

外边距问题 - 合并现象

场景：垂直排列的兄弟元素，上下 margin 会合并

现象：取两个 margin 中的较大值生效

外边距问题 - 塌陷问题

场景：父子级的标签，子级的添加上外边距会产生塌陷问题

现象：导致父级一起向下移动

解决方法:

取消子级 margin，父级设置 padding（推荐）
父级设置 overflow: hidden
父级设置 border-top

行内元素 - 内外边距问题

场景：行内元素添加 margin 和 padding，无法改变元素垂直位置

解决方法：给行内元素添加 line-height 可以改变垂直位置

盒子模型 - 圆角

作用：设置元素的外边框为圆角。

属性名：border-radius

属性值：数字+px / 百分比

提示：属性值是圆角半径

注意：也存在多值写法，记忆方法：从左上角顺时针赋值，没有取值的角与对角取值相同

常用的圆角形状：

常见形状 - 正圆形状
- 给正方形盒子设置圆角属性值为宽高的一半 / 50%（超过 50 没有效果）
常见形状 - 胶囊形状
- 给长方形盒子设置圆角属性值为盒子高度的一半

盒子模型 - 阴影（拓展）

作用：给元素设置阴影效果

属性名：box-shadow

属性值：X 轴偏移量 Y 轴偏移量模糊半径扩散半径颜色内外阴影

X 轴偏移量和 Y 轴偏移量必须书写
默认是外阴影，内阴影需要添加 inset

设计顺序

书写顺序

1. 盒子模型属性
2. 文字样式
3. 圆角，阴影等属性

浮动

作用：让块元素水平排列。

属性名：float

属性值：

left：左对齐
right：右对齐

浮动后的盒子特点：

顶对齐
具备行内块特点
脱标

注意：一般放在 css 属性的最前面

清除浮动

场景：浮动元素会脱标，如果父级没有高度，子级无法撑开父级高度（可能导致页面布局错乱）

解决方法：清除浮动（清除浮动带来的影响）

方法一：额外标签法

在父元素内容的最后忝加一个块级元素（一般类名为 clearfix），设置 CSS 属性 clear: both

方法二：单伪元素法

.clearfix::after {
	content: "";
	display: block;
	clear: both;
}

方法三：双伪元素法（推荐）

<!-- brfore 伪元素是为了解决塌陷的 after是清除浮动影响的 -->
.clearfix::before,
.clearfix::after {
	content: "";
	display: table;
}

.clearfix::after {
	clear: both;
}

方法四：overflow

父元素添加 CSS 属性 overflow: hidden

总结

浮动属性 float，left 表示左浮动，right 表示右浮动
特点：

浮动后的盒子顶对齐
浮动后的盒子具备行内块特点
父级宽度不够，浮动的子级会换行
浮动后的盒子脱标

清除浮动：子级浮动，父级没有高度，子级无法撑开父级高度，影响布局效果

双伪元素法

拓展：浮动本质作用是实现图文混排效果

Flex 布局

Flex 布局 - 简介

Flex布局也叫弹性布局，是浏览器提倡的布局模型，非常适合结构化布局，提供了强大的空间分布和对齐能力。

Flex模型不会产生浮动布局中脱标现象，布局网页更简单、更灵活。

Flex - 组成

设置方式：给父元素设置 display: flex 子元素可以自动挤压或拉伸

组成部分：

弹性容器
弹性盒子：沿着主轴方向排列
主轴：默认在水平方向
侧轴 / 交叉轴：默认在垂直方向

描述	属性
创建 flex 容器	display: flex
主轴对齐方式	justify-content
侧轴对齐方式	align-items
某个弹性盒子侧轴对齐方式	align-self
修改主轴方向	flex-decoration
弹性伸缩比	flex
弹性盒子换行	flex-wrap
行对齐方式	align-content

Flex - 主轴对齐方式

属性名：justify-content

属性值	效果
flex-start	默认值，弹性盒子从起点开始依次排列
flex-end	弹性盒子从终点开始依次排列
center	弹性盒子沿主轴居中排列
space-between	弹性盒子沿主轴均匀排列，空白间距均分在弹性盒子之间
space-around	弹性盒子沿主轴均匀排列，空白间距均分在弹性盒子两侧
space-evenly	弹性盒子沿主轴均匀排列，弹性盒子与容器之间间距相等

Flex - 侧轴对齐方式

属性名：

Align-items：当前弹性容器内所有弹性盒子的侧轴对齐方式（给弹性容器设置）
Align-self：单独控制某个弹性盒子的侧轴对齐方式（给弹性盒子设置）

属性值：

属性值	效果
stretch	弹性盒子沿着恻轴线被拉伸至铺满容器（弹性盒子没有设置侧轴方向尺寸则默认拉伸）
center	弹性盒子沿侧轴居中排列
flex-start	弹性盒子从起点开始依次排列
flex-end	弹性盒子从终点开始依次排列

Flex - 修改主轴方向

主轴默认在水平方向，侧轴默认在垂直方向。主轴方向变换，侧轴自动变换。

属性名：flex-decoration

属性值：

属性值	效果
row	水平方向，从左向右（默认）
column	垂直方向，从上向下
row-reverse	水平方向，从右向左
column-reverse	垂直方向，从下向上

Flex - 弹性伸缩比

作用：控制弹性盒子在主轴方向的尺寸。

属性名：flex

属性值：整数数字，表示占用父级剩余尺寸的份数。

Flex - 弹性盒子换行

弹性盒子可以自动挤压或拉伸，默认情况下，所有弹性盒子都在一行显示。

属性名：flex-wrap

属性值：

Wrap：换行
Nowrap：不换行（默认）

Flex - 行对齐方式

属性名：align-content

属性值：

属性值	效果
flex-start	默认值，弹性盒子从起点开始依次排列
flex-end	弹性盒子从终点开始依次排列
center	弹性盒子沿主轴居中排列
space-between	弹性盒子沿主轴均匀排列，空白间距均分在弹性盒子之间
space-around	弹性盒子沿主轴均匀排列，空白间距均分在弹性盒子两侧
space-evenly	弹性盒子沿主轴均匀排列，弹性盒子与容器之间间距相等

注意：该属性对单行弹性盒子不生效

注意：

默认情况下，主轴方向尺寸是靠内容撑开，侧轴默认拉伸

ul>li{$}*4可以快速生成

定位

作用：灵活的改变盒子在网页中的位置

实现：

定位模式：position
边偏移：设置盒子的位置

left
right
top
bottom

定位模式：相对定位

属性值：position: relative

特点：

改变位置的参照物是自己原来的位置
不脱标，占位
标签的显示模式特点：不变

定位模式：绝对定位

属性值：position: absolute

使用场景：子级绝对定位，父级相对定位（子绝父相）

特点：

参照物：先找最近的已经定位的祖先元素，如果所有祖先元素都没有定位，参照浏览器可视区改位置
脱标，不占位
标签的显示模式特点：改变，宽高生效（具备了行内块特点）

定位居中

实现步骤：

绝对定位
水平、垂直边偏移为 50%
子级向左、上移动自身尺寸的一半

左、上的外边距为 - 尺寸的一半
transtform: translate(-)

固定定位

属性值：position: fixed

场景：元素的位置在网页滚动时不会改变

特点：

参照物：浏览器窗口
脱标，不占位
标签的显示模式：改变，宽高生效（具备了行内块特点）

堆叠层级

默认效果：按照标签书写顺序，后来者居上

作用：设置定位元素的层级顺序，改变定位元素的显示顺序，取值越大显示顺序越靠上

总结

定位模式	属性值	是否脱标	显示模式	参照物
相对定位	relative	否	保持标签原有显示模式	自己原来位置
绝对定位	absolute	是	行内块特点	1.已经定位的祖先元素 <br>2.浏览器可视区
固定定位	fixed	是	行内块特点	浏览器窗口

CSS 精灵

CSS 精灵，也叫 CSS Sprites，是一种网页图片应用处理方式。把网页中一些背景图片整合到一张图片文件，再 background-position 精确的定位出背景图片的位置。

优点：减少服务器被请求次数，减轻服务器的压力，提高页面加载速度

实现步骤：

创建盒子，盒子尺寸与小图尺寸相同
设置盒子背景图为精灵图
添加 background-position 属性，改变背景图位置 3.1 是用 PxCook 测量 3.2 取负数坐标为 background-position 属性值（向左上移动图片位置）

字体图标

字体图标：展示的是图标，本质是字体

作用：在网页中添加简单的、颜色单一的小图标

优点：

灵活性：灵活地修改样式，例如：尺寸、颜色等
轻量级：体积小、渲染快、降低服务器请求次数
兼容性：几乎兼容所有主流浏览器
使用方便：先下载再使用

字体图标 - 下载字体

iconfont 图标库：https://www.iconfont.cn/
下载字体：

字体图标 - 使用字体

引入字体样式表（iconfont.css）
标签使用字体图标类名
iconfont：字体图标基本样式（字体名，大小等等）
icon-xxx：图标对应的类名

样例代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>test</title>
    <link rel="stylesheet" href="./iconfont/iconfont.css">
    <style>
        /* 字体样式 */
    </style>
</head>
<body>
    <span class="iconfont icon-xxx"></span>
</body>
</html>

注意：如果要调整字体大小，注意选择器的优先级要高于iconfont类

字体图标 - 上传矢量库

作用：项目特有的图标上传到iconfont图标库，生成字体

垂直对齐方式 - vertical-align

属性名：vertical-align

属性值：

屬性值	效果
baseline	基线对齐（默认）
top	顶部对齐
middle	居中对齐
bottom	底部对齐

注意：行内块和行内标签当成文字处理，默认基线对齐导致基线下有空白，除去 baseline 其余三种对其方式无空白，行内块转为块显示模式也无空白

过渡属性 - transition

作用：可以为一个元素在不同状态之间切换的时候添加过渡效果

属性名：transition（复合属性）

属性值：过渡的属性花费时间（s）

提示：

过渡的属性可以是具体的 CSS 属性
也可以为 all（两个状态属性值不同的所有属性，都产生过渡效果）
transition 设置给元素本身

透明度 - opacity

作用：设置整个元素的透明度（包含背景和内容）

属性名：opacity

属性值：0 - 1

0：完全透明（元素不可见）
1：不透明
0 - 1 之间小数：半透明

光标类型 - cursor

作用：鼠标悬停在元素上时指针显示样式

属性名：cursor

属性值：

属性值	效果
default	默认值，通常是箭头
pointer	小手效果，提示用户可以点击
text	工字型，提示用户可以选择文字
move	十字光标，提示用户可以移动

平面转换 transform

作用：为元素添加动态效果，一般与过渡配合使用

概念：改变盒子在平面内的形态（位移、旋转、缩放、倾斜）

平面转换又叫做 2D转换

平面转换 - 平移

属性值：transform: translate(X轴移动距离, Y轴移动距离）

取值：

像素单位数值
百分比（按照盒子自身尺寸计算结果）
正负均可

技巧：

translate（只写一个值，表示沿着 X 轴移动）
单独设置 X 或 Y 轴移动距离：translateX() 或 translateY()

居中写法：

写法1

position: absolute;
left: 50%;
top: 50%;

/* margin */
margin-left: -100px;
margin-top: -50px;

width: 200px;
height: 100px;

写法2（参考自身尺寸，方便）

osition: absolute;
left: 50%;
top: 50%;
translate: transform(-50%, -50%);

注意：

宽高可以使用百分比，以父级元素为基准

平面转换 - 旋转

属性值：transform: rotate(旋转角度）

旋转角度：

单位：deg
有正负（正顺负逆）

平面转换 - 改变转换原点

默认情况下，转换原点是盒子中心点

属性值：transform-origin: 水平原点位置垂直原点位置;

取值

方位名词（left、top、right、bottom、center)
像素单位数值
百分比

多重转换

先平移再旋转
旋转会改变坐标轴向
多重转换:以第一种转换形态的坐标轴为准
拆开写不行，有层叠性，生效最后一个

平面转换 - 缩放

属性值：

transform: scale(缩放倍数);
transform: scale(X轴缩放倍效, Y轴缩放倍数);

技巧

通常，只为 scale 设置一个值，表示 X 轴和 Y 轴等比例缩放
取值大于1表示放大，取值小于1表示缩小

平面转换 - 倾斜

属性值：transform: skew();

取值：角度度数deg

渐变

线性渐变

属性值：

background-image: linear-gradient(
	渐变方向,
	颜色1 终点位置,
	颜色2 终点位置,
	......
);

取值

渐变方向（可选）
- to 方位名词
- 角度度数
终点位置（可选）
- 百分比

硬线：

例子1：

background: linear-gradient(
	to bottom left, 
	cyan 50%, 
	palegoldenrod 50%
);

例子2（多条纹硬线）

background: linear-gradient(
    to left,
    lime 25%,
    red 25%,
    red 50%,
    cyan 50%,
    cyan 75%,
    yellow 75%
);
background: linear-gradient(
    to left,
    lime 25%,
    red 25% 50%,
    cyan 50% 75%,
    yellow 75%
);

径向渐变

属性值：

background-image: radial-gradient(
	半径 at 圆心位置,
	颜色1 终点位置,
	颜色2 终点位置,
	......
);

取值

半径可以是2条，则为椭圆
圆心位置取值：像素单位数值 / 百分比 / 方位名词

锥形渐变

属性值：

background: conic-gradient(
	from 起始角度 at 变换中心,
	颜色1 终点位置,
	颜色2 终点位置,
	......
);

空间转换

空间：是从坐标轴角度定义的X、Y和Z三条坐标轴构成了一个立体空间，Z轴位置与视线方向相同
空间转换也叫3D转换
属性：transform

空间转换 - 平移

属性值：

transform: translate3d(x, y, z);
transform: translatex();
transform: translateY();
transform: translatez();

取值（正负均可）

像素单位数值
百分比（参照盒子自身尺寸计算结果）

注意：

电脑是平面，默认无法观察z轴平移效果
translate3d 必须要有三个数字

视距

作用：指定了观察者与 Z = 0 平面的距离，为元素添加透视效果

透视效果：近大远小、近实远虚

属性值：(添加给父级，取值范围800-1200）

perspective: 视距;

空间转换 - 旋转

属性值：transform: rotateZ(值)；
属性值：transform: rotateX(值)；
属性值：transform: rotateY(值)；
左手法则 – 根据旋转方向确定取值正负：左手握住旋转轴，拇指指向正值方向，其他四个手指弯曲方向为旋转正值方向
拓展
- rotate3d(x, y, z, 角度度数)：用来设置自定义旋转轴的位置及旋转的角度
- x， y，z取值为0-1之间的数字

立体呈现

作用：设置元素的子元素是位于 3d空间 中还是平面中

属性名：transform-style

属性值：

flat：子级处于平面中
preserve-3d：子级处于3D空间

呈现立体图形步骤

父元素添加transform-style: preserve-3d;
子级定位
调整子盒子的位置（位移或旋转）

空间转换 - 缩放

属性值：

transform: scale3d(x, y, z);
transform: scaleX();
transform: scaleY();
transform: scaleZ();

动画 - animation

过渡：实现两个状态间的变化过程
动画：实现多个状态间的变化过程，动画过程可控（重复播放、最终画面、是否暂停）

实现步骤：

定义动画

@keyframes 动画名称{
    from {}
    to {}
}

@keyframes 动画名称{
    0% {}
    10% {}
    ......
    100% {}
}

使用动画

animation: 动画名称 动画时长 速度曲线 延迟时间 重复次数 动画方向 执行完毕时状态;

提示：

动画名称和动画时长必须赋值
取值不分先后顺序
如果有两个时间值，第一个时间表示动画时长，第二个时间表示延迟时间

属性值：

属性	作用	取值
animation-name	动画名称
animation-duration	动画时长
animation-delay	延迟时间
animation-fill-mode	执行完毕时状态	forwards：最后一帧转态 <br>backwards：第一帧状态
animation-timing-function	速度曲线	linear：匀速运动 <br>steps(数字)：逐帧动画
animation-iteration-count	重复次数	infinite为无限循环
animation-direction	动画方向	alternate为反向
animation-play-state	暂停动画	paused为暂停，通常配合 :hover 使用

无缝动画原理：复制开头图片到结尾位置（图片累加宽度=区域宽度）

多组动画

animation:
	动画1,
	动画2,
	动画N
;

注意：当动画的开始状态样式跟盒子默认样式相同，可以省略动画开始状态的代码

屏幕分辨率

硬件分辨率→物理分辨率（出厂设置）
缩放调节的分辨率→逻辑分辨率（软件/驱动设置）
通过视口标签规定html尺寸，让html宽度等于设备宽度（默认生成）

<meta name="viewport" content="width=device-width, initial-scale=1.0">

适配方案

宽度适配：宽度自适应
- 百分比布局
- Flex布局
等比适配：宽高等比缩放
- rem
- vw

rem适配方案

rem单位，是相对单位
rem单位是相对于HTML标签的字号计算结果
1rem = 1HTML字号大小
手机屏幕大小不同，分辨率不同，如何设置不同的HTML标签字号?
- 媒体查询
媒体查询能够检测视口的宽度，然后编写差异化的CSS样式当
某个条件成立，执行对应的CSS样式

@media (媒体特性) {
  选择器 {
	css属性
  }
}

目前rem布局方案中，将网页等分成10份，HTML标签的字号为视口宽度的1/10

rem - flexible.js

flexible.js是手淘开发出的一个用来适配移动端的js库。
核心原理就是根据不同的视口宽度给网页中html根节点设置不同的 font-size。

less

Less是一个CSS预处理器，Less文件后缀是**.less**。扩充了CSS语言,使CSS具备一定的逻辑性、计算能力
注意：浏览器不识别Less 代码，目前阶段，网页要引入对应的CSS文件
VS Code插件：Easy LESS，保存less文件后自动生成对应的CSS文件

less - 注释

单行注释
- 语法：// 注释内容
- 快捷键：ctrl + /
块注释
- 语法：/*注释内容*/
- 快捷键：Shift + Alt + A

less - 运算

加、减、乘直接书写计算表达式
除法需要添加小括号或 .
如果表达式有多个单位，最终css里面以第一个单位为准

less - 嵌套

作用：快速生成后代选择器
& 表示的是当前选择器，代码写到谁的大括号里面就表示谁
不会生成后代选择器
应用：配合hover伪类或nth-child结构伪类使用

less - 变量

语法

定义变量：@变量名:数据;
使用变量：CSS属性:@变量名;

less - 导入

作用：导入 less 公共样式文件
语法：导入：@import “文件路径”;
提示：如果是less文件可以省略后缀

import "./base.less';
import "./common';

less - 导出

写法：在less文件的第一行添加 //out:存储URL
提示：文件夹名称后面添加 /

// out: ./index.css
// out: ./css/

less - 禁止导出

写法：在 less文件第一行添加：// out:false

vw适配方案

相对单位
相对视口的尺寸计算结果
vw：viewport width
- 1vw = 1/100 视口宽度
vh：viewport height
- 1vh = 1/100 视口高度
注意：vw和vh不要混用

Bootstrap

Bootstrap 是由 Twitter 公司开发维护的前端 UI 框架，它提供了大量编写好的 CSS 样式，允许开发者结合一定HTML结构及JavaScript，快速编写功能完善的网页及常见交互效果。

中文官网：https://www.bootcss.coml

Bootstrap - 使用

下载：Bootstrap V5中文文档 → 进入中文文档 → 下载 → 下载 Bootstrap 生产文件

使用

1．引入Bootstrap.css文件

<link rel="stylesheet" href="./Bootstrap/css/bootstrap.min.css">

2.调用类名：container：响应式布局版心类
```
<div class="container">测试</div>
```

Bootstrap - 栅格系统

栅格化是指将整个网页的宽度分成12等份，每个盒子占用的对应的份数

例如：一行排4个盒子，则每个盒子占3份即可（12 / 4= 3）

Breakpoint	Class infix	Dimensions
Extra small	None	<576px
Small	sm	>=576px
Medium	md	>=768px
Large	lg	>=992px
Extra large	xl	>=1200px
Extra extra large	xxl	>=1400px

常用布局类

col-*-*：列（例如：col-xxl-3）
row：行

Bootstrap - 全局样式

Button类

btn：默认样式
btn-success：成功
btn-warning：警告
…
按钮尺寸：btn-lg / btn-sm

剩余的看文档

表格类

table：默认样式
table-striped：隔行变色
table-success：表格颜色
…

剩余的看文档

Bootstrap - 组件(Components)

1.引入样式表

2.引入 js 文件

3.复制结构，修改内容

Bootstrap - 字体图标

下载
- 导航 / Extend：图标库 → 安装 → 下载安装包 → bootstrap-icons-1.X.X.zip
使用
- 复制fonts文件夹到项目目录
- 网页引入 bootstrap-icons.css 文件
- 调用CSS类名（图标对应的类名）

无题

Mon, 13 Nov 2023 14:06:06 GMT

事务隔离

索引

jwt

微服务

多线程

乐观/悲观

limit 1000000

aqs

g1 cms

redis

tcp拥塞控制

jmm

jvm

可达性分析

接雨水

协程

Spring SpringMVC SpringBoot

cas 和 volatile

3握4挥

拦截与过滤区别

Session

循环队列

分析

Sun, 16 Jul 2023 16:00:00 GMT

注解

@ApiModel

使用场景：在实体类上边使用，标记类时swagger的解析类

什么是Swagger
OpenAPI规范（OpenAPI Specification 简称OAS）是Linux基金会的一个项目，试图通过定义一种用来描述API格式或API定义的语言，来规范RESTful服务开发过程，目前版本是V3.0，并且已经发布并开源在github上。

Swagger是符合OpenAPI规范的接口开发工具，支持从设计和文档到测试和部署的整个API生命周期的开发

作用范围	API	使用位置
对象属性	@ApiModelProperty	用在出入参数对象的字段上
协议集描述	@Api	用于controller类上
协议描述	@ApiOperation	用在controller的方法上
Response集	@ApiResponses	用在controller的方法上
Response	@ApiResponse	用在 @ApiResponses里边
非对象参数集	@ApiImplicitParams	用在controller的方法上
非对象参数描述	@ApiImplicitParam	用在@ApiImplicitParams的方法里边
描述返回对象的意义	@ApiModel	用在返回对象类上

@JsonNaming

@JsonNaming批注用于为序列化中的属性选择命名策略，覆盖默认设置。使用value元素，我们可以指定任何策略，包括自定义策略。

除了默认值LOWER_CAMEL_CASE（例如lowerCamelCase）外，Jackson库还为我们提供了另外四种内置的属性命名策略，以方便使用：

KEBAB_CASE：名称元素之间用连字符分隔，例如 kebab-case。

LOWER_CASE：所有字母均为小写字母，没有分隔符，例如 lowercase。

LOWER_DOT_CASE：所有字母均为小写字母，用点连接字符，例如 lower.case。

SNAKE_CASE：所有字母均为小写，并在名称元素之间使用下划线作为分隔符，例如 snake_case。

UPPER_CAMEL_CASE：所有名称元素，包括第一个，都以大写字母开头，后跟小写字母，并且没有分隔符，例如 UpperCamelCase。

此示例将说明使用蛇形案例名称序列化属性的方法，其中将名为beanName的属性序列化为bean_name。

@ConfigurationProperties( prefix = ”xxxx” )

在 SpringBoot 中，当想需要获取到配置文件数据时，除了可以用 Spring 自带的 @Value 注解外，SpringBoot 还提供了一种更加方便的方式：@ConfigurationProperties。只要在 Bean 上添加上了这个注解，指定好配置文件的前缀，那么对应的配置文件数据就会自动填充到 Bean 中。

比如在application.properties文件中有如下配置文件

config.username=jay.zhou
config.password=3333

Redis09-消息队列

Sat, 08 Jul 2023 11:30:00 GMT

Redis消息队列

基于List的消息队列

消息队列(Message Queue)，字面意思就是存放消息的队列。最简单的消息队列模型包括3个角色:

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

Redis提供了三种不同的方式来实现消息队列:

list结构:基于List结构模拟消息队列
PubSub:基本的点对点消息模型
stream: 比较完善的消息队列模型

基于List结构模拟消息队列
消息队列(Message Queue)，字面意思就是存放消息的队列。而Redis的list数据结构是一个双向链表，很容易模拟出队列效果。
队列是入口和出口不在一边，因此我们可以利用:LPUSH结合RPOP、或者RPUSH结合LPOP来实现。
不过要注意的是，当队列中没有消息时RPOP或LPOP操作会返回null，并不像JVM的阻塞队列那样会阻塞并等待消息。因此这里应该使用BRPOP或者BLPOP来实现阻塞效果。

基于List的消息队列有哪些优缺点?

优点:

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

缺点:

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

基于PubSub的消息队列

发布者把消息发送到频道，当前在线且订阅该频道的多个订阅者各自接收一份，这与把任务分摊给单个消费者不同。频道不保存供离线订阅者补读的历史，也没有消费组的确认与待处理记录；断开连接期间错过的消息，不能仅靠重新订阅自动恢复。

基于PubSub的消息队列有哪些优缺点?

优点:

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

缺点:

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

基于Stream的消息队列

Stream 保存带标识的消息记录，不同消费组维护各自进度，同组消费者可以分摊新消息。组内消息交付后进入待确认记录，业务处理成功再确认；确认移除的是待确认状态，不是流中的消息正文。失败消息需要显式恢复或认领，重复交付仍可能发生，因此处理逻辑必须考虑幂等。

消费组并不会替应用判断业务是否真正完成。消费者应在处理成功后确认，处理中断时由恢复逻辑检查待确认记录并安排重试或认领。消息保留、裁剪与 Redis 持久化配置还会影响可恢复范围；确认机制不自动提供端到端恰好一次处理，并发消费者的完成顺序也不必等于消息写入顺序。

Redis08-分布式锁

Wed, 05 Jul 2023 13:30:00 GMT

分布式锁要协调的是不同进程对同一资源的访问，而不是只锁住单个应用实例内的线程。竞争者需要使用一致的资源标识，通过共享的协调服务决定谁可进入临界区；获取失败时不得继续执行受保护操作。互斥、释放策略和故障边界需要分别设计，不能因为使用了 Redis 就默认全部具备。

分布式锁的核心是实现多进程之间互斥，而满足这一点的方式有很多，常见的有三种:

	MySQL	Redis	Zookeeper
互斥	利用mysql本身的互斥锁机制	利用setnx这样的互斥命令	利用节点的唯一性和有序性实现互斥
高可用	好	好	好
高性能	一般	好	一般
安全性	断开连接，自动释放锁	利用锁超时时间，到期释放	临时节点，断开连接自动释放

注意redis的超时释放

过期时间限制的是 Redis 锁键的存活，并不会中断持锁线程。旧线程停顿期间锁可能到期，另一个线程随后获得同名锁；旧线程恢复后若直接删除该键，就删除了别人的锁。解锁需要核对本次加锁标识，并且将核对与删除合并执行，避免新的竞争窗口。

租期结束后，同名锁可能已经属于新的请求。旧持有者恢复执行时，如果不检查当前锁值便直接删除，就会把新持有者的锁一并释放，使后续请求也进入临界区。超时机制有助于故障后的自动释放，却不会停止仍在执行的旧业务，因此不能把键过期理解为业务已经结束。

解决方法：释放锁的时候判断一下锁标识

锁值应保存本次加锁生成的唯一标识，释放前只接受与该标识一致的所有者。仅记录一个容易被不同进程重复使用的线程编号并不充分；不同持有者必须能够区分。检查归属只能确定应该删除谁的锁，若检查与删除分成两次命令，仍存在中间过期、换主人的竞争窗口。

先 GET 再 DEL 即使检查过所有者，也可能在两条命令之间发生过期和重新加锁。把比较与条件删除放进同一个 Lua 脚本，只有锁值等于预期标识时才删除同一把锁，其他客户端无法在这两个步骤之间插入命令。这个保证限于脚本内的 Redis 操作，不覆盖数据库事务。

==使用Redis事务（Redis只保证了原子性，不能保证一致性，要不然再加上乐观锁进行判断，复杂==

==使用简单的Lua脚本，在一个脚本中编写多条Redis命令，确保多条命令执行时的原子性。==

样例：

调用解锁脚本时，要把实际锁键作为键参数传入，再把期望的所有者标识作为普通参数传入。脚本中的 KEYS[1] 与 ARGV[1] 分别读取这两类输入，不应把用户输入直接拼进脚本文本。调用方还要解释返回值，区分本次确实删除了锁与锁已不存在、已不属于自己等未释放情况。

这段 Lua 的核心是先读取目标锁的当前值，再与调用者提供的标识比较，匹配时删除的必须仍是同一个键。这里键参数应统一使用 KEYS[1]，不能换成未定义的 key 变量。返回值也应与删除结果对应，否则调用者无法仅凭固定返回值知道是否真正完成了释放。

-- 比较标识的一致性
if(redis.call('get', KEYS[1]) == ARGV[1]) then
    -- 释放锁
    redis.call('del', key)
end
return 0

完整的锁生命周期需要两处不可分割的操作：获取时用一条带 NX 与过期参数的 SET 同时建立互斥和租期，避免先加锁后设置过期之间中断；释放时用脚本原子比较标识并条件删除。租期仍应覆盖业务风险，自动过期本身不能保证旧执行者已停止访问受保护资源。

基于Redis的分布式锁实现思路:

利用set nx ex获取锁，并设置过期时间，保存线程标示
释放锁时先判断线程标示是否与自己一致，一致则删除锁

特性:

利用set nx满足互斥性
利用set ex保证故障时锁依然能释放，避免死锁，提高安全性·利用Redis集群保证高可用和高并发特性

Redsson可重入锁

==基于setnx存在以下问题==

不可重入：同一个线程无法多次获取同一把锁
不可重试：获取锁只尝试一次就返回false，没有重试机制
锁超时释放虽然可以避免死锁，但如果是业务执行耗时较长，也会导致锁释放，存在安全隐患
如果Redis提供了主从集群，主从同步存在延迟，当主宕机时，如果从并同步主中的锁数据，则会出现锁实现

使用可重入锁时，先按业务资源取得同名锁对象，再尝试获取；只有获取成功才执行受保护逻辑，并在退出时确保释放。若获取过程被中断或未成功，不能当作已经持锁继续处理，也不能无条件解锁。等待时长与租期属于不同配置概念，需要根据所选调用方式确认续期行为。

可重入原理

可重入允许同一所有者重复进入同一把锁，而不是允许其他线程共享持有。锁状态记录可区分客户端与线程的标识及重入计数，每次正确解锁减少计数，归零才释放并通知等待者。等待者仍需重新获取锁，通知不等于授权；续期是否启用也要结合固定租期或 watchdog 模式判断。

加锁时需要区分锁不存在、锁属于当前线程、锁属于其他线程三种状态。不存在时建立所有者与计数，属于当前所有者时增加重入次数，属于别人时不能直接覆盖，而应依据等待策略重试或返回。被通知唤醒只是获得再次竞争的机会，并不等于已经自动取得锁。

解锁先确认当前执行者有权操作这把锁，再减少自己的重入计数。仍有未退出的重入层级时锁应继续保留，只有最后一层退出才删除锁并发布释放通知。其他线程收到通知后还要重新竞争，不能将一次通知当作锁已转交，也不能由非持有者随意清空计数。

Redisson 将重入计数、等待唤醒和适用模式下的租期续约组合起来：同一所有者重入增加计数，其他线程等待通知后再尝试竞争，最终释放才唤醒等待者。watchdog 不是所有调用方式下都启用的无限续期，也不能消除进程长时间停顿、网络中断或主从切换的全部互斥风险。

Redisson分布式锁原理:

可重入:利用hash结构记录线程id和重入次数
可重试:利用信号量和PubSub功能实现等待、唤醒，获取锁失败的重试机制
超时续约:利用watchDog，每隔一段时间( releaseTime / 3)，重置超时时间

Redis07-秒杀

Tue, 04 Jul 2023 13:30:00 GMT

全局唯一ID

一般的订单会出什么问题呢？

第一点：数据量大

第二点：要具备唯一性（数据量过大时分表，可能出现重复id的问题）

因此要使用==全局唯一ID==在分布式系统下用来生成全局唯一ID的工具

需要满足：

唯一性
高可用
高性能
递增性（有利于索引和插入）Redis的incr
安全性（自增不能规律过于明显）

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

同一业务与日期命名空间中的应用实例，共用 Redis 计数器获取自增序列，再与约定的时间信息组成 ID。编码需要明确字段边界、日期切换和序列溢出的处理，不能随意拼接便认为绝不会重复。这是 Redis 自增组合方案，与通常包含机器标识的 Snowflake 应区别理解，也不代表 ID 已不可猜测。

全局唯一ID生成策略:.

UUID
Redis自增snowflake算法
数据库自增
Redis自增ID策略:
- 每天一个key，方便统计订单量.
- ID构造是时间戳＋计数器

下单时需要判断两点:

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

活动时间不符合条件时直接拒绝下单；活动进行中也不能仅凭先前读到的库存继续扣减。应在数据库更新时同时约束库存大于零，并依据更新结果决定是否创建订单。库存扣减与订单写入需要事务边界，而同一用户同一优惠券只能购买一次，还需要额外的并发约束。

==高并发情况下会出现超卖==

超卖的风险来自检查与修改之间的并发窗口：多个请求可能先后读到同一个可售库存，再各自继续下单。若扣减没有同步约束，就可能卖出超过可用数量的订单，或者发生更新覆盖。把库存条件放进更新语句，并检查影响行数，才能让过时的读取结果不再直接决定是否售出。

悲观锁把冲突操作放进互斥区，让其他执行者等待；乐观方案则允许先读取，在提交更新时用版本号或条件比较拒绝过期修改。前者需要评估锁粒度与等待成本，后者需要处理冲突失败和重试，不能只用“更快”概括选择。进程内同步锁也不会自动约束另一台应用实例。

乐观锁的实现方式：

版本号法
CAS

1．悲观锁:添加同步锁，让线程串行执行

优点:简单粗暴
缺点:性能一般

2.乐观锁:不加锁，在更新时判断是否有其它线程在修改

优点∶性能好
缺点∶存在成功率低的问题

修改秒杀业务，要求同一个优惠券，一个用户只能下一单

p54

集群下的并发安全问题

同一用户的请求分散到不同应用进程后，各进程自己的同步锁无法相互排斥。需要让相同业务资源竞争同一个共享锁键，只有获锁者进入受保护业务，未获锁者等待、重试或返回。锁键粒度应匹配优惠券与用户的业务约束，数据库唯一约束也可作为防止重复订单的最终保护。

Redis06-缓存

Mon, 03 Jul 2023 14:00:00 GMT

缓存

缓存就是数据交换的缓冲区（称作Cache [ kae]] )，是存贮数据的临时地方，一般读写性能较高。

优点
- 降低后端的负载
- 提高读写效率，降低响应的时间
成本
- 数据一致性成本
- 代码维护成本
- 运维成本

应用先查询 Redis，命中时直接返回，未命中时查询数据库并回填带有效期的缓存。修改数据时先提交数据库更新，再让对应缓存失效，后续读取重新加载。缓存减少重复查询，但数据库与缓存之间的失败窗口仍需处理，不能仅靠设置有效期宣称两者始终一致。

缓存更新策略

	内存淘汰	超时剔除	主动更新
说明	不用自己维护，利用Redis的内存淘汰机制，当内存不足时自动淘汰部分数据。下次查询时更新缓存。	给缓存数据添加TTL时间，到期后自动删除缓存。下次查询时更新缓存。	编写业务逻辑，在修改数据库的同时，更新缓存。
一致性	差	一般	好
维护成本	无	低	高

业务场景:
低一致性需求:使用内存淘汰机制。例如店铺类型的查询缓存
高一致性需求:主动更新，并以超时剔除作为兜底方案。例如店铺详情查询的缓存

主动更新

由缓存的调用者，在更新数据库的同时更新缓存
缓存与数据库整合为一个服务，由服务来维护一致性。调用者调用该服务，无需关心缓存一致性问题。
调用者只操作缓存，由其它线程异步的将缓存数据持久化到数据库，保证最终一致。

缓存更新策略的最佳实践方案:
1.低一致性需求:使用Redis自带的内存淘汰机制
2.高一致性需求:主动更新，并以超时剔除作为兜底方案

读操作︰
- 缓存命中则直接返回
- 缓存未命中则查询数据库，并写入缓存，设定超时时间
写操作∶
- 先写数据库，然后再删除缓存
- 要确保数据库与缓存操作的原子性

先写数据库再删除缓存，是让下一次读取重新加载最新数据，而不是给旧缓存逐字段打补丁。数据库提交与缓存删除属于两个操作，删除失败需要重试或补偿，超时剔除只能限制陈旧数据存续的窗口，不能自动提供跨存储的原子性，也不能消除所有并发回填竞态。

*缓存穿透

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

恶意用户在发送请求后发现为空，而查询每次都要到数据库，长此以往会导致数据库压力过大。

缓存空对象
- 优点:实现简单，维护方便
- 缺点:
  - 额外的内存消耗
  - 可能造成短期的不一致
布隆过滤器（存伪不失真）存在不一定存在，不存在一定不存在
- 优点:内存占用较少，没多余key
- 缺点:
  - 实现复杂
  - 存在误判的可能

数据库查空后，可以短期缓存明确的空值标记，使后续同类请求直接返回不存在；需要区分空标记和真正没有缓存。布隆过滤器能够排除确定不存在的查询，但“可能存在”仍须继续查询，不能当作数据存在的证明。两种方式都需要考虑新增数据和失效维护。

缓存穿透产生的原因是什么?

用户请求的数据在缓存中和数据库中都不存在，不断发起这样的请求给数据库带来巨大压力

缓存穿透的解决方案有哪些?

缓存null值
布隆过滤
增强id的复杂度，避免被猜测id规律
做好数据的基础格式校验
加强用户权限校验
做好热点参数的限流

*缓存雪崩

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

解决方案:

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

*缓存击穿

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

击穿的对象是原本存在、访问集中的热点键，缓存失效后大量请求同时回源；穿透则是缓存和数据库都没有对应数据，雪崩涉及大量键失效或整个缓存服务不可用。先定位触发范围，再决定使用空值缓存、互斥重建、错开有效期或业务降级，避免把不同故障当作同一问题处理。

==常见的解决方案有两种:==

互斥锁
逻辑过期

互斥方案让获锁请求再次检查缓存，再按需回源重建，其他请求等待或重试；逻辑过期方案保留旧值，发现过期时先返回旧数据，仅让获锁任务后台更新。后者以暂时陈旧换取读取不等待，但缓存真实缺失时没有旧值可用，仍需冷启动或回源策略。

解决方案	优点	缺点
互斥锁	没有额外的内存消耗 <br>保证一致性 <br>实现简单	线程需要等待，性能受影响 <br>可能有死锁风险
逻辑过期	线程无需等待，性能较好	不保证一致性 <br>有额外内存消耗 <br>实现复杂

Redis05-短信登陆

Mon, 03 Jul 2023 13:00:00 GMT

短信登陆

导入的表格

tb_user:用户表
tb_userLinfo:用户详情表
tb_shop:商户信息表
tb_shop_type:商户类型表
tb_blog:用户日记表(达人探店日记)
tb_follow:用户关注表
tb_voucher:优惠券表
tb_voucher_order:优惠券的订单表

短信登录的关键不在页面外观，而在验证码与用户身份的衔接：服务端保存与手机号对应的验证码，登录请求提交后进行比对，通过后再查找或创建用户并建立登录态。验证码只是一次登录校验材料，不应作为长期凭证，也不应把用户表中的全部字段交给浏览器。

为什么使用Redis

Session 保存在各自应用实例内存时，一个实例不能直接读到另一个实例的登录记录。改用 Redis 保存登录态后，请求携带随机 token，各实例都能通过它查找同一份用户信息；这改变的是状态存储位置，并不意味着浏览器会自动保存或发送新的凭证。

1.怎么基于session

2.验证码如何比对

3.是否要将所有的数据存入session？

==集群的session共享问题==

session共享问题:多台Tomcat并不共享session存储空间，当请求切换到不同tomcat服务时导致数据丢失的问题。

session的替代方案应该满足:

数据共享
内存存储
kev、value结构(和session一样)

使用Redis！

首先每个Tomcat可以去访问Redis，Redis是内存存储的，且Redis就是key，value结构

问题：

保存验证码

存储在Redis中类型：String，那么key是什么？手机号（确保每个手机号有自己的验证码，不仅可以

保存用户信息

存储在Redis中类型：Hash，那么key是什么？==手机号（不推荐，放在请求头中，有暴露的风险）建议随机token==

（保存登录的用户信息，可以使用String结构，以SON字符串来保存，比较直观，

Hash结构可以将对象中的每个字段独立存储，可以针对单个字段做CRUD，并且内存占用更少）

登陆校验

不再是sessionid，token才是登录凭着，但是token不是自动存储在浏览器，需要手动返回到浏览器。

验证码可以按手机号建立独立的 String 键，登录用户信息则以随机 token 为索引保存为 Hash，或按需要序列化为 String。登录成功后把 token 返回客户端，由后续请求显式携带；验证码和登录态分别设置有效期，既限制凭证使用窗口，也避免过期记录长期占用内存。

==可以给验证码设置有效期，放在内存满==

==注意像session（默认30min）一样给登陆时间做一个有效期，要不然登陆信息越来越多，最后会把redis装满==

==另一个问题，有效期30min，从登陆开始算起，只要登陆了30min后就会踢出，那么如何访问刷新有效期？拦截器！==

==上个问题可以在prehandle中修改，获取请求头的token，

preHandle

调用时间：Controller方法处理之前

执行顺序：链式Intercepter情况下，Intercepter按照声明的顺序一个接一个执行

若返回false，则中断执行，注意：不会进入afterCompletion

 

postHandle

调用前提：preHandle返回true

调用时间：Controller方法处理完之后，DispatcherServlet进行视图的渲染之前，也就是说在这个方法中你可以对ModelAndView进行操作

执行顺序：链式Intercepter情况下，Intercepter按照声明的顺序倒着执行。

备注：postHandle虽然post打头，但post、get方法都能处理



afterCompletion

调用前提：preHandle返回true

调用时间：DispatcherServlet进行视图的渲染之后

Redis代替session需要考虑的问题:

选择合适的数据结构
选择合适的key
选择合适的存储粒度

==拦截器问题==

拦截器拦住了需要登录的路径，若一直访问不需要登陆的网页则不会刷新，怎么办？

将刷新拦截器放在前面并覆盖所有路径，有有效 token 才恢复用户信息、刷新登录态有效期；随后由登录拦截器检查受保护路径。公开路径无需登录，但有效登录用户访问这些路径时仍能完成续期。缺少或失效的凭证不能通过刷新重新获得登录身份。

如何控制拦截器顺序？

.order属性

例如：

@Override
public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate))
            .addPathPatterns(
                    "/**"
            ).order(0);
    registry.addInterceptor(new LoginInterceptor())
            .excludePathPatterns(
                    "/shop/**",
                    "/blog/hot",
                    "/shop/type/**",
                    "/upload/**",
                    "/vocher/**",
                    "/user/code",
                    "/user/login"
            ).order(1);
}

order越小越先执行

后端

Sun, 02 Jul 2023 15:00:00 GMT

[toc]

1.请你说说Java的特点和优点,为什么要选择Java

Java语言的特点是：一次编译，到处运行，即平台无关性；是纯粹的面向对象的语言。

JAVA语言的优点有：内置的类库简化了开发人员的设计工作；具有较好的安全性和健壮性；开发人员不需要对内存的使用进行管理。

选择JAVA的原因是：使用范围很广，安卓操作系统的应用软件目前大部分还是使用JAVA语言编写。

2.请你说说Java基本数据类型和引用类型

Java的数据类型分为基本数据类型和引用数据类型两大类。基本数据类型共有八大类,这八大数据类型又可分为四小类,分别是整数类型（byte/short/int/long）、浮点类型（float、double）、字符类型（char）和布尔类型（boolean）。其中,int是最常用的整数类型,double是最为常用的浮点类型,除了布尔类型之外的其他7个类型,都可以看做是数字类型,它们相互之间可以进行类型转换。引用类型包括数组、类、接口类型,还有一种特殊的null类型,所谓引用数据类型就是对一个对象的引用,对象包括实例和数组两种。

8种基本数据类型的变量的值存放在栈内存，有char(16位),byte(8位),short(16位),int(32位)，long(64位)float(32位),double(64位),boolean。引用类型的变量存放引用地址，堆内存才是真正的值。类，接口，数组,string等为引用类型。

3.请你说一下抽象类和接口的区别

相同点：

1、两者都不能实例化；

2、可以拥有抽象方法。

区别：

1、抽象类定义的关键字是abstract class，接口定义的关键字是interface；

2、属性上，抽象类可以有静态变量、常量和成员变量，接口只能有常量；

3、抽象方法可以有普通方法，而接口在 JDK1.8 之前只能有抽像方法（1.8之后，增加了静态方法和默认方法）；

4、抽象方法可以有构造方法，接口不可以有构造方法。

5、一个类只能单继承一个父类，而一个接口可以继承多个父接口，同时，一个类可以实现多个接口却没有实现多个父类这一说法；

6、抽象方法在业务编程上更像一个模板，有自己的功能，同时也可以有优化补充的多种形式，而接口更像是一种规范和要求，实现就要按照要求来进行。

4.请你说一下final关键字

final可以修饰类，方法，变量。 final修饰类，该类不可被继承。 final修饰方法，该方法不能被重写。 final修饰变量，如果是基本变量则值不能再改变，如果是引用变量则引用地址不能改变，但值可以改变。

5.说说static修饰符的用法

Java类中包含了成员变量、方法、构造器、初始化块和内部类（包括接口、枚举）5种成员,static关键字可以修饰除了构造器外的其他4种成员。static关键字修饰的成员被称为类成员。类成员属于整个类,不属于单个对象。 static关键字有一条非常重要的规则,即类成员不能访问实例成员,因为类成员属于类的,类成员的作用域比实例成员的作用域更大,很容易出现类成员初始化完成时,但实例成员还没被初始化,这时如果类成员访问实力成员就会引起大量错误。加分回答 static修饰的部分会和类同时被加载。被static修饰的成员先于对象存在,因此,当一个类加载完毕,即使没有创建对象也可以去访问被static修饰的部分。静态方法中没有this关键词,因为静态方法是和类同时被加载的,而this是随着对象的创建存在的。静态比对象优先存在。也就是说,静态可以访问静态,但静态不能访问非静态而非静态可以访问静态。

6.请你说说String类,以及new string和使用字符串直接量

String类被final修饰，所以不能被继承。创建String对象时可以使用字符串直接量，如String str=”1abc”, 另一种String str=new String(“1abc”),前者使用常量池来管理，后者先判断常量池中是否已存在此字符串，不存在就也在常量池创建，再在堆内存创建一个新的对象，因此后者开销更大。

7.String、StringBuffer、Stringbuilder有什么区别

StringBuilder和StringBuffer非常类似，均代表可变的字符序列，而且方法也一样

String:不可变字符序列，效率低，但是复用率高。

StringBuffer:可变字符序列、效率较高(增删)、线程安全

StringBuilder:可变字符序列、效率最高、线程不安全

8.请你说说\==与 equals()的区别

== 比较基本数据类型时，比较的是两个数值是否相等；比较引用类型是，比较的是对象的内存地址是否相等。 equals() 没有重写时，Object 默认以\==来实现，即比较两个对象的内存地址是否相等；重写以后，按照对象的内容进行比较

9.请你说说hashCode()和equals()的区别,为什么重写equals()就要重写hashcod()

得分点 hashCode()用途,equals()用途,hashCode()、equals()约定

1、hashCode()：获取哈希码，equals()：比较两个对象是否相等。

2、二者两个约定：如果两个对象相等，它们必须有相同的哈希码；若两个对象的哈希码相同，他们却不一定相等。也就是说,equals()比较两个对象相等时hashCode()一定相等，hashCode()相等的两个对象equqls()不一定相等。

3、加分回答：由于hashCode()与equals()具有联动关系，equals()重写时，hashCode()进行重写，使得这两个方法始终满足相关的约定。

10.请你讲一下Java 8的新特性

得分点 Lambda表达式、Java8对接口的改进

1、Lambda表达式：可将功能视为方法参数，或者将代码视为数据。使用 Lambda 表达式，可以更简洁地表示单方法接口（称为功能接口）的实例。

2、方法引用：提供了非常有用的语法，可直接引用已有Java类或对象（实例）的方法或构造器。与Lambda联合使用,方法引用可以使语言的构造更紧凑简洁,减少冗余代码。

3、对接口进行了改进：允许在接口中定义默认方法，默认方法必须使用default修饰。

4、Stream API：新添加的Stream API（java.util.stream）支持对元素流进行函数式操作。Stream API 集成在 Collections API 中,可以对集合进行批量操作，例如顺序或并行的 map-reduce 转换。

5、Date Time API：加强对日期与时间的处理。

11.介绍一下包装类的自动拆装箱与自动装箱

得分点包装类的作用,应用场景

1、自动装箱、自动拆箱是JDK1.5提供的功能。

2、自动装箱：把一个基本类型的数据直接赋值给对应的包装类型；

3、自动拆箱是指把一个包装类型的对象直接赋值给对应的基本类型；

4、通过自动装箱、自动拆箱功能，简化基本类型变量和包装类对象之间的转换过程

12.请你说说Java的异常处理机制

1、异常处理机制让程序具有容错性和健壮性,程序运行出现状况时,系统会生成一个Exception对象来通知程序

2、处理异常的语句由try、catch、finally三部分组成。try块用于包裹业务代码,catch块用于捕获并处理某个类型的异常,finally块则用于回收资源。

3、如果业务代码发生异常,系统创建一个异常对象,并将其提交给JVM,由JVM寻找可以处理这个异常的catch块,并将异常对象交给这个catch块处理。如果JVM没有找到，运行环境终止,Java程序退出。

4、Java也允许程序主动抛出异常。当业务代码中,判断某项错误的条件成立时,可以使用throw关键字向外抛出异常

13.说说你对面向对象的理解

1、面向对象三大基本特征：封装、继承、多态。

2、封装：将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，让外部程序通过该类提供的方法来实现对内部信息的操作和访问,提高了代码的可维护性；

3、继承：实现代码复用的重要手段,通过extends实现类的继承，实现继承的类被称为子类，被继承的类称为父类；

4、多态的实现离不开继承,在设计程序时,我们可以将参数的类型定义为父类型。在调用程序时根据实际情况,传入该父类型的某个子类型的实例,这样就实现了多态。

多态实现的三个条件：1.需要有继承关系的存在。 2. 需要有方法的重写。 3. 需要有父类的引用指向子类对象。

14.请你说说重载和重写的区别,构造方法能不能重写

重写和重载的区别：

1.重载发生在同一类中，而重写发生在子类中。

2.重载要求方法名相同，参数列表，返回值，访问修饰符都可以不同。重写要求方法名相同，参数列表相同，返回值类型要小于等于父类的方法，抛出的异常要小于等于父类方法抛出的异常，访问修饰符权限大于等于父类方法的访问修饰符权限。

3.final，private修饰的方法不能重写，构造方法也不能重写。

构造方法不能重写。因为构造方法需要和类保持同名,而重写的要求是子类方法要和父类方法保持同名。如果允许重写构造方法的话,那么子类中将会存在与类名不同的构造方法,这与构造方法的要求是矛盾的。

15.请介绍一下访问修饰符

Java中的访问修饰符有四种，分别为private,default,protected,public。

private：类中被private修饰的只能在被当前类的内部访问

default：类中被default修饰的只能在当前类和当前类所在包的其他类访问

protected：类中被protected修饰的可以被当前类和当前类所在的包的其他类以及子类访问

public：类中被public修饰的能被当前项目下的所有类访问。

16.请你说说泛型、泛型擦除

1.泛型：Java在jdk1.5引入了泛型，在没有泛型之前，每次从集合中读取的对象都必须进行类型转换，如果在插入对象时，类型出错，那么在运行时转换处理的阶段就出错；在提出泛型之后就可以明确的指定集合接受哪些对象类型，编译器就能知晓并且自动为插入的代码进行泛化，在编译阶段告知是否插入类型错误的对象，程序会变得更加安全清晰。

2.泛型擦除：Java泛型是伪泛型，因为Java代码在编译阶段，所有的泛型信息会被擦除，Java的泛型基本上都是在编辑器这个层次上实现的，在生成的字节码文件中是不包含泛型信息的，使用泛型的时候加上的类型，在编译阶段会被擦除掉，这个过程称为泛型擦除。

17.请说说你对反射的了解

在程序运行期间动态的获取对象的属性和方法的功能叫做反射。

它能够在程序运行期间，对于任意一个类，都能知道它所有的方法和属性，对于任意一个对象，都能知道他的属性和方法。

获取Class对象的三种方式：getClass(); xx.class; Class.forName(“xxx”);

反射的优缺点：

优点：运行期间能够动态的获取类，提高代码的灵活性。

缺点：性能比直接的Java代码要慢很多。

应用场景：spring的xml配置模式，以及动态代理模式都用到了反射。

18.请你说说多线程

进程是操作系统资源调度的基本单位，线程是处理器任务调度和执行的基本单位，一个进程可以创建多个线程，每个线程有自己独立的程序计数器，本地方法栈和虚拟机栈，线程之间共享进程的堆和方法区。线程之间是通过时间片算法来争夺CPU的执行权的。

多线程的优点：当一个线程进入阻塞或者等待状态时，其他的线程可以获取CPU的执行权，提高了CPU的利用率。

多线程的缺点：可能产生死锁；频繁的上下文切换可能会造成资源的浪费；在并发编程中如果因为资源的限制，多线程串行执行，可能速度会比单线程更慢。

死锁四个条件：

（1）互斥条件：一个资源每次只能被一个进程使用。

（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。

（3）不剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺。

（4）循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

19.说说线程的创建方式

创建线程有三种方式，分别是继承Thread类，实现Runnable接口，实现Callable接口

继承Thread类之后我们需要重写run()方法，方法中是我们希望这个线程执行什么操作，再创建对象的实例，通过实例对象的start())方法开启这个线程

实现runnable接口之后，我们需要实现run()方法，方法中同样写我们需要执行的操作，然后将实现了接口的类作为参数创建一个Thread对象，通过这个对象的start方法开启线程

实现Callable之后，需要实现call()方法，方法中写我们需要的操作，然后创建实现接口类的对象，将对象作为参数创建FurtureTask对象，再将task对象作为参数创建thread对象，调用start方法开启线程，还可以使用task对象的get方法获取返回值。他们的区别是前二者不能获取返回值，callable接口可以获得返回值，一般在实际使用中，更多使用实现接口的方式开启线程，因为接口不会占用类的继承位置

20.说说线程的状态

1：新建态(NEW)：当一个线程被创建成功后，但并没有执行它的start方时处于该状态

2：就绪态(RUNNABLE)：一个线程执行了start方法进入就绪态开始竞争cpu调度权但还没有竞争到以完成它的任务

3：运行态：一个线程对象获取到了cpu的资源调度权，并进入允许态开始完成它的任务

4：阻塞态(BLOCKED)：若一个运行中的线程存在同步操作，此时锁被其他线程占用，该线程就会进入阻塞态等待获取锁

5：限期等待(TIMED WAITING)：正在运行的线程执行了Thread.spleep()方法或者设置了timeout的wait()方法，join方法等进入一定时间的等待，系统自动唤醒。

6：不限期等待(WAITING)：正在运行的线程执行了未设置timeout的wait方法或join方法进入等待，只有通过其他线程使用interrupt()或notify方法对其进行唤醒。

7：死亡态(TEMINATED)：线程成功执行完毕或执行中抛出异常中断了线程会进入死亡态。

21.说说wait()和sleep()的区别

1.所属的类型不同 - wait()是Object类的实例方法,调用该方法的线程将进入WAITING状态。 - sleep()是Thread类的静态方法,调用该方法的线程将进入TIMED_WTING状态。

2.对锁的依赖不同 - wait()依赖于synchronized锁,通过监视器进行调用,调用后线程会释放锁。 - sleep()不依赖于任何锁,所以在调用后它也不会释放锁

3.返回的条件不同 - 调用wait()进入等待状态的线程,需要由notify()/notifyAll()唤醒,从而返回。 - 调用sleep()进入超时等待的线程,需要在超时时间到达后自动返回。

22.说说怎么保证线程安全

线程的安全主要是原子性、可见性、有序性三个问题。

1、可见性：可见性问题是由处理器核心的缓存导致的,每个核心均有各自的缓存,而这些缓存均要与内存进行同步，volatile在多处理器开发中保证了共享变量的“可见性”

2、原子性：一个或者多个操作在CPU执行的过程中不被中断的特性。线程切换可能造成原子性问题。synchronized关键字可以解决原子性、有序性和可见性问题，同时lock和Atomic开头的类也可以解决原子性问题

3、有序性：程序执行的顺序按照代码的顺序执行，编译优化可能造成这个问题。volatile关键字通过禁止指令重排来解决有序性问题

23.说说你了解的线程同步方式

java主要通过加锁的方式实现线程同步：主要有两种方式：synchronized关键字和lock接口。

synchronized可以加在三个不同的位置，对应着三种不同范围，区别是锁对象的不同：

1.加在实例方法上，锁的就是当前的实例。

2.加在静态方法和类上，锁的就是当前整个类。

3.加在代码块上，锁的就是代码块里面的内容。我们应该合理的选择锁的对象。

lock锁接口除了支持上述功能外，还支持了响应中断，超时机制，阻塞队列等。

24.说说你了解的线程通信方式

25.说说Java中常用的锁及原理

synchronized关键字和lock锁接口：

synchronized关键字底层采用java对象头来存储锁信息的。

lock锁接口是基于AQS实现的。AQS内部定义一个先进先出的队列实现锁的同步，同时还定义了同步状态来记录锁信息。

26.synchronized和Lock有什么区别

synchronized是同步锁，可以修饰静态方法、普通方法和代码块。修饰静态方法时锁住的是类对象，修饰普通方法时锁住的是实例对象。当一个线程获取锁时，其他线程想要访问当前资源只能等当前线程释放锁。

synchronized是java的关键字，Lock是一个接口。

synchronized可以作用在代码块和方法上，Lock只能用在代码里。

synchronized在代码执行完或出现异常时会自动释放锁，Lock不会自动释放，需要在finally中释放。

synchronized会导致线程拿不到锁一直等待，Lock可以设置获取锁失败的超时时间。

synchronized无法获知是否获取锁成功，Lock则可以通过tryLock判断是否加锁成功。

27.说说synchronize的用法及原理

synchronized可以修饰静态方法、普通方法、代码块。能够保证同一个时刻只有一个线程执行该段代码，保证线程安全。在执行完或者出现异常时自动释放锁。 synchronized作用在代码块时，它的底层是通过monitorenter、monitorexit指令来实现的。

28.说说你对AQS的理解

1、AQS队列同步器,用来构建锁的基础框架,Lock实现类都是基于AQS实现的。

2、AQS是基于模板方法模式进行设计的,所以锁的实现需要继承AQS并重写它指定的方法。

3、AQS内部定义了一个FIFO的队列来实现线程的同步,同时还定义了同步状态来记录锁的信息。

4、AQS的模板方法,将管理同步状态的逻辑提炼出来形成标准流程,这些方法主要包括：独占式获取同步状态、独占式释放同步状态、共享式获取同步状态、共享式释放同步状态

29.说说你对线程池的理解

ThreadPoolExecutor构造器：
public ThreadPoolExecutor（int corePoolSize
int maximumPoolSize,
long keepAliveTIme,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
参数一：指定线程池的线程数量（核心线程）：corePoolsize ——-> 不能小于0
参数二：指定线程池可支持的最大线程数：maximumPoolSize ———> 最大数量>=核心线程数量
参数三：指定临时线程的最大存活时间：keepAliveTime ———> 不能小于0
参数四：存活时间的单位（秒，分，时，天）：unit ———> 时间单位
参数五：指定任务队列：workQueue ———> 不能为null
参数六：指定用那个线程工厂创建线程：threadFactory ———> 不能为null
参数七：指定线程忙，任务忙的时候，新任务来了怎么办，即拒绝策略：handler ———> 不能为null

（重要！！！）注意两点：
临时线程什么时候创建：新任务提交时发现核心线程都在忙，任务队列满，还可以创建临时线程时才会创建。
什么时候开始拒绝任务：核心线程和临时线程都在忙，任务队列都满，新任务过来会拒绝。

拒绝策略：

策略详解

ThreadPoolExecutor.AbortPolicy 丢弃任务抛出RejectedExecutionException异常

ThreadPoolExecutor.DiscardPolicy 丢弃任务不抛出异常（不推荐）

ThreadPoolExecutor.DiscardOldestPolicy 抛弃等待最久的任务并把当前任务加入队列

ThreadPoolExecutor.CallerRunsPolicy 由主线程负责调用的run()方法绕过线程池直接执行，即来新任务主线程亲自服务

30.说说volatile的用法及原理

1.修饰被不同线程访问和修改的变量

2.被其修饰的变量，系统每次用到它时都是直接从对应的内存中提取，而不会利用缓存（如寄存器），所有线程在任何时候所看到变量的值都是相同的

3.volatile不能保证操作的原子性，因此不能代替synchronized

4.能不使用就尽量不要使用

*31.说说你对ThreadLocal的理解

ThreadLocal即线程变量，它用于共享变量在多线程中的隔绝，即每个线程都有一个该变量的副本彼此互不影响也就不需要同步机制了，

实现原理：每个Thread对象中都有一个ThreadLocal类的内部类ThreadLocalMap对象，他是一个键值形式的容器，以ThreadLocal对象的get和set方法来存取共享变量值，原理时：以ThreadLocal对象作为key来存取共享变量值。一个ThreadLocal用完后必须remove，否则会造成内存泄漏。

*32.请你说说JUC

JUC是java.util.concurrent的缩写，这个包中包含了支持并发操作的各种工具。

1.原子类：遵循比较和替换原则。可以用于解决单个变量的线程安全问题。

2.锁：与Synchronized类似，在包含synchronized所有功能的基础上，还支持超时机制，响应中断机制，主要用于解决多个变量的线程安全问题。

3.线程池：可以更方便的管理线程，同时避免重复开线程和杀线程带来的消耗，效率高。

4.并发容器：例如ConcurrentHashMap，支持多线程操作的并发集合，效率更快。

?33.Java哪些地方使用了CAS

1、CAS 比较并交换,比较典型的使用场景有原子类、AQS、并发容器。

2、AQS：在向同步队列的尾部追加节点时,它首先会以CAS的方式尝试一次,如果失败则进入自旋状态,并反复以CAS的方式进行尝试。

3、并发容器：以ConcurrentHashMap为例,它的内部多次使用了CAS操作。在初始化数组时,以CAS的方式修改初始化状态,避免多个线程同时进行初始化。在执行put方法初始化头节点时,它会以CAS的方式将初始化好的头节点设置到指定槽的首位,避免多个线程同时设置头节点。

34.请说说你对Java集合的了解

java中的集合类主要都有Collection和Map这两个接口派生而出，其中Collection又派生出List,Set,Queue。所有的集合类都是List,set,queue,map这四个接口的实现类。其中，list代表有序的，可重复的数据集合；set代表无序的，不可重复的数据集合，queue代表先进先出的队列；map是具有映射关系的集合。最常用的实现类又ArrayList,LinkedList,HashMap,TreeMap,HashSet,TreeSet,ArrayQueue。

35.你知道哪些线程安全的集合？

java.util包中的集合类大部分都是非线程安全的，例如：ArrayList/LinkedList/HashMap等等，但也有少部分是线程安全的，像是Vector和Hashtable，它们属于很古老的API了，是基于Synchronized实现的，性能很差，在实际的开发中不常用。一般可以使用collections工具类中的syncheronizedXxx()方法将非线程安全的集合包装成线程安全的类。在java5之后可以使用concurrent包提供的大量的支持并发访问的集合类，例如ConcurrentHashMap/CopyOnWriteArrayList等

36.请你说说HashMap底层原理

在1.8之前，HashMap的底层是数组加链表，在1.8之后是数组+链表+红黑树；它的put流程是：基于哈希算法来确定元素位置，当我们向集合存入数据时，他会计算传入的key的哈希值，并利用哈希值取绝对值再根据集合长度取余来确定元素的位置，如果这个位置已经存在其他元素了，就会发生哈希碰撞，则hashmap就会通过链表将这些元素组织起来，如果链表的长度达到8时，就会转化为红黑树，从而提高查询速度。扩容机制：HashMap中数组的默认初始容量为16，当达到默认负载因子0.75时，会以2的指数倍进行扩容。 Hashmap时非线程安全的，在多线程环境下回产生循环死链，因此在多线程环境下建议使用ConcurrentHashMap。

37.请你说说HashMap和Hashtable的区别

1.Hashtable在实现Map接口时保证了线程安全性，而HashMap则是非线程安全的。所以Hashtable的性能不如HashMap,因为为了保证线程它牺牲了一些性能。

2.Hashtable不允许存入null，无论是以null作为key或value,都会引发异常但，HashMap是允许的。Hashtable是很古老的API，性能不好，不推荐使用，要在多线程下使用ConcurrrntHashMap,它不但保证了线程安全，也通过降低锁的粒度提高了并发访问时的性能

38.HashMap是线程安全的吗？如果不是该如何解决

HashMap不是线程安全的，在添加数据的时候，会根据key和value计算出在底层数组中的位置，然后封装成entrey对象插入，但由于HashMap并没有做对应的线程安全处理，所以如果恰好两个线程同时操作的话，就有点会将其中一个数据覆盖掉，这不符合要求。那么解决方法就是说，你可以在操作这个HashMap的时候手动的上锁，可以通过Lock也可以通过synchronized关键字。当然我更推荐直接使用java已经提供了的ConcurrentHashMap，其内部使用了Lock来解决线程安全问题，并且底层结构也进行了一些变动，上锁的时候只会锁对应下标的元素，不会对其他位置造成影响，即保证了线程安全，又保证了性能。

*39.请你说说ConcurrentHashMap

ConcurrentHashMap是一个线程安全的集合，它的底层是数组+链表/红黑树构成的。在1.7的时候采用segment数组+hashEntry的方式实现的，lock加在Segment的上面，在size计算的时候，首先是不加锁的，最多计算三次，前后两次的结果是相同的话那么结果就是准确的，如果不一样的话，那么就加锁，重新计算。在1.8的时候废弃了这种算法，采用Synchronized+CAS+Node来保证并发安全的进行，使用一个volatile类型的变量baseCount来记录元素的个数，集合每次增加或者删除的时候，basecount就会通过addCount()来对baseCunt产生相应的变化，最后得到元素的个数。初始值为16,每次扩容都是之前的二倍，不支持null值和null为key

40.说说你对ArrayList的理解

arraylist在jdk7.0的时候，创建容器的时候会在底层创建一个长度为10的object数组，在jdk8.0的时候，在创建容器的时候底层并不会立刻创建，只有在第一次调用add方法的时候才会创建一个长度为10的数组，默认情况下，扩容为原来容量的1.5倍，同时将原有数组中的值复制到新的数组中，并且arraylist属于有序的，可重复的集合，提供了iterator方法，增强了迭代能力。

41.请你说说ArrayList和LinkedList的区别

1.ArrayList的实现是基于数组,LinkedList的实现是基于双向链表。

2.对于随机访问ArrayList要优于LinkedList,ArrayList可以根据下标以O(1)时间复杂度对元素进行随机访问,而LinkedList的每一个元素都依靠地址指针和它后一个元素连接在一起,查找某个元素的时间复杂度是O(N)。

3.对于插入和删除操作,LinkedList要优于ArrayList,因为当元素被添加到LinkedList任意位置的时候,不需要像ArrayList那样重新计算大小或者是更新索引

4.LinkedList比ArrayList更占内存,因为LinkedList的节点除了存储数据,还存储了两个引用,一个指向前一个元素,一个指向后一个元素。

42.请你说说List与Set的区别

list和set都是接口collection的子接口，list代表有序的可重复的集合，每个元素都有对应的顺序索引，可以通过索引来访问指定位置的集合元素。而set表示无序，不可重复的集合元素。但是它有支持排序的实现类treeset，treeset可以确保元素处于排序状态，并支持自然排序和定制排序两种方式，treeset是非线程安全的，内部元素的值不能为null

?43.请你说说BIO、NIO、AIO

BIO是阻塞IO，当用户线程发送请求后会一直阻塞知道内核将数据准备；NIO是非阻塞IO，用户线程发送请求后，可以做其他工作，并不断询问内核数据，但在数据复制阶段，用户线程依然属于阻塞状态。BIO和NIO都属于同步IO。AIO是异步IO，当用户线程发送请求后，内核会返回一个回调函数，但该回调函数不包含数据，之后用户线程可以去处理其他操作，当数据准备好后，内核会将数据发送给用户线程，而不必像同步IO中用户线程自己去读取。BIO只能处理一个请求，NIO可以处理多个请求。IO多路复用在NIO的基础上加入了事件机制，将用户请求注册到多路复用器上，然后监视是否有IO事件发生，如果有，会通知用户线程，IO多路复用的方式主要有select、poll、epoll。

?44.请你说说IO多路复用

IO多路复用指的是单个线程能够同时完成对多个IO事件的监听处理。linux提供了select、poll和epoll三种多路复用方式。本质上是利用内核缓存fd描述文件，并内核完成对文件描述符的监听操作。selec是将所用文件描述符的集合从用户态拷贝到内核空间，底层采用的是数组。poll和select相似，主要区别是poll底层使用的是链表，所以其能够监听的文件描述符不受限制。但是这两种方法都需要多次的内核与用户空间的复制拷贝，并且用户空间还需要在O(N)的时间复杂度下对描述符进行遍历才具体知道哪一个文件描述符发生了事件。epoll在内核开辟空间底层采用红黑树，用户可以直接在内核创建需要需要关注的文件描述的节点，当事件发送内核将对应文件描述符直接存入队列并将其返回到用户空间。epoll这种方式可以减少每次调用时从用户空间复制到内核的操作，并且因为内核返回的发送事件描述符的队列，可以减少每次轮询的操作，使得在O(1)的时间复杂度就能找到发送事件的描述符。

?45.请你讲一下Java NIO

NIO弥补了原来同步阻塞IO的不足，它在标准Java代码中提供了高速的、面向块的IO。通过定义包含数据的类，以及通过以块的形式处理这些数据。NIO包含三个核心的组件：Buffer（缓冲区）、Channel（通道）、Selector（多路复用器）。Buffer是一个对象，它包含一些写入或者要读出的数据。在读取数据时，它是直接读到缓冲区中的。在写入数据时，写入到缓冲区中，任何时候访问NIO中的数据，都是通过缓冲区进行操作。Channel是一个通道，可以通过它的读取和写入数据，它就像自来水管一样，网络数据通过Channel读取和写入。通道和流的不同之处在于通道是双向的，流只是在一个方向上移动而且通道可以用于读、写或者同时读写。Selector会不断地轮询注册在其上的Channel，如果某个Channel上面有心的TCP连接接入、读和写事件，这个Channel就处于就绪状态，会被Selector轮询出来，然后通过SelectionKey可以获取就绪Channel的集合，进行后续的IO操作

46.简单说下你对JVM的了解

JVM是Java语言跨平台的关键，Java在虚拟机层面隐藏了底层技术的复杂性以及机器与操作系统的差异性。运行程序的物理机千差万别，而JVM则在千差万别的物理机上面简历了统一的运行平台，实现了在任意一台JVM上编译的程序，都能在任何其他JVM正常运行。 JVM由三部分组成：类加载子系统、执行引擎和执行时数据区。

1）类加载子系统：可以根据指定的全限定名来载入类或接口。

2）执行引擎：负责执行那些包含在被载入类的方法中的指令。

3）当程序运行时，JVM需要内存来存储许多内容，例如：字节码、对象、参数、返回值、局部变量、运算的中间结果等，JVM会把这些东西都存储到运行时数据区中，以便于管理。而运行时数据区又可以分为方法区、堆、虚拟机栈、本地方法栈、程序计数器。

47.说说你了解的JVM内存模型

JVM由三部分组成：类加载子系统、执行引擎、运行时数据区 1、类加载子系统：可以根据指定的全限定名来载入类或接口。 2、执行引擎：负责执行那些包含在被载入类的方法中的指令。 3、运行时数据区：分为方法区、堆、虚拟机栈、本地方法栈、程序计数器。当程序运行时,JVM需要内存来存储许多内容,例如：字节码、对象、参数、返回值、局部变量、运算的中间结果等,把这些东西都存储到运行时数据区中,以便于管理。

48.说说Java运行时数据区

Java运行时数据区由五部分组成：程序计数器、Java栈、本地方法栈、Java堆和方法区。程序计数器控制着程序下一步的执行，如循环、分值判断等，Java栈保存着方法运行时的数据结构，方法的调用和结束对应着一个帧栈的入栈和出栈，本地方法栈与Java栈作用类似，其作用对象是本地方法，Java堆中存储new的对象，也是垃圾回收的重要管理区域，方法区中保存着全局变量、静态变量等。方法区和Java堆是线程共享的，而程序计数器和Java栈是线程私有的。

49.说说JVM的垃圾回收机制

JVM的垃圾回收机制是遵循分代收集理论进行设计的，主要分为四种收集方式：

1.新生代收集，目标为新生代的垃圾收集。

2.老年代收集：目标为老年代的垃圾收集，目前只有CMS收集器会有这种行为。

3.混合收集：目标为整个新生代及部分老年代的垃圾收集，目前只有G1收集器会有这种行为。

4.整堆收集：目标为整个方法区和堆的垃圾收集。

常见的垃圾回收算法包括：标记清除算法：缺点：内存碎片化，优点：速度快。

标记复制算法：缺点占用内存大，优点：内存连续。

标记整理算法：优点：内存连续，缺点：整理效率低。

50.说说JVM的垃圾回收算法

1.引用计数法，每次赋值时均要维护引用计数器且计数器本身也有一定的消耗，较难处理循环引用，一般不采用这种方式

2.复制算法，将内存分为两块，每次只使用其中一块，当这块内存用完，就将还活着的对象复制到另外一块上面，效率高且没有碎片，但是需要双倍的空间，年轻代中使用复制算法

3.标记-清除，先标记要清除的对象，然后统一回收这些对象，不需要额外的空间，但是需要两次扫描耗时严重并且会产生内存碎片

4.标记-整理，标记存活对象，然后将标记的存活对象按内存地址依次排序，清除边界外未标记的对象，没有内存碎片，但是需要移动对象。老年代一般用标记-清除和标记-整理的混合实现

51.说说GC的可达性分析

可达性分析算法用于判断对象是否可以被回收，程序通过GC Roots中的对象为起点，以类之间的引用关系简历引用链，最终形成一个类似于数据结构中森林的一个结果，不存在与森林中的对象便是需要被回收的对象。这里的GC Roots主要包括线程栈中引用的变量，本地方法栈中引用的变量，方法区中的静态引用对象，常量池中的常量引用对象和被锁引用的对象。对一个对象真正的宣告回收需要经历两次标记过程，如果一个对象不再引用链上就会对它进行第一次标记，并判断它是否重新了finalize方法，若未重新或finalize方法已经被执行过了则会直接回收对象，否则会创建一个F-queue队列来存储这些对象，并启动一个低优先级的Finalizer线程去执行它们的finalize方法。第二次标记，稍后收集器会对队列中的对象进行可达性分析并标记，若仍然存在标记则表明该对象没有通过finalize方法实现自救则直接回收，否则对象复活。任何对象的finalize方法都只能被调用一次。

52.请你说说Java的四种引用方式

java中的四种引用方式分别是：1，强引用，以new关键字创建的引用都是强引用，被强引用引用的对象永远都不会被回收。2，软引用：以SoftRererenc引用对象，被弱引用引用的对象只有在内存空间不足时会被垃圾回收。3，弱引用，以WeakReference引用对象，被弱引用引用的对象一定会被回收，它只能存活到下一次垃圾回收。4，虚引用：以PhantomReference引用对象，一个对象被引用引用后不会有任何影响，也无法通过该引用来获取该对象，只是其再被垃圾回收时会收到一个系统通知。

53.请你讲下CMS垃圾回收器

CMS垃圾收集器采用标记清除算法，使用多线程实现，所以它的应用场景一般为服务端系统的老年代。它是一个以达到在垃圾回收期间用户线程低停顿为目标的垃圾收集器。CMS垃圾收集器垃圾回收分为四个阶段：1，初始标记：只对与GCRoots有直接关键的对象进行可达性分析的标记。2，并发标记：标记整个GCRoots引用链中的对象，与用户线程并发执行。3，重新标记：用于更新在并发标记过程中被复活的对象。4，并发清除：清除标记阶段判断的已死亡的对象。该流程与用户线程并发执行。缺点：1，它使用标记清除算***导致内存碎片化，2，会产生在并发清除阶段的浮动垃圾，只有到下一次垃圾回收时才会被清除。

54.请你讲下G1垃圾回收器

G1回收器是一个多线程，可以同时收集新生代和老年代的一个垃圾收集器。G1将整个堆内存区域划分为多个大小相等的region，追踪每个Region可以回收对象的大小和预估时间，并以region为单位进行垃圾收集并获取每个region的收集效率和收集收益，通过一张优先级表对其进行维护。 G1可以设置垃圾回收的预期停顿时间（STW）。 G1的年轻代和老年代空间并不是固定的，当现有年轻代分区占满时，JVM会分配新的空闲Region加入到年轻代空间，老年代也是如此。 G1 GC的回收过程中有内存整理，理论上不会产生内存碎片！ G1垃圾收集器垃圾回收主要包括四个流程：1，初始标记 2，并发标记（类似于CMS） 3，最终标记 4，并发筛选回收：根据优先级表选择分区进行垃圾回收，用户线程不停顿。

55.说说类加载机制

类加载的过程中首先判断这个是否被加载过，如果没有被加载过，那么调用类加载器进行加载，判读这个类是否符合规范，如果不符合就抛出异常，加载成功就会生成class对象。接下来是链接过程，分为三步：准备，验证，准备，解析。验证：确保文件符合规范，不会危害虚拟机自身的安全，对文件格式，字节码，元数据，符号引用进行验证。准备:为类变量分配初始空间以及默认初始值，即零值。这里不会为实例变量分配，类变量分配在方法区中，实例变量跟随对象分配在堆中，final修饰的在编译期间就分配了，在准备阶段会显式的初始化。解析：将常量池内的直接引用转为直接引用的过程。链接过程完成之后开始初始化的过程：初始化阶段就是执行类构造器方法的过程。此方法不需要定义，一个类只会被加载一次，虚拟机必须保证在多线程条件下类的构造方法是被加锁的。

56.说说JVM的双亲委派模型

双亲委派模型的工作过程是,如果一个类加载器收到了类加载的请求,它首先不会自己去尝试加载这个类,而是把这个请求委派给父类加载器去完成,每一个层次的类加载器都是如此,因此所有的加载请求最终都应该传送到最顶层的启动类加载器中,只有当父加载器反馈自己无法完成这个加载请求时,子加载器才会尝试自己去完成加载

57.说说类的实例化过程

类实例化的过程。类加载，分配内存，初始化零值，状态设置，构造函数。

58.请你说说内存溢出

内存溢出：指程序运行过程中申请的内存大于系统能够提供的内存，导致无法申请到足够的内存，于是就发生了内存溢出。引起内存溢出的原因：1.内存加载的数据量过于庞大。如一次从数据库取出的过多的数据。2.代码中存在死循环或者死循环中产生大量的对象实体。3.启动内存值设定过小。解决内存溢出的方案：修改JVM启动参数，直接增加内存。2.检查错误日志，查看“OutOfMemory”错误之前是否存在异常。3.对代码进行debug分析。4.使用内存工具动态查看内存使用情况。常见的内存溢出出现在：1.堆。对象创建过多2.栈溢出3.方法区和运行时常量池；创建大量动态类。

59.请你说说内存泄漏

内存泄露：指不再使用的对象仍然被引用，导致垃圾收集器无法回收它们的内存，最终导致OOM。

60.请你说说进程间的通信方式

1.管道：管道本质是内核中维护的一块内存缓冲区。2.命名管道：因为无名管道只适用于具有亲缘关系的线程，所以就衍生出来命名管道，这样就可以实现了非亲缘关系进程之间的通信。3.信号：一种通知机制。4.消息队列：是一个消息链表，既可以读消息，也可以写消息。5.共享内存：多个线程共享一片内存区域。6.内存映射：就是将磁盘文件数据映射到内存，通过修改内存就能修改磁盘文件。7socket接口，socket接口一般用于不同主机上进程之间的通信

61.请你说说线程和协程的区别

协程与线程的区别: 1) 一个线程可以多个协程，一个进程也可以单独拥有多个协程。 2) 线程进程都是同步机制，而协程则是异步。 3) 协程能保留上一次调用时的状态，每次过程重入时，就相当于进入上一次调用的状态。 4）线程是抢占式，而协程是非抢占式的，所以需要用户自己释放使用权来切换到其他协程，因此同一时间其实只有一个协程拥有运行权，相当于单线程的能力。 5）协程并不是取代线程, 而且抽象于线程之上, 线程是被分割的CPU资源, 协程是组织好的代码流程, 协程需要线程来承载运行, 线程是协程的资源, 但协程不会直接使用线程, 协程直接利用的是执行器(Interceptor), 执行器可以关联任意线程或线程池, 可以使当前线程, UI线程, 或新建新程.。 6）线程是协程的资源。协程通过Interceptor来间接使用线程这个资源。

62.请你说说线程和协程的区别

线程是操作系统的资源,线程的创建、切换、停止等都非常消耗资源,而创建协程不需要调用操作系统的功能,编程语言自身就能完成,所以协程也被称为用户态线程,协程比线程轻量很多；

线程在多核环境下是能做到真正意义上的并行,而协程是为并发而产生的；

一个具有多个线程的程序可以同时运行几个线程,而协同程序却需要彼此协作的运行；

线程进程都是同步机制,而协程则是异步；

线程是抢占式,而协程是非抢占式的,所以需要用户自己释放使用权来切换到其他协程,因此同一时间其实只有一个协程拥有运行权,相当于单线程的能力；

操作系统对于线程开辟数量限制在千的级别,而协程可以达到上万的级别。

63.请你说说死锁定义及发生的条件

死锁：两个或者两个以上的线程互相争夺对方的资源而不释放自己的资源，从而导致死锁的产生。死锁产生的条件：互斥：一个资源在同一个时刻只能由一个线程执行请求与保持：一个线程在请求被占用资源时，对已经获得的资源保持不放。循环等待：发生死锁时所有的线程都会形成一个死循环，一直阻塞。不可剥夺条件：线程对所获得的资源在未使用完时不能被其他线程剥夺，只能自己释放。避免死锁的方法就是破坏死锁产生的条件。

64.请你说说内存管理

linux操作系统采用段页式内存管理方式：页式存储管理可以有效的提高内存利用率，段式内存管理能反映程序的逻辑结构并有利于段的共享。将这两种方法结合起来就形成了段页式储存管理方式。段页式储存管理方式就是先建好用户程序分成若干个段，再把每个段分成若干页，并为每个段赋予一个段名

65.请你说说虚拟内存和物理内存的区别

物理内存以前,还没有虚拟内存概念的时候,程序寻址用的都是物理地址。程序能寻址的范围是有限的,这取决于 CPU 的地址线条数。比如在 32 位平台下,寻址的范围是 2^32 也就是 4G。并且这是固定的,如果没有虚拟内存,且每次开启一个进程都给 4G 物理内存,就可能会出现很多问题： - 因为物理内存是有限的,当有多个进程要执行的时候,都要给 4G 内存,很显然内存不够,这很快就分配完了,于是没有得到分配资源的进程就只能等待。当一个进程执行完了以后,再将等待的进程装入内存。这种频繁的装入内存的操作效率很低 - 由于指令都是直接访问物理内存的,那么任何进程都可以修改其他进程的数据,甚至会修改内核地址空间的数据,这是不安全的

虚拟内存由于物理内存有很多问题,所以出现了虚拟内存。虚拟内存是计算机系统内存管理的一种技术。它使得应用程序认为它拥有连续的可用的内存（一个连续完整的地址空间）,而实际上,它通常是被分隔成多个物理内存碎片,还有部分暂时存储在外部磁盘存储器上,在需要时进行数据交换。

66.请你说说IO多路复用（select、poll、epoll）

IO多路复用指的是单个进程或者线程能同时处理多个IO请求，select，epoll，poll是LinuxAPI提供的复用方式。本质上由操作系统内核缓冲IO数据，使得单个进程线程能监视多个文件描述符。select是将装有文件描述符的集合从用户空间拷贝到内核空间，底层是数组，poll和select差距不大，但是底层是链表，这就代表没有上限，而select有数量限制。epoll则是回调的形式，底层是红黑树，避免轮询，时间复杂度从O（n）变为O（1）

67.epoll原理

epoll是一种高效地IO多路复用技术。调用epoll_create()会创建一个结构体数据，里面包含一个用于遍历扫描文件描述符状态的红黑树和一个就绪列表。调用epoll_ctr()可以进行增删改要监听的文件描述符及事件。调用epoll_wt()就会让内核检测就绪事件，将就绪事件到该表列表返回。epoll有两种触发机制。水平触发：当文件描述符状态改变时就立即进行IO操作，如果不进行处理将继续通知。边沿触发：是高速工作方式。该机制默认你已经知道了状态描述符改变，再你改变IO状态后描述状态改变后不会通知。该种方式减少了epoll的重复触发次数，提升了效率。必须使用非阻塞接口防止因一个文件描述符阻塞读写其他任务饿死

68.请你说说MySQL的事务隔离级别

事务隔离级别是为了解决脏读、不可重复读、幻读脏读：一个事务读取了另一个事务未提交的数据不可重复读：事务A两次读取的数据不一致，读第二次之前可能有其他事务修改了这个数据并提交了幻读：事务A两次读取数据库，两次查询结果的条数不同，称为幻读。行数变了即为幻读，数据变了即为不可重复度事务隔离级别如下：读未提交：以上三个问题都解决不了读已提交：只能解决脏读可重复读：mysql的默认隔离级别，能解决脏读和不可重复读，包含了间隙锁，可以防止幻读串行化：都可以解决。（为每个读取操作加一个共享锁）

69.请你说说innodb和myisam的区别

1.innodb支持事务，myisam不支持。2.Innodb支持行级锁；myisam支持表级锁。3.Innodb的增删改性能更优；Myisam的查询性能更优。4.Innodb不支持全文索引，myisam默认支持。5.Innodb默认支持外键，而myisam不支持。

70.请你说说MySQL索引,以及它们的好处和坏处

MySQL索引是一种帮助快速查找数据的数据结构，可以把它理解为书的目录，通过索引能够快速找到数据所在位置。场景的索引数据结构有：Hash表（通过hash算法快速定位数据，但不适合范围查询，因为需要每个key都进行一次hash）、二叉树（查找和修改效率都比较高），但是在InnoDB引擎中使用的索引是B+Tree，相较于二叉树，B+Tree这种多叉树，更加矮宽，更适合存储在磁盘中。使用索引增加了数据查找的效率，但是相对的由于索引也需要存储到磁盘，所以增加了存储的压力，并且新增数据时需要同步维护索引。但是合理的使用索引能够极大提高我们的效率！

71.请你讲讲B树和B+树

B树和B+树都是多路平衡查找树。B树中所有节点都存放数据。B+树只有叶子结点存放数据，其他节点存放key。B树中的叶子结点是独立的，B+书中的叶子结点通过链与相邻叶子结点连接。B树查找使用的是二分查找，没有查找到叶子结点就可能结束，而B+树必须从根节点进行查找，查询效率更稳定。

72.MySQL主从同步是如何实现的

复制（replication）是MySQL数据库提供的一种高可用高性能的解决方案,一般用来建立大型的应用。总体来说,replication的工作原理分为以下3个步骤： 1. 主服务器（master）把数据更改记录到二进制日志（binlog）中。 2. 从服务器（slave）把主服务器的二进制日志复制到自己的中继日志（relay log）中。 3. 从服务器重做中继日志中的日志,把更改应用到自己的数据库上,以达到数据的最终一致性

73.请你说说数据库索引的底层数据结构

数据库索引用的是B+树，它的叶子节点存储所有的数据，并且叶子节点通过指针进行链接，树的查找效率与其高度有关，树的高度越高，查找效率越低，B+树的高度一般在2-4层，这意味着查找到某一键值只需要2-4次IO操作，而且现在的数据库1s中至少可以做100次IO操作，2-4次的IO操作意味着查询时间只需要0.02-0.04s，所以其查找效率很高。

74.请你说说聚簇索引和非聚簇索引

它们两个的最大区别就是索引和数据是否存放在一起。聚簇索引：索引和数据存放在一起，叶子节点保留数据行。非聚簇索引：索引和数据分开存放，叶子节点存放的是指向数据行的地址。

75.请你说说数据库引擎有哪些,各自有什么区别

1.InnoDB引擎支持MySQL事务，具有提交，回滚和崩溃恢复功能能够更加安全的保护用户数据；支持行级锁，提高多用户并发和性能；支持外键，维护数据完整性。 2.MyISAM引擎，占用空间较小，支持表级锁，能够限制读写工作的负载的性能，查询效率较高，常用于只读场景。 3.Memory引擎，将所有数据存储在RAM（主存）中，在非关键字查询时，查询效率较高。

76.数据库为什么不用红黑树而用B+树

索引的数据结构会被存储在磁盘中，每次查询都需要到磁盘中访问，对于红黑树，树的高度可能会非常的高，会进行很多次的磁盘IO，效率会非常低，B+树的高度一般为2-4，也就是说在最坏的条件下，也最多进行2到4次磁盘IO，这在实际中性能时非常不错的

77.请你介绍一下数据库的ACID

原子性

事务被视为不可分割的最小单元，事务的所有操作要么全部提交成功，要么全部失败回滚。

回滚可以用回滚日志（Undo Log）来实现，回滚日志记录着事务所执行的修改操作，在回滚时反向执行这些修改操作即可。

一致性

数据库在事务执行前后都保持一致性状态。在一致性状态下，所有事务对同一个数据的读取结果都是相同的。

隔离性

一个事务所做的修改在最终提交以前，对其他事务是不可见的。

持久性

一旦事务提交，则其所做的修改将会永远保存到数据库中。即使系统发生崩溃，事务执行的结果也不能丢失。

系统发生崩溃可以用重做日志（Redo Log）进行恢复，从而实现持久性。与回滚日志记录数据的逻辑修改不同，重做日志记录的是数据页的物理修改。

事务的 ACID 特性概念简单，但不是很好理解，主要是因为这几个特性不是一种平级关系：

只有满足一致性，事务的执行结果才是正确的。

在无并发的情况下，事务串行执行，隔离性一定能够满足。此时只要能满足原子性，就一定能满足一致性。

在并发的情况下，多个事务并行执行，事务不仅要满足原子性，还需要满足隔离性，才能满足一致性。

事务满足持久化是为了能应对系统崩溃的情况。

78.请你说说数据库的索引是什么结构,为什么不用哈希表

MySQL中的索引是采用B+树的，哈希表的查询效率很高，但是哈希表最大的问题就是不支持范围和顺序查找，还会产生哈希冲突问题

79.请你说说InnoDB的MVCC

多版本并发控制，最大的优点是无锁并发，读不加锁，因此读写不冲突，并发性好，它为每个数据都根据事务维护了多个版本，使其在并发事务中解决了读写冲突，同时使用快照读为MVCC提供了非阻塞读功能，所以它是一个用户解决读写冲突的无锁并发控制机制，它通过数据表的三个隐藏字段分别为 db_trx_id(最长操作事务id)，roll_point(undolog指针)，db_row_id(唯一性自增张列，可能没有)，undolog和readview实现。

80.请你说说索引怎么实现的B+树,为什么选这个数据结构

如何实现： - 索引的本质上就是通过预排序+树型结构来加快检索效率，而MySQL中使用InnoDB和MyISAM引擎时都使用了B+树实现索引 - 为什么选取： - 在二叉查找树上查找一个数据时，当出现海量信数据时，查找效率将大大折扣 - B+树是一种一棵平衡多路查找树，可以有效减少磁盘IO同时B+树增加了叶子节点间的连接，能保证范围查找时找到起点和终点后能快速取出需要的数据

81.请你说说乐观锁和悲观锁

乐观锁：乐观锁总是假设最好的情况，每次去拿数据的时候默认别人不会修改，所以不会上锁，只有当更新的时候会判断一下在此期间有没有人更新了这个数据。适用于多读，可以使用版本号机制进行控制悲观锁：悲观锁总是假设最坏的情况，每次去拿数据是都认为别人会修改，所以每次在拿数据时都会上锁，这样别人想拿这个数据时会阻塞直到拿到锁。mysql数据库的共享锁和排他锁都是悲观锁的实现。

82.说说你对Spring Boot的理解,以及它和Spring的区别

（1）1、从本质上来说,Spring Boot就是Spring,它帮你完成了一些Spring Bean配置。 2、Spring Boot使用“习惯优于配置”的理念让你的项目快速地运行起来 3、但Spring Boot本身不提供Spring的核心功能,而是作为Spring的脚手架框架,达到快速构建项目的目的

（2）Spring Boot优点, 可以快速构建项目 - 可以对主流开发框架的无配置集成 - 项目可独立运行,无需外部依赖Servlet容器 - 提供运行时的应用监控 - 可以极大地提高开发、部署效率 - 可以与云计算天然集成

（3）核心功能： 1. 自动配置针对很多Spring应用程序常见的应用功能,Spring Boot能自动提供相关配置。 2. 起步依赖 Spring Boot通过起步依赖为项目的依赖管理提供帮助。起步依赖其实就是特殊的Maven依赖和Gradle依赖,利用了传递依赖解析,把常用库聚合在一起,组成了几个为特定功能而定制的依赖。 3. 端点监控 Spring Boot 可以对正在运行的项目提供监控。

83.说说Spring Boot常用的注解

@SpringBootApplication:它是SpringBoot的核心注解，用于开启自动配置，准确的说是通过该注解内的@EnablAutoConfiguration注解实现的自动配置。 @EnableAutoConfiguration:自动配置注解，在启动Spring应用程序上下文时进行自动配置，自动配置通常是基于项目classpath中引入的类和已定义的bean来实现的。 @Import:@EnableAutoConfiguration的关键功能是通过@Import注解导入的ImportSelector来完成的。 @Congiguration：配置类注解，根据一些特定条件来控制bean的实例化的行为。 @ComponentScan：位置在SpringBoot的启动类上，Spring包扫描。

84.说说Soring Boot的起步依赖

SpringBoot将日常企业应用研发中的各种常见都抽取出来，做成一个个的starter（启动器），starter中整合了该场景下各种可能用到的依赖，用户只需要在Maven中引入starter依赖，SpringBoot就能自动扫描到要加载的信息并启动相应的默认配置。starter提供了大量的自动配置，让用户摆脱了处理各种依赖和配置的困扰。所有这些starter都遵循这约定俗成的默认配置，并允许用户调整这些配置，即遵循“约定大于配置”的原子

85.说说Spring Boot的启动流程

调用run方法，run方法执行流程 =》获取监听器参数配置-打印Banner信息-创建并初始化容器-监听器发送通知

86.说说Spring Boot的自动装配

靠EnableAutoConfigurations注解，首先会从spring.factories中寻找有没有AutoConfiguration类满足Conditional注解的生效条件，有的话，就是实例化该AutoConfiguration类，然后加载到spring容器就实现了spring的自动装配

87.简单介绍Spring

Spring是一个轻量级的免费框架，它有两大核心功能，分别是ioc和aop，ioc控制反转是将创建对象的权限交给spring容器来进行管理，可以很好的起到解耦和的作用，aop是一种编程思想，底层使用的是动态代理，可以在程序原有的功能上进行增强，常用的地方有日志记录，权限验证等

88.说说你对IoC的理解

IoC：控制反转。控制：对象的创建的控制权限；反转：将对象的控制权限交给spring。之前我们创建对象时用new，现在直接从spring容器中取，维护对象之间的依赖关系，降低对象之间的耦合度。实现方式为DI,依赖注入，有三种注入方式：构造器、setter、接口注入

89.说说你对AOP的理解

AOP面向切面编程。是spring两大核心之一，它是一种编程思想，是对OOP的一种补充。它可以对业务逻辑的各个部分进行隔离，降低耦合，提高代码的可重用性。它的底层是通过动态代理实现的。它的应用场景有事务、日志管理等。

90.说说Bean的生命周期

创建，初始化，调用，销毁； bean的创建方式有四种，构造器，静态工厂，实例工厂，setter注入的方式。 spring在调用bean的时候因为作用域的不同，不同的bean初始化和创建的时间也不相同。在作用域为singleton的时候，bean是随着容器一起被创建好并且实例化的，在作用域为pritotype的时候，bean是随着它被调用的时候才创建和实例化完成。然后程序就可以使用bean了，当程序完成销毁的时候，bean也被销毁

91.说说@Autowired和@Resource注解的区别

@Autowied是Spring提供的注解，@Resource是JDK提供的注解。@Autowied是只能按类型注入，@Resource默认按名称注入，也支持按类型注入。@Autowired按类型装配依赖对象,默认情况下它要求依赖对象必须存在,如果允许null值,可以设置它required属性为false,如果我们想使用按名称装配,可以结合@Qualifier注解一起使用

92.说说Spring事务管理

spring支持编程式事务管理和声明式事务管理两种方式： ①编程式事务管理使用TransactionTemplate。 ②声明式事务管理建立在AOP之上的。其本质是通过AOP功能，对方法前后进行拦截，将事务处理的功能编织到拦截的方法中，也就是在目标方法开始之前启动一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明或通过@Transactional注解的方式，便可以将事务规则应用到业务逻辑中，减少业务代码的污染。唯一不足地方是，最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。

93.说说Bean的作用域,以及默认的作用域

作用域分为singleton、prototype、request、session、globalsession。singleton表示在spring容器中仅存在一个实例，以单例的方式存在，prototype：每次调用都会返回一个新的实例，request：每次HTTP请求都会创建一个新的bean，session：同一个HTTP session共享一个bean，不同的HTTP请求使用不同的session，global session：同一个全局session共享一个bean。

94.说说BeanFactory和FactoryBean的区别

BeanFactory是最基础的IOC容器，给Spring 的容器定义一套规范，给IOC容器提供了一套完整的规范； FactoryBean只是SpringIOC容器创建Bean的一种形式；

95.说说你对MVC的理解

Spring mvc 是一个基于java的实现了mvc设计模式的轻量级web框架，在这种模式下软件被分为三层，即model、view、Controller。将软件分层的好处是可以将对象之间的耦合度降低，便于代码的维护。model封装了数据和对数据的操作，是实际进行数据处理的地方，view负责进行模型的展示，一般就是我们见到的用户界面 Controller控制器负责视图和模型之间的交互主要负责两方面的动作，一是把用户的请求分发到相应的模型，二是把模型的改变及时地响应到视图上。Spring mvc框架已经成为了mvc模式地最主流实现，前端控制器是DispatcherServlet接口实现类，映射处理器是HandlerMapping接口实现类，视图解析器是ViewResolver接口实现类，页面控制器是Controller接口实现类

MVC是一种设计模式，将软件分为三层，分别是模型层，视图层，控制器层。其中模型层代表的是数据，视图层代表的是界面，控制器层代表的是逻辑处理，是连接视图与模型之前的桥梁。降低耦合，便于代码的维护

96.介绍一下Spring MVC的执行流程

SpringMVC 的执行流程如下。

用户点击某个请求路径，发起一个 HTTP request 请求，该请求会被提交到 DispatcherServlet（前端控制器）；

由 DispatcherServlet 请求一个或多个 HandlerMapping（处理器映射器），并返回一个执行链（HandlerExecutionChain）。

DispatcherServlet 将执行链返回的 Handler 信息发送给 HandlerAdapter（处理器适配器）；

HandlerAdapter 根据 Handler 信息找到并执行相应的 Handler（常称为 Controller）；

Handler 执行完毕后会返回给 HandlerAdapter 一个 ModelAndView 对象（Spring MVC的底层对象，包括 Model 数据模型和 View 视图信息）；

HandlerAdapter 接收到 ModelAndView 对象后，将其返回给 DispatcherServlet ；

DispatcherServlet 接收到 ModelAndView 对象后，会请求 ViewResolver（视图解析器）对视图进行解析；

ViewResolver 根据 View 信息匹配到相应的视图结果，并返回给 DispatcherServlet；

DispatcherServlet 接收到具体的 View 视图后，进行视图渲染，将 Model 中的模型数据填充到 View 视图中的 request 域，生成最终的 View（视图）；

视图负责将结果显示到浏览器（客户端）。

97.在MyBatis中$和#有什么区别

$设置参数时,MyBatis会创建普通的SQL语句,然后在执行SQL 语句时将参数拼入SQL #设置参数时,MyBatis会创建预编译的SQL语句,然后在执行SQL时MyBatis会为预编译SQL中的占位符赋值,预编译的SQL语句执行效率高,并且可以防止注入攻击,效率和安全性都大大优于前者

98.介绍一下MyBatis的缓存机制

MyBatis的缓存机制，一级缓存也称为本地缓存，它默认启用且不能关闭。一级缓存存在于SqlSession的生命周期中，即它是SqlSession级别的缓存，在同一个SqlSession中查询时，MyBatis会把执行的方法和参数通过算法生成缓存的键值，将键值和查询结果存入一个Map对象中，如果同一个SqlSession中执行的方法和参数完全一致，则会将缓存的对象返回；二级缓存则为SqlSessionFactory,mybaits的全局配置setting有一个参数cacheEnabled,这个参数是二级缓存的全局开关，默认值是true,初始状态为启用状态，映射语句文件中的所有SELECT 语句将会被缓存。 - 映射语句文件中的所有时INSERT 、UPDATE 、DELETE 语句会刷新缓存。 - 缓存会使用Least Recently Used ( LRU ,最近最少使用的）算法来收回

99.说说你对Redis的了解

Redis是一款基于键值对的NoSQL数据库，Redis中拥有string(字符串)，hash(哈希)、list(列表)、set（集合）等多种数据结构，redis将数据写进内存的性能很快，不仅如此，如遇到系统崩溃，内存中的数据不会丢失；redis访问速度快、支持的数据类型丰富，很适合用来储存热点数据、而且适用业务广，如可以运用expire命令来做限时业务，设置一个键的生存时间，到时间后redis会自动删除它，，如排行榜可以借住redis的SortedSet进行热点数据的排序，还有分页查询，模糊查询，点赞好友等

100.请你说说Redis的数据类型

Redis拥有五种基本数据类型和四种特殊的数据类型。五种基本数据类型： 1）String：String是Redis中最基本的数据类型，可以存储任何数据，包括二进制数据、序列化的数据、JSON化的对象甚至是图片。 2）List：List是字符串列表，按照插入的顺序排序，元素可以重复，你可以添加一个元素到哦列表的头部或者尾部，底层是一个链表结构。 3）Set：Set是一个无序不重复的集合。 4）Hash：Hash是String类型的filed和value的集合，适合用于存储对象。 5）Zset：Zset和set一样也是String类型元素的集合，且不允许有重复的元素，但不同的是Zset的每个元素都会关联一个分数，分数可以重复，Redis通过分数来为集合汇总的成员进行从小到大的排序。四种特殊数据类型 1）bitmap 2）hyperloglog 3）geo 4）stream

101.请你说说Redis数据类型中的zset,它和set有什么区别？底层是怎么实现的？

zset是有序的，而set是无序的。 zset底层使用的是压缩列表以及跳跃表，当元素数量小于128个，所有member的长度都小于64字节，是使用压缩列表。不满足这两个条件时使用跳跃表。 set底层是hashtable和inset.

102.详细的说说Redis的数据类型

redis中常用的五种数据结构：string、list、set、zset、hash。String结构底层是一个简单动态字符串，支持扩容，存储字符串。list存储线性有序且可重复的元素，底层数据结构可以是双向链表/压缩列表。set存储不可重复的元素，一般用于求交集、差集等，底层数据结构可以是hash和整数数组，zset存储的是有序不可重复的元素，zset为每个元素添加了一个score属性作为排序依据，底层数据结构可以是ziplist和跳表，hash类型存储的是键值对，底层数据结构是ziplist和hash。redis会在性能以及节省内存间考虑，选择最适合当前状态的底层数据结构实现

list（有序可重）的底层数据结构是双向链表/压缩列表

set（不可重）=hash+整数数组，

zset（有序不重）=ziplist+跳表

hash（存键值对）=ziplist+hash

103.说说Redis的单线程架构

redis采用的是单线程+IO多路复用技术。这里单线程指的是redis中读写操作和网络IO使用的是是有一个线程来完成，但是其他操作是有其他线程完成，例如持久化操作。单线程既可以简化数据结构和算法的实现，同时也消除了线程切换和锁竞争所带来的消耗。redis中采用的IO多路复用技术实现了单线程下同时处理多个IO请求。redis为什么这么快：1.单线程进行读写操作，避免线程切换和锁竞争带来的消耗。2：redis操作是在内存中进行的。3.最重要的就是：采用了IO多路复用技术，实现了在网络IO中能够处理大量并发请求，实现高吞吐率。

104.说说Redis的持久化策略

1.RDB: redis database 在指定的时间间隔内，将内存中的数据集的快照写入磁盘，文件名dump.rdb 适合大规模的数据恢复，对数据库的完整性和一致性要求不是很高一定时间间隔备份一次，如果数据库意外down掉，就会失去最后一次快照的所有修改 2.AOF: append only file 以日志的形式记录每个写操作，只允许追加文件，不允许改写文件，redis启动时会读取这个文件，并从头到尾执行一遍，以此来恢复数据，文件名appendonly.aof 在最恶劣的环境下，也丢失不会超过2秒的数据，完整性较高，但是会对磁盘持续的进行IO，代价太大。企业级最少需要5G才能支持如果.aof文件大小超过原来的一倍，会进行重写压缩，保留最小的指令集合 3.优先级 aof>rdb

105.说说Redis的主从同步机制

主从同步分为全量同步和增量同步，从机第一次连接主机时不会携带主机id和数据偏移量，主机会对从机的主机id进行校验，如果不是则说明是第一次连接需要进行全量同步，原理就是将当前数据写到RDB文件发送给从机，从机接收到文件之后将数据读取到从机的内存中，增量同步是第二次和之后连接才会发生，当从机第一次同步完成之后，主机在这期间数据发生变化，会将命令存储在缓冲区，当校验到从机的id正确时会获取从机的偏移量，主机从偏移量记录的命令开始将从机没同步的数据的操作命令发送给从机执行，执行完成后即完成了数据同步

106.说说Redis的缓存淘汰策略

惰性删除：当你访问一个key的时候，redis检查它的过期时间，如果过期就会删除。定期删除：redis会将设置了过期事件的key全都放入一个字典中，然后进行扫描，过期了的key就会被删除。但是扫描不是全局扫描，而是一种简单的贪心算法，从字典中随机选择20个key，将过期的key删除，当过期的key超过一定的比例时，将会再次随机选择，知道随机选择的key小于一定比例。当写入数据超过最大内存限制时，redis也有8种淘汰方案： 1. 直接报错 2. 删除拥有过期时间的key中快要过期的 3. 在所有key中随机删除 4. 在具有过期时间的key中随机删除 5. lru 从所有key中删除使用时间离现在最久的 6. lru 从拥有过期时间的key中删除使用时间离现在最久的 7. lfu 从所有key中删除使用次数最少的 8. lfu 从拥有过期时间的key中删除使用次数最少的

107.说说缓存穿透、击穿、雪崩的区别

缓存穿透：客户端访问不存在的数据，使得请求直达存储层，导致负载过大，直至宕机。原因可能是业务层误删了缓存和库中的数据，或是有人恶意访问不存在的数据。解决方式：1.存储层未命中后，返回空值存入缓存层，客户端再次访问时，缓存层直接返回空值。2.将数据存入布隆过滤器，访问缓存之前经过滤器拦截，若请求的数据不存在则直接返回空值。缓存击穿：一份热点数据，它的访问量非常大，在它缓存失效的瞬间，大量请求直达存储层，导致服务崩溃。解决方案：1.永不过期：对热点数据不设置过期时间。2.加互斥锁，当一个线程访问该数据时，另一个线程只能等待，这个线程访问之后，缓存中的数据将被重建，届时其他线程就可以从缓存中取值。缓存雪崩：大量数据同时过期、或是redis节点故障导致服务不可用，缓存层无法提供服务，所有的请求直达存储层，造成数据库宕机。解决方案：1.避免数据同时过期，设置随机过期时间。2.启用降级和熔断措施。3.设置热点数据永不过期。4.采用redis集群，一个宕机，另外的还能用

108.Redis如何与数据库保持双写一致性

共有四种同步策略：1.先更新数据库再更新缓存。缺点：多线程并发下会存在数据库中数据和缓存不一致的的现象。可能出现2.先更新缓存在更新数据库，优点就是每次数据变化都可以及时的更新缓存，但是消耗很大，影响服务器性能。3.先删除缓存在更新数据库。缺点：也会导致缓存和数据库数据不一致。4.先更新数据库再删除缓存。缺点仍然可能存在缓存和数据库中数据不一致的情况，但是，我们可以使用重试机制进行操作。，所以说这是效果最好的解决方案。

109.如何实现Redis高可用

主从复制：写一定是在主服务器上，然后主服务器同步给从服务器。缺点：当主服务器挂掉的时候，不能自动切换到从服务器上。主从服务器存储数据一样，内存可用性差。优点：在一定程度上分担主服务器读的压力。哨兵模式：构建多个哨兵节点监视主从服务器，当主服务器挂掉的时候，自动将对应的从服务器切换成主服务器。优点：实现自动切换，可用性高。缺点：主从服务器存储数据一致，内存可用性差。还要额外维护一套哨兵系统，较为麻烦。集群模式：采用无中心节点的方式实现。多个主服务器相连，一个主服务器可以有多个从服务器，不同的主服务器存储不同的数据。优点：可用性更高，内存可用性高。

？110.如何利用Redis实现一个分布式锁

最简单redis分布式锁的实现方式：加锁：setnx（key,1），解锁：del(key),问题：如果客户忘记解锁，将会出现死锁。第二种分布式锁的实现方式：setnx(key,1)+expire(key,30),解锁：del(key).问题：，由于setnx和expire的非原子性，当第二步挂掉，仍然会出现死锁。第三种方式：加锁：将setnx和expire变成原子性操作，set(key,1,30,NX),解锁：del（key）。同时考虑到线程A还在执行，但是锁已经到期，当线程A执行结束时去释放锁时，可能就会释放别的线程锁，所以在解锁时要先判断一下value值，看是不是该锁，如果是，再进行删除

111.设计模式了解么

常用的设计模式有单例模式、工厂模式、代理模式、适配器模式、装饰器模式、模板方法模式等等。像sping中的定义的bean默认为单例模式，spring中的BeanFactory用来创建对象的实例，他是工厂模式的体现。AOP面向切面编程时代理模式的体现，它的底层就是基于动态代理实现的。适配器模式在springMVC中有体现，它的处理器适配器会根据处理器规则适配相应的处理器执行，模板方法模式用来解决代码重复的问题等

112.请你讲讲单例模式、请你手写一下单例模式

单例模式是一个类只能创建一个对象，单例模式又分为饿汉式和懒汉式，饿汉式就是在类加载的的时候不管后边会不会用到都创建一个对象并且做初始化，浪费资源。懒汉式是在类加载的的时候创建对象，但不进行初始化，只有在用的时候，先判断对象是否为空，如果为空，对对象进行初始化，然后返回初始化后的值。为了解决线程安全问题，又分为懒汉式线程安全、懒汉式双重检验锁、静态内部类等

public class Singleton{

private static Singleton instance;

private Singleton(){}

private static synchronized Singleton getInstance(){

if(instance == null){

instance = new Singleton();

}

return instance;

}

}

113.请你讲讲工厂模式,手写实现工厂模式

工厂模式其用意是定义一个创建产品的接口将具体创建推迟到子类中去。工厂模式可以分为简单工厂、工厂方法、抽象工厂。简单工厂就是定义一个工厂类根据传入的参数返回不同的实例，被创建的实例具有共同的父类或接口。工厂方法工厂方法是定义一个工厂接口，但创建过程让子类去实现，去决定哪一个产品被实例化。抽象工厂模式是对工厂方法的进一步深化，在工厂类中可以创建一组对象。实现方式是提供一个创建一系列相关或相互依赖对象的接口而无需指定具体的类

114.说说垃圾收集器

Serial（新生代）、Serial Old（老年代）：适用于单核小CPU，单核工作，回收时会暂停其他工作stop the word。

PawNew（新生代）、CMS（老年代）：适用于多核CPU，最求短暂停时间，多核工作，使用标记清除算法，最短的暂停时间。

Parallel Scavenge（新生代-标记复制算法）、Parallel Old（老年代-标记整理算法）：1.7,1.8默认的组合，适用于多核CPU，追求最大吞吐量

G1 jdk1.9默认，适用于大内存多核CPU服务器，它不按整个新生代或老年代去回收，而是开辟了面向局部收集，实现了较小的收集暂停时间和高吞吐量。

Java中的error和exception有什么区别

Error（错误）:程序无法处理，通常指程序中出现的严重问题。

例如java.lang.VirtualMachineError（Java虚拟机运行错误）：当 Java虚拟机崩溃或用尽了它继续操作所需的资源时，抛出该错误
例如java.lang.StackOverflowError（栈溢出错误）：当应用程序递归太深而发生堆栈溢出时，抛出该错误。
例如java.lang.OutOfMemoryError（内存溢出）：内存溢出或没有可用的内存提供给垃圾回收器时，产生这个错误。
Error（错误）是不可查的，而且也常常在应用程序的控制和处理能力之外，因此当Error（错误）出现时，程序会立即奔溃，Java虚拟机立即停止运行，
Exception（异常）:是指程序本身可以处理的异常（可以向上抛出或者捕获处理）。

Java处理异常的默认方式是中断处理。

以java.lang.NullPointerException为例，当程序出现空指针异常时，会创建一个空指针异常对象，并向外抛出，并被虚拟机捕获，从而导致程序中断执行。

进程间通信的方式有几种

一、进程间的通信方式

管道( pipe )：

管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。

有名管道 (namedpipe) ：

有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。

信号量(semophore ) ：

信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。

消息队列( messagequeue ) ：

消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。

信号 (sinal ) ：

信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。

共享内存(shared memory ) ：

共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。

套接字(socket ) ：

套接口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同设备及其间的进程通信。

DNS域名解析过程

浏览器先检查自身缓存中有没有被解析过的这个域名对应的ip地址，如果有，解析结束。同时域名被缓存的时间也可通过TTL属性来设置。

如果浏览器缓存中没有（专业点叫还没命中），浏览器会检查操作系统缓存中有没有对应的已解析过的结果。而操作系统也有一个域名解析的过程。在windows中可通过c盘里一个叫hosts的文件来设置，如果你在这里指定了一个域名对应的ip地址，那浏览器会首先使用这个ip地址。

如果至此还没有命中域名，才会真正的请求本地域名服务器（LDNS）来解析这个域名，这台服务器一般在你的城市的某个角落，距离你不会很远，并且这台服务器的性能都很好，一般都会缓存域名解析结果，大约80%的域名解析到这里就完成了。

如果LDNS仍然没有命中，就直接跳到Root Server 域名服务器请求解析

根域名服务器返回给LDNS一个所查询域的主域名服务器（gTLD Server，国际顶尖域名服务器，如.com .cn .org等）地址

此时LDNS再发送请求给上一步返回的gTLD

接受请求的gTLD查找并返回这个域名对应的Name Server的地址，这个Name Server就是网站注册的域名服务器

Name Server根据映射关系表找到目标ip，返回给LDNS

LDNS缓存这个域名和对应的ip

LDNS把解析的结果返回给用户，用户根据TTL值缓存到本地系统缓存中，域名解析过程至此结束

浏览器输入一个网址后发生了什么

1.在客户端浏览器中输入URL.
2.发送到DNS(域名服务器)获得域名对应的web服务器的lP地址。
3.客户端浏览器与web服务器建立tcp连接.
4.客户端浏览器向对应IP地址的WEB服务器发送相应的http或https请求。
5.WEB服务器响应请求，返回指定的URL数据或错误信息。如果设定重定向，则重定向到新的URL地址。
6.客户端浏览器下载数据，解析HTML源文件，解析的过程中实现对页面的排版，解析完成后，在浏览器中显示基础界面。
7.分析页面中的超链接，显示在当前页面，重复以上过程直至没有超链接需要发送，完成页面的全部显示。

Jvm内存划分

原理示意：每个线程独有程序计数器、虚拟机栈与本地方法栈，堆和方法区则由线程共享。栈帧中的引用可以指向堆对象；运行时常量池属于方法区。直接内存位于规范定义的运行时数据区之外，可由堆中的 DirectByteBuffer 对象关联。这里区分逻辑职责，不表示实际物理地址或内存大小比例。

第一，是程序计数器（Program Counter Register)，在JVM规范中，每个线程都有自己的程序计数器。这是一块比较小的内存空间，存储当前线程正在执行的Java方法的JVM指令地址，即字节码的行号。如果正在执行Native方法，则这个计数器为空。该内存区域是唯一一个在Java虚拟机规范中没有规定任何OOM情况的内存区域。

第二，Java虚拟机栈(Java Virtal Machine Stack)，同样也是属于线程私有区域，每个线程在创建的时候都会创建一个虚拟机栈，生命周期与线程一致，线程退出时，线程的虚拟机栈也回收。虚拟机栈内部保持一个个的栈帧，每次方法调用都会进行压栈，JVM对栈帧的操作只有出栈和压栈两种，方法调用结束时会进行出栈操作。

该区域存储着局部变量表，编译时期可知的各种基本类型数据、对象引用、方法出口等信息。

第三，本地方法栈（Native Method Stack）与虚拟机栈类似，本地方法栈是在调用本地方法时使用的栈，每个线程都有一个本地方法栈。

第四，堆（Heap）,几乎所有创建的Java对象实例，都是被直接分配到堆上的。堆被所有的线程所共享，在堆上的区域，会被垃圾回收器做进一步划分，例如新生代、老年代的划分。Java虚拟机在启动的时候，可以使用“Xmx”之类的参数指定堆区域的大小。

第五，方法区（Method Area)。方法区与堆一样，也是所有的线程所共享，存储被虚拟机加载的元（Meta）数据，包括类信息、常量、静态变量、即时编译器编译后的代码等数据。这里需要注意的是运行时常量池也在方法区中。

根据Java虚拟机规范的规定，当方法区无法满足内存分配需求时，将抛出OutOfMemoryError异常。由于早期HotSpot JVM的实现，将CG分代收集拓展到了方法区，因此很多人会将方法区称为永久代。Oracle JDK8中已永久代移除永久代，同时增加了元数据区（Metaspace）。

第六，运行时常量池（Run-Time Constant Pool)，这是方法区的一部分，受到方法区内存的限制，当常量池无法再申请到内存时，会抛出OutOfMemoryError异常。

第七，直接内存（Direct Memory），直接内存并不属于Java规范规定的属于Java虚拟机运行时数据区的一部分。Java的NIO可以使用Native方法直接在java堆外分配内存，使用DirectByteBuffer对象作为这个堆外内存的引用。

可重入锁

什么是“可重入”，可重入就是说某个线程已经获得某个锁，可以再次获取锁而不会出现死锁。例如

使用ReentrantLock的注意点
ReentrantLock和synchronized不一样，需要手动释放锁，所以使用ReentrantLock的时候一定要手动释放锁，并且加锁次数和释放次数要—样

Java锁升级

Java中的锁有几种状态：无锁 → 偏向锁 → 轻量级锁 → 重量级锁

无锁状态

程序不会有锁的竞争。那么这种情况我们不需要加锁，所以这种情况下对象锁状态为无锁。

偏向锁

偏向锁，顾名思义，它会偏向于第一个访问锁的线程

如果在运行过程中，同步锁只有一个线程访问，不存在多线程争用的情况，则线程是不需要触发同步的，这种情况下，就会给线程加一个偏向锁。线程第二次到达同步代码块时，会判断此时持有锁的线程是否就是自己，如果是则正常往下执行。由于之前没有释放锁，这里也就不需要重新加锁。如果自始至终使用锁的线程只有一个，很明显偏向锁几乎没有额外开销，性能极高。
如果在运行过程中，遇到了其他线程抢占锁，则持有偏向锁的线程会被挂起，JVM会消除它身上的偏向锁，将锁恢复到标准的轻量级锁。偏向锁通过消除资源无竞争情况下的同步原语，进一步提高了程序的运行性能。一旦有第二个线程加入锁竞争，偏向锁就升级为轻量级锁（自旋锁）。升级为轻量级锁的时候需要撤销偏向锁，撤销偏向锁的时候会导致STW(stop the word)操作；

轻量级锁（自旋锁）

自旋锁：自旋锁原理非常简单，如果持有锁的线程能在很短时间内释放锁资源，那么那些等待竞争锁的线程就不需要做内核态和用户态之间的切换进入阻塞挂起状态，它们只需要等一等（自旋），等持有锁的线程释放锁后即可立即获取锁，这样就避免用户线程和内核的切换的消耗。

在轻量级锁状态下继续锁竞争，如果成功就成功获取轻量级锁。否则进入锁膨胀阶段，没有抢到锁的线程将自旋，即不停地循环判断锁是否能够被成功获取。长时间的自旋操作是非常消耗资源的，一个线程持有锁，其他线程就只能在原地空耗CPU，执行不了任何有效的任务，这种现象叫做忙等（busy-waiting）。如果锁竞争情况严重，某个达到最大自旋次数的线程，会将轻量级锁升级为重量级锁。
自旋锁:竞争锁失败的线程，并不会真实的在操作系统层面挂起等待，而是JVM会让线程做几个空循环(基于预测在不久的将来就能获得)，在经过若干次循环后，如果可以获得锁，那么进入临界区，如果还不能获得锁，才会真实的将线程在操作系统层面进行挂起。这样的好处就是快，坏处就是消耗cpu资源。

重量级锁

当后续线程尝试获取锁时，发现被占用的锁是重量级锁，则直接将自己挂起，等待将来被唤醒。在JDK1.6之前，synchronized直接加重量级锁，很明显现在得到了很好的优化。

重量级锁的特点：其他线程试图获取锁时，都会被阻塞，只有持有锁的线程释放锁之后才会唤醒这些线程。

锁优点缺点适用场景

偏向锁加锁和解锁不需要额外的消耗，和执行非同步方法比仅存在纳秒级的差距。如果线程间存在锁竞争，会带来额外的锁撤销的消耗。适用于只有一个线程访问同步块场景。

轻量级锁竞争的线程不会阻塞，提高了程序的响应速度。如果始终得不到锁竞争的线程使用自旋会消耗CPU。追求响应时间。同步块执行速度非常快。

重量级锁线程竞争不使用自旋，不会消耗CPU。线程阻塞，响应时间缓慢。追求吞吐量。同步块执行速度较长。

锁升级场景

场景1：经常只有某一个线程来加锁。

加锁过程：也许获取锁的经常为同一个线程，这种情况下为了避免加锁造成的性能开销，加偏向锁。
偏向锁的执行流程如下：
1、线程首先检查该对象头的线程ID是否为当前线程；
2、A：如果对象头的线程ID和当前线程ID一致，则直接执行代码；B：如果不是当前线程ID则使用CAS方式替换对象头中的线程ID，如果使用CAS替换不成功则说明有线程正在执行，存在锁的竞争，这时需要撤销偏向锁，升级为轻量级锁。
3、如果CAS替换成功，则把对象头的线程ID改为自己的线程ID，然后执行代码。
4、执行代码完成之后释放锁，把对象头的线程ID修改为空。

场景2：有线程来参与锁的竞争，但是获取锁的冲突时间很短。

当开始有锁的竞争了，那么偏向锁就会升级到轻量级锁；
线程获取锁出现冲突时，线程必须做出决定是继续在这里等，还是先去做其他事情，等会再来看看，而轻量级锁的采用了继续在这里等的方式。当发现有锁竞争，线程首先会使用自旋的方式循环在这里获取锁，因为使用自旋的方式非常消耗CPU。当一定时间内通过自旋的方式无法获取到锁的话，那么锁就开始升级为重量级锁了。

场景3：有大量的线程参与锁的竞争，冲突性很高。

当获取锁冲突多，时间越长的时候，线程肯定无法继续在这里死等了，所以只好先挂起，然后等前面获取锁的线程释放了锁之后，再开启下一轮的锁竞争，而这种形式就是我们的重量级锁。

锁	优点	缺点	适用场景
偏向锁	加锁和解锁不需要额外的消耗，和执行非同步方法比仅存在纳秒级的差距。	如果线程间存在锁竞争，会带来额外的锁撤销的消耗。	适用于只有一个线程访问同步块场景。
轻量级锁	竞争的线程不会阻塞，提高了程序的响应速度。	如果始终得不到锁竞争的线程使用自旋会消耗CPU。	追求响应时间。同步块执行速度非常快。
重量级锁	线程竞争不使用自旋，不会消耗CPU。	线程阻塞，响应时间缓慢。	追求吞吐量。同步块执行速度较长。

为什么jdk9要将String的底层由char[]改为byte[]

JDK 9并没有将String的底层实现由char[]改成byte[]，而是在JDK 9中，引入了一个CompactStrings的优化,优化的目的是减少String对象的内存消耗，在大多数Java程序的堆里，String占用的空间最大，并且绝大多数String只有Latin-1字符，这些Latin-1字符只需要1个字节就够了。JDK9之前，JVM因为String使用char数组存储，每个char占2个字节，所以即使字符串只需要1字节/字符，它也要按照2字节/字符进行分配，浪费了一半的内存空间。

JDK9是怎么解决这个问题的呢？一个字符串出来的时候判断，它是不是只有Latin-1字符，如果是，就按照1字节/字符的规格进行分配内存，如果不是，就按照2字节/字符的规格进行分配，提高了内存使用率。

单点登录

手写单例模式、工厂模式

一、单例模式的定义

定义： 确保一个类只有一个实例，并提供该实例的全局访问点。

这样做的好处是：有些实例，全局只需要一个就够了，使用单例模式就可以避免一个全局使用的类，频繁的创建与销毁，耗费系统资源。

二、单例模式的设计要素

一个私有构造函数（确保只能单例类自己创建实例）
一个私有静态变量（确保只有一个实例）
一个公有静态函数（给使用者提供调用方法）

简单来说就是，单例类的构造方法不让其他人修改和使用；并且单例类自己只创建一个实例，这个实例，其他人也无法修改和直接使用；然后单例类提供一个调用方法，想用这个实例，只能调用。这样就确保了全局只创建了一次实例。

三、单例模式的6种实现及各实现的优缺点

（一）懒汉式（线程不安全）

实现：

public class Singleton {
     private static Singleton uniqueInstance;
   
     private Singleton() {
        
    }
    
    public static Singleton getUniqueInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}

说明： 先不创建实例，当第一次被调用时，再创建实例，所以被称为懒汉式。

优点： 延迟了实例化，如果不需要使用该类，就不会被实例化，节约了系统资源。

缺点： 线程不安全，多线程环境下，如果多个线程同时进入了 if (uniqueInstance == null) ，若此时还未实例化，也就是uniqueInstance == null，那么就会有多个线程执行 uniqueInstance = new Singleton(); ，就会实例化多个实例；

（二）饿汉式（线程安全）

实现：

public class Singleton {
    
    private static Singleton uniqueInstance = new Singleton();
    
    private Singleton() {
    }
    
    public static Singleton getUniqueInstance() {
        return uniqueInstance;
    }
    
}

说明： 先不管需不需要使用这个实例，直接先实例化好实例 (饿死鬼一样，所以称为饿汉式)，然后当需要使用的时候，直接调方法就可以使用了。

优点： 提前实例化好了一个实例，避免了线程不安全问题的出现。

缺点： 直接实例化好了实例，不再延迟实例化；若系统没有使用这个实例，或者系统运行很久之后才需要使用这个实例，都会操作系统的资源浪费。

（三）懒汉式（线程安全）

实现：

public class Singleton {
    private static Singleton uniqueInstance;
    
    private static singleton() {
    }
   
    private static synchronized Singleton getUinqueInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
    
}

说明： 实现和线程不安全的懒汉式几乎一样，唯一不同的点是，在get方法上加了一把锁。如此一来，多个线程访问，每次只有拿到锁的的线程能够进入该方法，避免了多线程不安全问题的出现。

优点： 延迟实例化，节约了资源，并且是线程安全的。

缺点： 虽然解决了线程安全问题，但是性能降低了。因为，即使实例已经实例化了，既后续不会再出现线程安全问题了，但是锁还在，每次还是只能拿到锁的线程进入该方法，会使线程阻塞，等待时间过长。

（四）双重检查锁实现（线程安全）

实现：

public class Singleton {
    
    private volatile static Singleton uniqueInstance;
    
    private Singleton() {
    }
    
    public static Singleton getUniqueInstance() {
        if (uniqueInstance == null) {
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }  
}

说明: 双重检查数相当于是改进了线程安全的懒汉式。线程安全的懒汉式的缺点是性能降低了，造成的原因是因为即使实例已经实例化，依然每次都会有锁。而现在，我们将锁的位置变了，并且多加了一个检查。也就是，先判断实例是否已经存在，若已经存在了，则不会执行判断方法内的有锁方法了。而如果，还没有实例化的时候，多个线程进去了，也没有事，因为里面的方法有锁，只会让一个线程进入最内层方法并实例化实例。如此一来，最多最多，也就是第一次实例化的时候，会有线程阻塞的情况，后续便不会再有线程阻塞的问题。

为什么使用 volatile 关键字修饰了 uniqueInstance 实例变量？

uniqueInstance = new Singleton(); 这段代码执行时分为三步：

为 uniqueInstance 分配内存空间
初始化 uniqueInstance
将 uniqueInstance 指向分配的内存地址

正常的执行顺序当然是 1>2>3 ，但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1>3>2。单线程环境时，指令重排并没有什么问题；多线程环境时，会导致有些线程可能会获取到还没初始化的实例。例如：线程A 只执行了 1 和 3 ，此时线程B来调用 getUniqueInstance()，发现 uniqueInstance 不为空，便获取 uniqueInstance 实例，但是其实此时的 uniqueInstance 还没有初始化。

解决办法就是加一个 volatile 关键字修饰 uniqueInstance ，volatile 会禁止 JVM 的指令重排，就可以保证多线程环境下的安全运行。

优点： 延迟实例化，节约了资源；线程安全；并且相对于线程安全的懒汉式，性能提高了。

缺点： volatile 关键字，对性能也有一些影响。

（五）静态内部类实现（线程安全）

实现：

public class Singleton {
    
    private Singleton() {
    }
    
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getUniqueInstance() {
        return SingletonHolder.INSTANCE;
    }
     
}

说明： 首先，当外部类 Singleton 被加载时，静态内部类 SingletonHolder 并没有被加载进内存。当调用 getUniqueInstance() 方法时，会运行 return SingletonHolder.INSTANCE; ，触发了 SingletonHolder.INSTANCE ，此时静态内部类 SingletonHolder 才会被加载进内存，并且初始化 INSTANCE 实例，而且 JVM 会确保 INSTANCE 只被实例化一次。

优点： 延迟实例化，节约了资源；且线程安全；性能也提高了。

（六）枚举类实现（线程安全）

实现：

public enum Singleton {
    
    INSTANCE;

    //添加自己需要的操作
    public void doSomeThing() {
    
    }
    
}

说明： 默认枚举实例的创建就是线程安全的，且在任何情况下都是单例。

优点： 写法简单，线程安全，天然防止反射和反序列化调用。

**防止反序列化****序列化：**把java对象转换为字节序列的过程；**反序列化：**通过这些字节序列在内存中新建java对象的过程；**说明：**反序列化将一个单例实例对象写到磁盘再读回来，从而获得了一个新的实例。我们要防止反序列化，避免得到多个实例。**枚举类天然防止反序列化。** 其他单例模式可以通过重写 readResolve() 方法，从而防止反序列化，使实例唯一重写 readResolve() :

private Object readResolve() throws ObjectStreamException{
        return singleton;
}

四、单例模式的应用场景

应用场景举例：

网站计数器。
应用程序的日志应用。
Web项目中的配置对象的读取。
数据库连接池。
多线程池。
……

使用场景总结：

频繁实例化然后又销毁的对象，使用单例模式可以提高性能。
经常使用的对象，但实例化时耗费时间或者资源多，如数据库连接池，使用单例模式，可以提高性能，降低资源损坏。
使用线程池之类的控制资源时，使用单例模式，可以方便资源之间的通信。

1. 简单工厂模式（静态工厂）

某种程度上不符合设计原则，但实际使用最多。

原始方法

public interface Car {   
    public void name();
}
public class Tesla implements Car{
    public void name(){   
        System.out.println("特斯拉！");    
    }}
public class WuLing implements Car{ 
    public void name(){  
        System.out.println("五菱宏光！");  
    }}
public class Consumer { 
    public static void main(String[] args) { 
        // 接口，所有实现类   
        Car car=new WuLing();
        Car car2=new Tesla(); 
        car.name();     
        car2.name();
        // Car car = CarFactory.getCar("五菱");  
        // car.name(); 
    }}

静态工厂方法

因为CarFactory类中的所有方法都是静态的，需要向其中添加参数来返回不同的对象实例。

增加一个新的产品，如果不修改CarFactory代码就做不到。

public class CarFactory {  
    // 方法一   
    public static Car getCar(String car){ 
        if(car.equals("五菱")){    
            return new WuLing();  
        }else if(car.equals("特斯拉")){  
            return new Tesla();     
        }else { 
            return null; 
        } 
    } 
    // 方法二 
    public static Car getWuLing(){
        return new WuLing(); 
    }
    public static Car getTesla(){ 
        return new Tesla();   
    }}
public class Consumer { 
    public static void main(String[] args) {     
        // 接口，所有实现类    
        // Car car=new WuLing();
        // Car car2=new Tesla();  
        // car.name();
        // car2.name();   
        Car car = CarFactory.getCar("五菱");    
        Car car2 = CarFactory.getCar("特斯拉");    
        car.name(); 
        car2.name();
    }}

静态工厂方法

因为CarFactory类中的所有方法都是静态的，需要向其中添加参数来返回不同的对象实例。

增加一个新的产品，如果不修改CarFactory代码就做不到。

public class CarFactory {  
    // 方法一   
    public static Car getCar(String car){ 
        if(car.equals("五菱")){    
            return new WuLing();  
        }else if(car.equals("特斯拉")){  
            return new Tesla();     
        }else { 
            return null; 
        } 
    } 
    // 方法二 
    public static Car getWuLing(){
        return new WuLing(); 
    }
    public static Car getTesla(){ 
        return new Tesla();   
    }}
public class Consumer { 
    public static void main(String[] args) {     
        // 接口，所有实现类    
        // Car car=new WuLing();
        // Car car2=new Tesla();  
        // car.name();
        // car2.name();   
        Car car = CarFactory.getCar("五菱");    
        Car car2 = CarFactory.getCar("特斯拉");    
        car.name(); 
        car2.name();
    }}

新增一个产品

public class DaZhong implements Car{ 
    @Override  
    public void name() {    
        System.out.println("大众！");   
    }}
public class  DaZhongFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new DaZhong();   
    }}
public class Consumer {
    public static void main(String[] args) {
        Car car = new WuLingFactory().getCar();  
        Car car1 = new TeslaFactory().getCar();
        car.name();
        car1.name();  
        Car car2 = new DaZhongFactory().getCar(); 
        car2.name(); 
    }}

对比

结构复杂度：simple更简单
代码复杂度：simple更简单
编程复杂度：simple更简单
管理上的复杂度：simple更简单

根据设计原则：工厂方法模式

根据实际业务：简单工厂模式

3、抽象工厂模式

定义:抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定它们具体的类
适用场景:
- 客户端(应用层)不依赖于产品类实例如何被创建、实现等细节
- 强调一系列相关的产品对象(属于同一产品族)一起使用创建对象需要大量的重复代码（一次一起全部创建，很少更改）
- 提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体的实现
优点:
- 具体产品在应用层的代码隔离，无需关心创建的细节
- 将一个系列的产品统一到一起创建
缺点:
- 规定了所有可能被创建的产品集合，产品簇中扩展新的产品困难;

IO多路复用

LRU手写

设计模式的原则

setnx底层实现

可见性问题？volatile，那么volatile底层如何实现的

迭代器失效

dns基于什么协议

osi和tcp/ip，有什么主要的协议

java跨平台如何实现

https加密通信的过程

流量控制和拥塞控制

topk

Redis04-SpringDataRedis

Sun, 02 Jul 2023 13:00:00 GMT

SpringDataRedis

SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis

提供了对不同Redis客户端的整合(Lettuce和Jedis)
提供了RedisTemplate统一API来操作Redis
支持Redis的发布订阅模型
支持Redis哨兵和Redis集群
支持基于Lettuce的响应式编程
支持基于JDK、JSON、字符串、Spring对象的数据序列化及反序列化
支持基于Redis的JDKCollection实现

SpringDataRedis快速入门

API	返回值类型	说明
redisTemplate.opsForValue()	ValueOperations	操作String数据类型
redisTemplate.opsForHash()	HashOperations	操作Hash类型数据
redisTemplate.opsForList()	ListOperations	操作List类型数据
redisTemplate.opsForSet()	SetOperations	操作Set类型数据
redisTemplate.opsForZSet()	ZSetOperations	操作SortedSet类型数据
redisTemplate		通用的命令

使用(基于SpringBoot)

1.引入依赖

<!-- Redis依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 连接池依赖 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

2.配置文件

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

3.注入RedisTemplate

@Autowired
private RedisTemplate redisTemplate;

4.编写测试

@SpringBootTest
public class RedisTest {
    @Autowired
    private RedisTemplate redisTemplate;
    
    @Test
    void testString() {
        //插入一条String类型数据
        redisTemplate.opsForValue().set("name", "李四");
        //读取一条String数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }
    
    @Test
    void testSaveUser() {
        //写入数据
        redisTemplate.opsForValue().set("user:100", new User("Wang", 21));
        //获取数据
        User o = (User) redisTemplate.opsForValue().get("user:100");
        System.out.println("o = " + o);
    }
}

插入数据出现了问题，序列化出现了问题，变成了字节

缺点：可读性差且占用内存大

改进(自己定义序列化和反序列化)

public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        //创建RedisTemplate对象
        RedisTemplate<String, Object> 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;
    }
}

为了在反序列化时知道对象的类型，JSON序列化器会将类的class类型写入json结果中，存入Redis，会带来额外的内存开销。

为了节省内存空间，我们并不会使用JSON序列化器来处理value，而是统一使用String序列化器，要求只能存储String类型的key和value。当需要存储Java对象时，手动完成对象的序列化和反序列化。

Spring默认提供了一个StringRedisTemplate类，它的key和value的序列化方式默认就是String方式。省去了我们自定义RedisTemplate的过程:

使用StringRedisTemplate和手动序列化和反序列化

@SpringBootTest
class RedisStringTests {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    void testString() {
        //插入一条String类型数据
        stringRedisTemplate.opsForValue().set("name", "string测试");
        //读取一条String数据
        Object name = stringRedisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);//插入一条String类型数据
    }

    private static final ObjectMapper mapper = new ObjectMapper();

    @Test
    void testSaveUser() throws JsonProcessingException {
        //创建对象
        User user = new User("Wang-nine", 9);
        //手动序列化
        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);
    }

}

==RedisTemplate的两种序列化实践方案:==

方案一: 1.自定义RedisTemplate 2.修改RedisTemplate的序列化器为GenericJackson2JsonRedisSerializer
方案二: 1.使用StringRedisTemplate 2.写入Redis时，手动把对象序列化为JSON 3.读取Redis时，手动把读取到的JSON反序列化为对象

注意：有关于Hash数据结构的存取

@Test
void TestHash() {
    stringRedisTemplate.opsForHash().put("user:400", "测试300", "300");
    stringRedisTemplate.opsForHash().put("user:400", "测试400", "400");

    Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("user:400");
    System.out.println(entries);
}

Redis03-Jedis

Sun, 02 Jul 2023 11:00:00 GMT

Jedis

样例程序

1.引入依赖

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

2.建立连接

private Jedis jedis;

@BeforeEach
void setUp() {
	//建立连接
	jedis = new Jedis("192.168.150.101"，6379);
    //设置密码
	jedis.auth("123456");
    //选择库
	jedis.select(0);
}

测试String

@Test
void testString() {
	//插入数据，方法名称就是redis命令名称，非常简单
    String result = jedis.set("name", "张三"); 
    System.out.println("result = " + result);
    //获取数据
	String name = jedis.get("name") ;
	System.out.println("name = " + name) ;
}

释放资源

@AfterEach
void tearDown() {
	//释放资源
	if (jedis != null) {
		jedis.close();
    }
}

Jedis连接池

Jedis本身是线程不安全的，并且频繁的创建和销毁连接会有性能损耗，因此我们推荐大家使用Jedis连接池代替Jedis的直连方式

public class JedisConnectionFactory {
    private static final JedisPool jedisPool;
    
    static {
        //配置连接池
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(8);  //最大连接数
        poolConfig.setMaxIdle(8);   //最大空闲连接
        poolConfig.setMinIdle(0);   //最小空闲连接
        poolConfig.setMaxWaitMillis(1000);  //没有连接可用的等待时长，默认-1，持续等待
        //创建连接池对象
        jedisPool = new JedisPool(poolConfig, "192.168.72.128", 6379, 1000, "123456");
    }
    
    public static Jedis getJedis() {
        return jedisPool.getResource();
    }
}

Redis02-命令

Sun, 02 Jul 2023 09:00:00 GMT

Redis数据结构介绍

Redis是一个key-value的数据库，key一般是String类型，不过value的类型多种多样:

数据类型	样例	类型
String	hello world	基本类型
Hash	{name: “Jack”,age:21}	基本类型
List	[A ->B ->C ->C]	基本类型
set	{A，B，C}	基本类型
SortedSet	{A: 1，B:2，C:3}	基本类型
GEO	{A:( 120.3, 30.5)}	特殊类型
BitMap	0110110101110101011	特殊类型
HyperLog	0110110101110101011	特殊类型

命令文档

Redis官网命令文档
help @xxxx

通用命令

help @generic

常用命令

命令	描述
KEYS pattern	查询符和模版的所有key（通常使用通配符模糊匹配） <br>不建议在生产环境上使用（redis单线程，执行此命令则会等待）
DEL key [key …]	删除一个/多个指定的key
EXISTS key [key …]	判断key是否存在
EXPIRE key seconds	设置一个key的存活时间
TTL key	查看key的剩余有效期（-1永久有效）

String

String类型，也就是字符串类型，是Redis中最简单的存储类型。

其value是字符串，不过根据字符串的格式不同，又可以分为3类:

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

不管是哪种格式，底层都是字节数组形式存储，只不过是编码方式不同。字符串类型的最大空间不能超过512m

常见命令

命令	描述
SET key value	添加或者修改已经存在的一个String类型的键值对
GET	根据key获取String类型的value
MSET	批量添加多个String类型的键值对
MGET	根据多个key获取多个String类型的value
INCR	让一个整型的key自增1（自减，DECR，一般不用，自增负数即可）
INCRBY	让一个整型的key自增并指定步长，例如: incrby num 2 让num值自增2
INCRBYFLOAT	让一个浮点类型的数字自增并指定步长
SETNX（set not exist）	添加一个String类型的键值对，前提是这个key不存在，否则不执行
SETEX（set expire）	添加一个String类型的键值对，并且指定有效期，例如 setex name 10 jack 或者 set name jack ex 10

Key的层级结构

Redis没有类似MySQL中的Table的概念，我们该如何区
分不同类型的key呢?
例如，需要存储用户、商品信息到redis，有一个用户id是1，有一个商品id恰好也是1

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

项目名:业务名:类型:id

例如如果Value是一个Java对象，例如一个User对象，则可以将对象序列化为JSON字符串后存储:

KEY	VALUE
wang:user:1	{“id”:1，”name”:”Jack” , “age”:21}
wang:product:1	{“id”:1，”name”:”小米11”，”price”: 4999}

Hash类型

Hash类型，也叫散列，其value是一个无序字典，类似于Java中的HashMap结构

String结构是将对象序列化为JSON字符串后存储，当需要修改对象某个字段时很不方便:

KEY	VALUE
wang:user:1	{name:”Jack”, age:21}
wang:user:2	{name:”Rose”, age:18}

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

KEY	VALUE	VALUE
	field	value
wang:user:1	name	Jack
	age	21
wang:user:2	name	Rose
	age	18

常见命令

命令	描述
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
HVALS	获取一个hash类型的key中的所有的value
HINCRBY	让一个hash类型key的字段值自增并指定步长
HSETNX	添加一个hash类型的key的field值，前提是这个field不存在，否则不执行

List类型

Redis中的List类型与Java中的LinkedList类似，可以看做是一个双向链表结构。既可以支持正向检索和也可以支持反向检索。

特征也与LinkedList类似:

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

常见命令

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

如何利用List结构模拟一个栈?

入口和出口在同一边

如何利用List结构模拟一个队列?

入口和出口在不同边

如何利用List结构模拟一个阻塞队列?

入口和出口在不同边
出队时采用BLPOP或BRPOP

Set类型

Redis的Set结构与Java中的HashSet类似，可以看做是一个value为null的HashMap。因为也是一个hash表，

因此具备与HashSet类似的特征:

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

常见命令

命令	描述
SADD key member …	向set中添加一个或多个元素
SREM key member …	移除set中的指定元素
SCARD key	返回set中元素的个数
SISMEMBER key member	判断一个元素是否存在于set中
SMEMBERS	获取set中的所有元素
SINTER key1 key2 …	求key1和key2的交集
SDIFF key1 key2 …	求key1和key2的差集
SUNION key1 key2 …	求key1和key2的并集

SortedSet类型

Redis的SortedSet是一个可排序的set集合，与Java中的TreeSet(红黑树)有些类似，但底层数据结构却差别很大。SortedSet中的每一个元素都带有一个score属性，可以基于score属性对元素排序，底层的实现是一个跳表(SkipList)加 hash表。

SortedSet具备下列特性:

可排序
元素不重复
查询速度快

因为SortedSet的可排序特性，经常被用来实现排行榜这样的功能。

常见命令

命令	描述
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	求差集、交集、并集

注意:所有的排名默认都是升序，如果要降序则在命令的Z后面添加REV即可

Redis00-基础

Sat, 01 Jul 2023 15:00:00 GMT

NoSQL

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

Redis

Redis诞生于2009年全称是Remote Dictionary Server，远程词典服务器，是一个基于内存的键值型NoSQL数据库。

特征:

键值（ key-value）型，value支持多种不同数据结构，功能丰富
单线程，每个命令具备原子性
低延迟，速度快（基于内存、IO多路复用、良好的编码）
支持数据持久化
支持主从集群、分片集群
支持多语言客户端

安装与启动

启动

redis-server redis.conf

查看

ps -ef | grep redis

开机自启

vi /etc/systemd/system/redis.service

内容如下：

[Unit]
Description=redis-server
After=network.target

[Service]
Type=forking
ExecStart=/usr/loca/bin/redis-server /usr/local/src/redis-6.2.6/redis.conf
PrivateTmp=true

[Install]
WantedBy=multi-user.target

重载服务器

systemctl daemon-reload

启动redis

systemctl start redis

查看redis状态

systemctl status redis

关闭redis

systemctl stop redis

设置开机自启

systemctl enable redis

Redis客户端

包括:

命令行客户端
图形化桌面客户端
编程客户端

命令行客户端

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

redis-cli [options] [commonds]

其中常见的options有:

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

其中的commonds就是Redis的操作命令，例如:
ping : 与redis服务端做心跳测试，服务端正常会返回 pong
不指定commond时，会进入 redis-cli 的交互控制台:

Redis00-基础

Fri, 30 Jun 2023 15:00:00 GMT

基于Redis以及SpringBoot，实现了较为完整的业务流程

使用Redis解决了集群模式下的Session共享问题。

使用拦截器实现了用户的登陆校验功能和登录时间刷新功能。

使用Redis进行缓存，降低了数据库查询压力，解决了缓存穿透，雪崩，击穿的问题。

使用Redis与简单的Lua脚本实现了Redis操作的原子化，实现高可用，解决了用户秒杀资格的检测，同时使用了乐观锁解决了超卖问题。

==使用Redis解决了集群模式下的Session共享问题。==

Redis 在本组业务中首先承担共享存储的角色：验证码和登录信息不再只保存在某个应用实例的内存里，各实例访问同一份 Redis 数据后，才能在请求切换实例时继续识别用户。验证码与登录态应分别设计键和有效期，不能混为一条永久记录。

登录校验和登录有效期刷新是两项不同职责。请求携带有效凭证时可以恢复用户身份并续期，而是否允许访问某个业务接口，还要根据该路径是否要求登录来判断；公开页面也可能需要刷新已经存在的有效登录态。

缓存把可复用的查询结果放在数据库之前，但未命中仍可能回到数据库。处理风险时应区分三种原因：请求的数据本来不存在、单个热点键失效，以及大量键同时失效或缓存服务不可用，它们分别对应穿透、击穿与雪崩，保护策略不能互相替代。

秒杀流程需要把资格判断与并发约束分别落实：Redis 内相互依赖的判断和修改可以放入同一段 Lua 脚本，数据库库存则应在更新时检查条件。脚本的原子执行范围限于 Redis，不会自动把数据库更新、订单写入和服务高可用一并变成原子保证。

SpringCloud05-Nacos

Fri, 30 Jun 2023 14:00:00 GMT

简单的介绍了SpringCloud中的Nacos。

Nacos注册中心

启动

startup.cmd -m standalone

注册与发现

由于SpringCloud Commons定义了统一的接口规范

所以只需要改变引入的依赖和地址即可

在cloud-demo父工程中添加spring-cloud-alilbaba的管理依赖:

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
    <version>2.2.5.RELEASE</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

注释掉order-service和user-service中原有的eureka依赖。
添加nacos的客户端依赖

<!-- nacos客户端依赖 -->
<dependency>
	<groupId>com.alibaba.cloud</groupId>
	<arifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

修改user-service&order-service中的application.yml文件，注释eureka地址，添加nacos地址

spring:
	cloud:
		discovery:
			nacos:
				server-addr: localhost:8848 # nacos服务端地址

启动并测试
总结
Nacos服务搭建 - 下载安装包 - 解压 - 在bin目录下运行指令: startup.cmd -m standalone
Nacos服务注册或发现 - 引入nacos.discovery依赖 - 配置nacos地址spring.cloud.discovery.nacos.server-addr

Nacos服务分级存储模型

xxxxxxxxxx6 1ribbon:2 eager-load:3 enabled: true # 开启饥饿加载4 clients: userservice # 指定对userservice这个服务饥饿加载5 - userservice16 - userservice2yaml

spring:
	cloud:
		nacos:
			server-addr: localhost:8848 # nacos服务端地址
			discovery:
				cluster-name: HZ #配置集群名称，也就是机房位置，例如:HZ，杭州

总结

Nacos服务分级存储模型

一级是服务，例如userservice
二级是集群，例如杭州或上海
三级是实例，例如杭州机房的某台部署了userservice的服务器

如何设置实例的集群属性

修改application.yml文件，添加spring.cloud.nacos.discovery.cluster-name属性即可心

那么如何设置orderservice也进行集群属性配置使得远程调用可以优先调用本地的集群?

1.修改order-service中的application.yml，设置集群

spring:
	cloud:
		nacos:
			server-addr: localhost:8848 # nacos服务端地址
			discovery:
				cluster-name: HZ # 配置集群名称，也就是机房位置，例如:HZ，杭州

2.在order-service中设置负载均衡的IRule为NacosRule，这个规则会优先寻找与自己同集群的服务

userservice:
	ribbon:
		NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule # 负载均衡规则

3.注意将user-service的权重都设置为1

Nacos负载均衡的策略：先访问本地的集群，在本地的集群内随机负载均衡

那么如何进行根据权重负载均衡呢?

Nacos提供了权重配置来控制访问的频次

在Nacos页面进行权重配置即可

权重为0即为停止访问，可以用来停机进行版本升级，再小量的提升权重，放入小部分用户进行测试，若无问题则调整群众，进行一个平滑的升级

Nacos的环境隔离-namespace

环境隔离先从 namespace 入手：在 Nacos 的命名空间管理区域为开发、测试等环境分别建立空间，并记录各自的 ID。微服务通过 spring.cloud.nacos.discovery.namespace 指向目标空间，消费者与提供者必须处在相同的发现范围内才能互相发现。下方配置填写的是命名空间 ID，不是显示名称；cluster-name 表示服务实例的集群属性，不能替代 namespace 的环境隔离职责。

修改命名空间：修改order-service的application.yml，添加namespace:

spring:
	cloud:
		nacos:
			server-addr: localhost:8848 # nacos服务端地址
			discovery:
				cluster-name: HZ # 配置集群名称，也就是机房位置，例如:HZ，杭州
				namespace: 492a7d5d-237b-46a1-a99a-fa8e98e4b0f9 #命名空间，填ID

Nacos环境隔离

namespace用来做环境隔离
每个namespace都有唯一id
不同namespace下的服务不可见

Nacos注册中心细节

服务注册与发现可以拆成四件事：提供者登记实例，客户端维护实例健康信息，消费者订阅或获取服务列表，消费者再按规则选择实例调用。本文采用的 Nacos 客户端配置通过 discovery.ephemeral 区分临时与持久实例；两者的健康检测和失联后的处理方式应结合服务端版本与协议理解。排查时先核对 namespace、服务名、集群名和实例健康状态，再判断是否是发现或负载均衡问题，不要只看到实例记录仍在就认定它可接收业务流量。

非临时实例：yml中的discovery:ephemeral: false

1.Nacos与eureka的共同点

都支持服务注册和服务拉取
都支持服务提供者心跳方式做健康检测

2.Nacos与Eureka的区别

Nacos支持服务端主动检测提供者状态:临时实例采用心跳模式，非临时实例采用主动检测模式
临时实例心跳不正常会被剔除，非临时实例则不会被剔除
Nacos支持服务列表变更的消息推送模式，服务列表更新更及时
Nacos集群默认采用AP方式，当集群中存在非临时实例时，采用CP模式;Eureka采用AP方式

Nacos配置管理

统一配置管理

需求：

配置更改热更新

如何管理：Nacos表单填写配置名称

Data ID: 配置文件的id:[服务名称]-[profile].[后缀名]
Group：分组：默认即可
格式：建议yaml

有个问题：Nacos的地址存于application.yml ，如何先读取到naocs地址呢？

有个bootstrap.yml优先级高于本地的配置文件，写在其中即可

本文的启动顺序是先读取引导配置，再连接 Nacos 获取远程配置，随后建立应用环境并创建业务对象。bootstrap.yml 提供连接地址、服务名、激活环境和后缀，客户端据此定位 Data ID；按文中的 userservice、dev、yaml 组合，对应的环境配置名为 userservice-dev.yaml。还需核对配置所属的 namespace 与 Group。该说明针对文中启用 bootstrap 的旧版集成方式，升级时应先核对配置加载机制，不能假设仅新增同名文件就必然生效。

配置步骤如下

1.引入Nacos的配置管理客户端依赖:

<!-- nacos配置管理依赖 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

2.在userservice中的resource目录添加一个bootstrap.yml文件，这个文件是引导文件，优先级高于application.yml:

spring:
	application:
		name : userservice #服务名称
	profiles:
		active: dev #开发环境，这里是dev
	cloud:
		nacos:
			server-addr: localhost:8848 #Nacos地址
			config:
				file-extension: yaml #文件后缀名

中间的三项配置即为Data ID

==将配置交给Nacos管理的步骤==

1.在Nacos中添加配置文件
在微服务中引入nacos的config依赖
在微服务中添加bootstrap.yml，配置nacos地址、当前环境、服务名称、文件后缀名。这些决定了程序启动时去nacos读取哪个文件

==如何进行热更新==

热更新先确认配置发布到了应用实际读取的 namespace、Group 与 Data ID，再检查客户端是否收到配置变更。对于通过 @Value 注入的运行参数，本文配合 @RefreshScope 让相关对象在刷新后重新取值；发布配置与业务对象实际使用新值是两个环节。验证时应读取应用暴露的相关行为或参数，不要仅凭配置中心内容已保存就认定所有对象都已经刷新。

另一种方式是用 @ConfigurationProperties 把同一前缀下的配置绑定到配置对象，并让业务代码读取该对象。能否动态重新绑定还取决于该对象是否正确注册、客户端刷新机制和具体版本，不能把注解本身视为热更新开关。可以只调整一个可观察的业务参数，再检查后续请求是否读取新值；连接池、启动结构等配置不一定支持在线变更，应单独确认其生命周期与重建要求。

Nacos配置更改后，微服务可以实现热更新，方式:

通过@Value注解注入，结合@RefreshScope来刷新

通过@ConfigurationProperties注入

自动刷新注意事项：

不是所有的配置都适合放到配置中心，维护起来比较麻烦
建议将一些关键参数，需要运行时调整的参数放到nacos配置中心，一般都是自定义配置

共享配置

微服务会从nacos读取的配置文件：
- [服务名]-[spring.profile.active].yaml，环境配置
- [服务名].yaml，默认配置，多环境共享
优先级：
- [服务名]-[环境].yaml >[服务名].yaml >本地配置

Nacos集群

原理示意：多个 Nacos 节点组成集群，按部署方案通过代理提供入口，配置数据使用共享的 MySQL 持久化存储。数据库连线只表示配置存储，不表示所有服务注册信息都写入 MySQL；节点互联、客户端协议和代理端口还需按实际版本配置。

集群搭建步骤：

搭建MySQL集群并初始化数据库表
下载解压nacos
修改集群配置（节点信息）、数据库配置
分别启动多个nacos节点
nginx反向代理

MySQL12-MVCC多版本并发控制

Fri, 30 Jun 2023 07:00:00 GMT

基本概念

当前读

读取的是记录的最新版本，读取时还要保证其他并发事务不能修改当前记录，会对读取的记录进行加锁。对于我们日常的操作，如:select … lock in share mode(共享锁)，select … for update、update、insert、delete(排他锁)都是一种当前读。

快照读

简单的select(不加锁）就是快照读，快照读，读取的是记录数据的可见版本，有可能是历史数据，不加锁，是非阻塞读。

1.Read Committed:每次select，都生成一个快照读。

2.Repeatable Read:开启事务后第一个select语句才是快照读的地方。

3.erializable:快照读会退化为当前读。

MVCC

全称Multi-Version Concurrency Control，多版本并发控制。指维护一个数据的多个版本，使得读写操作没有冲突，快照读为My5QL实现MVCC提供了一个非阻塞读功能。MVCC的具体实现，还需要依赖于数据库记录中的三个隐式字段、undo log日志、readview.

实现原理

记录中的隐式字段

隐式字段	含义
DB_TRX_ID(database transaction id)	最近修改事务ID，记录插入这条记录或最后一次修改该记录的事务ID。
DB_ROLL_PTR(database rollback pointer)	回滚指针，指向这条记录的上一个版本，用于配合undo log，指向上一个版本。
DB_ROW_ID(dataabse row id)	隐藏主键，如果表结构没有指定主键，将会生成该隐藏字段。

可以使用以下命令查看表空间信息

ibd2sdi xxx.ibd

undo log

回滚日志，在insert、update、delete的时候产生的便于数据回滚的日志。

当insert的时候，产生的undo log日志只在回滚时需要，在事务提交后，可被立即删除。

而update、delete的时候，产生的undo log日志不仅在回滚时需要，在快照读时也需要，不会立即被删除。

原理示意：记录上的修改事务标识和回滚指针把当前状态与撤销信息联系起来。快照读若发现当前版本不可见，就沿撤销信息重建更早版本，直到找到可见记录或确认不存在。图中的事务号与状态值都只是示例；更新、删除的撤销信息可能在提交后仍被旧快照需要，不能立即全部清除。

readview

ReadView（读视图）是快照读SQL执行时MVCC提取数据的依据，记录并维护系统当前活跃的事务（未提交的) id。

ReadView中包含了四个核心字段:

字段	含义
m_ids	当前活跃的事务ID集合
min_trx_id	最小活跃事务ID
max_trx_id	预分配事务ID,当前最大事务ID+1（因为事务ID是自增的）
creator_trx_id	ReadView创建者的事务ID

原理示意：先判断是否为自身修改，再比较版本修改事务号与快照边界。处于中间区间的版本，还要检查修改事务是否在创建快照时的活跃集合中，不能只按事务号大小判断。读已提交级别每次一致性读建立新视图，可重复读通常首次建立后复用；不可见时继续沿撤销链查找，而锁定读不按旧快照选版本。

==不同的隔离级别，生成ReadView的时机不同:
READ COMMITTED:在事务中每一次执行快照读时生成ReadView,
REPEATABLE READ:仅在事务中第一次执行快照读时生成ReadView，后续复用该ReadView.==

SpringCloud03-Eureka

Thu, 29 Jun 2023 15:00:00 GMT

简单的介绍了SpringCloud中的注册中心Eureka。

提供者与消费者

服务提供者:一次业务中，被其它微服务调用的服务。（提供接口给其它微服务）
服务消费者:一次业务中，调用其它微服务的服务。（调用其它微服务提供的接口）
提供者与消费者角色其实是相对的
一个服务可以同时是服务提供者和服务消费者

Eureka注册中心

服务调用出现的问题

服务消费者该如何获取服务提供者的地址信息?

服务提供者启动时向eureka注册自己的信息

eureka保存这些信息

消费者根据服务名称向eureka拉取提供者信息
如果有多个服务提供者，消费者该如何选择?

服务消费者利用负载均衡算法，从服务列表中挑选一个
消费者如何感知服务提供者健康状态?

服务提供者会每隔30秒向EurekaServer发送心跳请求，报告健康状态eureka会更新记录服务列表信息，心跳不正常会被剔除消费者就可以拉取到最新的信息

解决URL的硬编码问题

Eureka的作用

原理示意：提供者注册地址并发送心跳，消费者获取实例列表并在客户端选择目标。业务请求直接发给目标实例，不通过 Eureka Server 中转；服务发现的缓存与更新也意味着异常感知并非瞬时完成。

在Eureka架构中，微服务角色有两类:

EurekaServer:服务端，注册中心
- 记录服务信息
- 心跳监控
EurekaClient:客户端
- Provider:服务提供者，例如案例中的user-service
  - 注册自己的信息到EurekaServer
  - 每隔30秒向EurekaServer发送心跳
- consumer:服务消费者，例如案例中的order-service
  - 根据服务名称从EurekaServer拉取服务列表
  - 基于服务列表做负载均衡，选中一个微服务后发起远程调用

Eureka远程调用

搭建EurekaServer

搭建EurekaServer服务步骤如下:

1.创建项目，引入spring-cloud-starter-netflix-eureka-server的依赖

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

2.编写启动类，添加@EnableEarekaServer注解

3.添加application.yml文件，编写下面的配置:

server:
	port: 10086 # 服务端口
spring:
	application:
		name: eurekaserver # Eureka服务名称
eureka:
	client:
		service-url: # Eureka的地址信息
			defaultzone: http://127.0.0.1:10086/eureka/

注册微服务

将user-service服务注册到EurekaServer步骤如下:

1.在user-service项目引入spring-cloud-starter-netflix-eureka-client的依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

2.在application.yml文件，编写下面的配置:

spring:
	application:
		name: userservice
eureka:
	client:
		service-url:
			defaultZone: http:/ /127.0.0.1:10086/eureka/

在order-service完成服务拉取

1.修改OrderService的代码，修改访问的url路径，用服务名代替ip、端口：

- String url = "http://localhost:8081/user/" + order.getUserId();
+ String url = "http://userservice/user/" + order.getUserId();

2.在order-service项目的启动类OrderApplication的RestTemplate添加负载均衡注解：

@Bean
@LoadBalanced
public RestTemplate restTemplate(){
	return new RestTemplate();
}

总结

1.搭建EurekaServer
- 引入eureka-server依赖
- 添加@EnableEurekaServer注解
- 在application.yml中配置eureka地址
2.服务注册
- 引入eureka-client依赖
- 在application.yml中配置eureka地址
3.服务发现
- 引入eureka-client依赖
- 在application.yml中配置eureka地址
- 给RestTemplate添加@LoadBalanced注解
- 用服务提供者的服务名称远程调用

SpringCloud04-Ribbon负载均衡

Thu, 29 Jun 2023 14:30:00 GMT

简单的介绍了SpringCloud中的Ribbon负载均衡。

负载均衡原理

负载均衡流程

Ribbon拦截请求寻找Eureka返回服务列表，进行负载均衡

在本文的 Ribbon 调用链中，@LoadBalanced 的 RestTemplate 先由拦截器识别 URL 中的服务名，再通过服务发现获得可用实例列表，交给 IRule 选择目标实例，最后用选中实例的主机和端口发出 HTTP 请求。负载均衡发生在消费者一侧，Eureka 并不代理业务流量；实例列表通常还涉及客户端缓存与更新，不应理解为每次业务请求都同步查询一次注册中心。

负载均衡策略

IRule

内置负载均衡规则类	规则描述
RoundRobinRule	简单轮询服务列表来选择服务器。它是Ribbon默认的负载均衡规则。
AvailabilityFilteringRule	对以下两种服务器进行忽略: (1）在默认情况下，这台服务器如果3次连接失败，这台服务器就会被设置为“短路”状态。短路状态将持续30秒，如果再次连接失败，短路的持续时间就会几何级地增加。(2）并发数过高的服务器。如果一个服务器的并发连接数过高，配置了AvailabilityFilteringRule规则的客户端也会将其忽略。并发连接数的上限，可以由客户端的\.\.ActiveConnectionsLimit属性进行配置。
weightedResponseTimeRule	为每一个服务器赋予一个权重值。服务器响应时间越长，这个服务器的权重就越小。这个规则会随机选择服务器，这个权重值会影响服务器的选择。
ZoneAvoidanceRule	以区域可用的服务器为基础进行服务器的选择。使用Zone对服务器进行分类，这个Zone可以理解为一个机房、一个机架等。而后再对Zone内的多个服务做轮询。
BestAvailableRule	忽略哪些短路的服务器，并选择并发数较低的服务器。
RandomRule	随机选择一个可用的服务器。
RetryRule	重试机制的选择逻辑。

调整负载均衡策略

通过定义IRule实现可以修改负载均衡规则，有两种方式:

1.代码方式:在order-service中的OrderApplication类中，定义一个新的IRule:全局生效

@Bean
public IRule randomRule(){
	return new RandomRule();
}

2 配置文件方式:在order-service的application.yml文件中，添加新的配置也可以修改规则: 某个微服务范围生效

userservice:
	ribbon:
		NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule #负载均衡规则

饥饿加载

Ribbon默认是采用懒加载，即第一次访问时才会去创建LoadBalanceClient，请求时间会很长。而饥饿加载则会在项目启动时创建，降低第一次访问的耗时，通过下面配置开启饥饿加载:

ribbon:
	eager-load:
		enabled: true # 开启饥饿加载
		clients: userservice # 指定对userservice这个服务饥饿加载
			- userservice1
			- userservice2

SpringCloud02-服务拆分

Thu, 29 Jun 2023 14:00:00 GMT

简单的介绍了SpringCloud中的服务拆分。

服务拆分

注意事项：

1.不同微服务，不要重复开发相同业务
2.微服务数据独立，不要访问其它微服务的数据库
3.微服务可以将自己的业务暴露为接口，供其它微服务调用

远程调用

如何进行远程调用呢，让其中一个微服务发起http请求，返回需要的数据即可

步骤：

1.注册RestTemplate

/**
 * 创建一个RestTemplate并且注入Spring容器
 * @return
 */
@Bean
public RestTemplate restTemplate(){
    return new RestTemplate();
}

2.利用RestTemplate发起http请求

restTemplate.getForObject(url, User.class);	//自动反序列化为json数据

JavaSE03-Java高级

Wed, 28 Jun 2023 17:00:00 GMT

SpringCloud00-总览

Wed, 28 Jun 2023 11:00:00 GMT

SpringCloud01-微服务简介

SpringCloud02-服务拆分

SpringCloud03-Eureka

SpringCloud04-Ribbon负载均衡

SpringCloud05-Nacos

SpringCloud06-Feign

SpringCloud07-Gateway

SpringCloud08-Docker

SpringCloud09MQ

SpringCloud09-MQ

SpringCloud01-微服务简介

Wed, 28 Jun 2023 11:00:00 GMT

简单的介绍了SpringCloud中的微服务技术栈。

微服务技术栈

原理示意：业务服务负责各自能力，网关处理统一入口，注册与配置中心提供治理信息，缓存、搜索与消息队列提供运行能力。日志、监控和部署贯穿这些服务的生命周期；图按职责归类，不表示所有组件都属于 Spring Cloud，也不要求小型系统一次性引入全部组件。

微服务拆分，形成微服务集群
注册中心：拉取活注册服务信息（记录微服务的ip端口等，微服务调用关系访问注册中心获得对方信息）
配置中心：拉取配置信息（统一的管理所有微服务的配置，实现配置的热更新）
服务网关组件：身份校验，将请求路由到服务，可以进行负载均衡
分布式缓存：实现高并发
分布式搜索：进行复杂的搜索
消息队列：异步通信，提高服务并发
分布式日志服务：统计整个集群的日志，统一存储，统计进行分析
系统监控链路追踪：实时监控整个集群中每个节点的运行状态，一旦出现问题可以快速定位异常所在
自动化部署（Jenkins）
打包（Docker） kuebernetes RANCHER

微服务简介

单体架构

将业务的所有功能集中在一个项目中开发，打成一个包部署。

优点：

架构简单
部署成本低

缺点：

耦合度高

分布式架构

根据业务功能对系统进行拆分，每个业务模块作为独立项目开发，称为一个服务。

优点：

降低服务耦合
有利于服务升级拓展

缺点：

服务治理
- 服务拆分粒度？
- 服务集群地址如何维护？
- 服务之间如何实现远程调用？
- 服务健康状态如何感知？

微服务架构特征

微服务是一种经过良好架构设计的分布式架构方案，微服务架构特征：

单一职责：微服务拆分粒度更小，每一个服务都对应唯一的业务能力，做到单一职责，避免重复业务开发
面向服务：微服务对外暴露业务接口
自治：团队独立、技术独立、数据独立、部署独立
隔离性强：服务调用做好隔离、容错、降级，避免出现级联问题

微服务结构

技术框架

SpringCloud
Dubbo
SpringCloudAlibaba

差异对比

	Dubbo	SpringCloud	SpringCloudAlibaba
注册中心	zookeeper、Redis	Eureka、Consul	Nacos、Eureka
服务远程调用	Dubbo协议	Feign(http协议)	Dubbo、Feign
配置中心	无	SpringCloudConfig	SpringCloudConfig、Nacos
服务网关	无	SpringCloudGateway、Zuul	SpringCloudGateway、Zuul
服务监控和保护	Dubbo-admin，功能弱	Hystrix	Sentinel

SpringCloud

SpringCloud是目前国内使用最广泛的微服务框架。

SpringCloud基于SpringBoot

Spring Boot 负责单个服务的应用组织与启动，Spring Cloud 则围绕多个服务协作提供治理组件。可以沿一条调用链理解它们：服务先注册实例信息，消费者按服务名发现实例，再通过 HTTP 客户端发起调用；外部请求由网关统一路由，跨服务的配置、监控与容错由相应组件配合。前面的组件对照表属于本文学习时的技术背景，实际选型还应核对 Spring Boot、Spring Cloud 与 Alibaba 组件的版本兼容关系。

SSM12-MybatisPlus

Wed, 28 Jun 2023 10:00:00 GMT

基础案例

==极其精简化了dao层的书写==

==先引入mp起步依赖==

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>3.0.2</version>
</dependency>

==导入实体类和表==

==定义数据接口继承BaseMapper<泛型>即可==

@Mapper
public interface UserDao extends BaseMapper<User> {
}

CURD和分页

功能	自定义接口	MP接口
新增	boolean save(T t)	int insert(T t)
删除	boolean delete(int id)	int deleteById(Serializable id)
修改	boolean update(T t)	int updateById(T t)
根据id查询	T getById(int id)	T selectById (Serializable id)
查询全部	List getAll()	List selectList()
分页查询	PageInfo getAll(int page, int size)	IPage selectPage(IPage page)
条件查询	List getAll(Condition condition)	IPage selectPage(wrapper querywrapper)

==自动动态SQL==

样例：

@SpringBootTest
class MybatisplusApplicationTests {

    @Autowired
    private UserDao userDao;

    //添加
    @Test
    void testSave() {
        User user = new User();
        user.setName("Wang");
        user.setPassword("123456");
        user.setAge(9);
        user.setTel("116483477");
        userDao.insert(user);
    }

    //删除
    @Test
    void testDelete() {
        userDao.deleteById(1L);
    }

    //修改
    @Test
    void testUpdate() {
        User user = new User();
        user.setId(1L);
        user.setName("Wang-nine");
        userDao.updateById(user);
    }

    //查找
    @Test
    void testGetById() {
        User user = userDao.selectById(1L);
        System.out.println(user);
    }

    //查找全部
    @Test
    void testGetAll() {
        List<User> users = userDao.selectList(null);
        System.out.println(users);
    }

    //分页查询
    @Test
    void testGetByPage() {
        IPage page = new Page(1, 2);
        userDao.selectPage(page, null);
        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());
    }
    
    //

}

==对于分页查询，开启拦截器和输出日志==

拦截器

@Configuration
public class MpConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        //1.定义mp拦截器
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        //2.添加具体的拦截器
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mybatisPlusInterceptor;
    }
}

配置日志输出

mybatis:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

==条件查询==

//按条件查询
@Test
void testGetByCondition() {
    //第一种方法
    QueryWrapper qw = new QueryWrapper();
    //查询小于18岁的
    qw.lt("age", 18);
    List<User> users = userDao.selectList(qw);
    System.out.println(users);

    //第二种方法，lambda表达式
    QueryWrapper<User> qw1 = new QueryWrapper();
    qw1.lambda().lt(User::getAge, 18);
    List<User> users1 = userDao.selectList(qw);
    System.out.println(users1);

    //第三种方法，lambda表达式
    LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
    lqw.lt(User::getAge, 18);
    List<User> users2 = userDao.selectList(lqw);
    System.out.println(users2);

    //链式编程
    LambdaQueryWrapper<User> lqw1 = new LambdaQueryWrapper<>();
    lqw1.lt(User::getAge, 30).or().gt(User::getAge, 10);
    
    //判断为空
    //其弊端，判断年龄上下限，需要新来一个类继承一下user同时自己扩展一个age2
    //模拟页面传递的数据，万一age2为空之类的情况
    UserQuery uq = new UserQuery();
    uq.setAge(10);
    uq.setAge2(30);
    lqw.lt(null != uq.getAge2(), User::getAge, uq.getAge2());
    lqw.gt(null != uq.getAge(), User::getAge, uq.getAge());
   	...查询语句...
}

==查询投影，非常麻烦，不如自己写==

查询投影解决的是“返回哪些列”，与前面年龄上下限解决的“保留哪些行”不同。先确定调用方真正需要的字段，再让查询只选择这些列；若用实体承接部分列，未查询属性通常不会被填入数据，不能把它们当成完整记录直接覆盖更新。涉及统计或分组时，结果形状也可能不再对应完整 User，应选择合适的结果对象或映射方式，并核对实际生成的 SELECT 列表。

==对于其余的复杂查询，例如> = between like null in group order等，强烈建议自己写mysql语句，不要再去学习复杂的API了==

==实在想学，可以查看它的官方文档==

==字段名称映射(均为熟悉注解)==

名称不一致

@TableField(value = "数据库字段名")

存在数据库未定义属性

@TableField(exist = false)

设定不可查询的字段权限，设定不参与查询

@TableField(select = false)

表名与实体类名不一致

@TableName("表名")

全局配置表名前缀

mybatis-plus:
	global-config:
		db-config:
			table-prefix: tbl_

==id生成策略(均为属性注解)==

@TableId(value = 数据库主键名称, type = 策略)

策略：IdType.AUTO 自增 NONE无策略 INPUT自己输入 ASSIGN_ID雪花算法 ASSIGN_UUIDuuid

主键策略首先要区分由谁提供标识：AUTO 依赖数据库自增，INPUT 要求应用在插入前设置主键，ASSIGN_ID 通常由框架的标识生成器分配，默认使用雪花算法，ASSIGN_UUID 面向字符串主键生成标识。NONE 表示没有单独指定策略，可跟随全局配置，并不等于数据库一定自增。应同时核对实体主键类型、数据库列定义、字段级 @TableId 与全局 id-type，避免只改一处配置就假定所有新增记录都会采用同一种方式。

也可在yaml中全局配置

mybatis-plus:
	global-config:
		db-config:
			id-type: assign_id

==多数据操作==

样例

List<Long> ids = Arrays.asList(new Long[]{2, 3});
userDao.deleteBatchIds(ids);	//删除
userDao.selectBatchIds(ids);	//查询

==逻辑删除==

通用配置

mybatis-plus:
	global-config:
		db-config:
			logic-delete-field: deleted
			logic-not-delete-value: 0
			logic-delete-value: 1

==乐观锁：比如秒杀（可以解决2000个一下的并发问题）==

新增一个字段并加上下述注解

属性注解

@Version

@Configuration
public class MpConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        //1.定义mp拦截器
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        //2.添加具体的拦截器
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        //3.添加乐观锁拦截器
        mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return mybatisPlusInterceptor;
    }
}

SSM10-SSM整合深入

Tue, 27 Jun 2023 10:00:00 GMT

详细的描述了Spring中的SSM整合深入

SSM整合深入

表现层与前端数据协议

前端接收数据格式—创建结果模型类，封装数据到data属性中（操作的结果）
前端接收数据格式—封装操作结果到code属性中（操作的结果：true还是false）
前端接收数据格式—封装特殊消息到message(msg)属性中（给用户看的）

综上，设计一个统一数据返回结果类

public class Result {
	private Object data;
    private Integer code;
    private String msg;
}

Result类中的字段并不是固定的，可以根据需要自行增减提供若干个构造方法，方便操作

针对Code也可以设计一个返回结果编码类

package com.wang.controller;

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;
}

SSM异常处理器

出现异常现象的常见位置与常见诱因如下:
- 框架内部抛出的异常:因使用不合规导致
- 数据层抛出的异常:因外部服务器故障导致（例如:服务器访问超时）
- 业务层抛出的异常:因业务逻辑书写错误导致（例如:遍历业务书写操作，导致索引异常等）
- 表现层抛出的异常:因数据收集、校验等规则导致（例如:不匹配的数据类型间导致异常）
- 工具类抛出的异常:因工具类书写不严谨不够健壮导致（例如:必要释放的连接长期未释放等）

问题如下

1.各个层级均出现异常，异常处理代码书写在哪一层？

==所有的异常均抛出到表现层进行处理== 向上抛到表现层

2.表现层处理异常，每个方法中单独书写，代码书写量巨大且意义不强，如何解决?

AOP思想

实现代码与杂项4-项目中的全局异常处理器相同：

/**
 * 全局异常处理器
 */

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)      //捕获所有的异常
    public Result ex(Exception ex) {
        ex.printStackTrace();
        return Result.error("对不起，操作失败，请联系管理员");
    }
}

SSM09-SSM整合

Mon, 26 Jun 2023 14:00:00 GMT

详细的描述了Spring中的SSM整合

SSM整合流程

1.创建工程

2.SSM整合

Spring
- SpringConfig
MyBatis
- MybatisConfig
- JdbcConfig
- Jdbc.properties
SpringMVC
- ServletConfig
- SpringMVCConfig

3.功能模块

表与实体类
dao（接口+自动代理）
service（接口+实现类）
业务层接口测试（整合JUnit）
mapper

设计一个简单的图书管理系统

总体思路分析

Spring整合MyBatis

配置
- SpringConfig
- JDBCConfig、jdbc.properties
- MyBatisconfig
模型
- Book
数据层标准开发
- BookDao
业务层标准开发
- BookService
- BookServiceImpl
测试接口 BookServiceTest
事务处理
- 在SpringConfig中开启注解式事务驱动@EnableTransactionManagement
- 在JdbcConfig中添加事务管理器PlatformTransactionManager
- 在业务层接口上添加Spring事务管理

Spring整合SpringMVC

Web配置类（详见SSM07样例代码4）
SpringMVC配置类 SpringMVCConfig
基于Restful的Controller开发

样例代码以及测试如下

程序框架

原理示意：图书请求先由 DispatcherServlet 分派给 BookController，再委托 BookService 与 MyBatis 创建的 BookDao 代理访问数据库。结果按调用链返回，由 MVC 转为 JSON 响应。ServletConfig 分别加载根容器与 MVC 子容器配置，前者管理业务、数据源和持久层，后者管理控制器；这解释了程序如何协作，而不是把目录结构当作实际请求路径。

MySQL数据库的设计（简单设计，样例较为简单，用于测试）

create database ssm_db default charset utf8mb4;

use ssm_db;

create table tbl_book (
    id int not null auto_increment comment 'id',
    type varchar(20) not null comment '种类',
    name varchar(50) not null comment '书名',
    description varchar(255) not null comment '简介',
    primary key (id)
) COMMENT='商品表';

begin;
   insert into tbl_book(type, name, description) values ('计算机理论', 'Spring实战第一版', 'Spring经典教程1');
   insert into tbl_book(type, name, description) values ('计算机理论', 'Spring实战第二版', 'Spring经典教程2');
   insert into tbl_book(type, name, description) values ('计算机理论', 'Spring实战第三版', 'Spring经典教程3');
   insert into tbl_book(type, name, description) values ('计算机理论', 'Spring实战第四版', 'Spring经典教程4');
   insert into tbl_book(type, name, description) values ('计算机理论', 'Spring实战第五版', 'Spring经典教程5');
   insert into tbl_book(type, name, description) values ('计算机理论', 'Spring实战第六版', 'Spring经典教程6');
   insert into tbl_book(type, name, description) values ('计算机理论', 'Spring实战第七版', 'Spring经典教程7');
   insert into tbl_book(type, name, description) values ('计算机理论', 'Spring实战第八版', 'Spring经典教程8');
   insert into tbl_book(type, name, description) values ('计算机理论', 'Spring实战第九版', 'Spring经典教程9');
   insert into tbl_book(type, name, description) values ('市场营销', '市场营销第一版', '市场营销教程1');
   insert into tbl_book(type, name, description) values ('市场营销', '市场营销第二版', '市场营销教程2');
   insert into tbl_book(type, name, description) values ('市场营销', '市场营销第三版', '市场营销教程3');
commit;

详细的代码放到了github，网址如下，需要自取：

小型的SSM图书管理系统

简单的使用postman对其中的增删改查功能进行了测试

按 BookController 的路由，可在 Postman 依次验证：GET /books 查询列表，GET /books/{id} 查询指定图书，POST /books 新增，PUT /books 修改，DELETE /books/{id} 删除。新增和修改请求使用 JSON 请求体，字段对应 Book 的 type、name、description，修改时还需携带 id，并设置 Content-Type 为 application/json。不要只看布尔返回值：本例写操作直接返回 true，验证增删改是否真正生效还应重新查询相应记录；路径中的 id 应使用当前数据中的真实主键。

具体代码如下（较为冗长，用于本人复习和调试）

Config模块

JdbcConfig

package com.wang.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;

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
    // 2.事务管理器
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager ds = new DataSourceTransactionManager();
        ds.setDataSource(dataSource);
        return ds;
    }
}

MybatisConfig

package com.wang.config;

import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class MybatisConfig {

    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        factoryBean.setTypeAliasesPackage("com.wang.domain");
        return factoryBean;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.wang.dao");
        return msc;
    }
}

ServletConfig

package com.wang.config;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

SpringConfig

package com.wang.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@ComponentScan("com.wang.service")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class, MybatisConfig.class})
// 1.开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {

}

SpringMVCConfig

package com.wang.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

@Configuration
@ComponentScan("com.wang.controller")
@EnableWebMvc
public class SpringMvcConfig {
}

Controller（表现层）

BookController

package com.wang.controller;

import com.wang.domain.Book;
import com.wang.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@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<Book> getAll() {
                return bookService.getAll(      );
        }
}

dao（持久层/持久层）

BookDao

package com.wang.dao;

import com.wang.domain.Book;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import java.util.List;

public interface BookDao {
    @Insert("insert into ssm_db.tbl_book(type, name, description) values (#{type}, #{name}, #{description})")
    public void save(Book book);
    @Update("update ssm_db.tbl_book set type=#{type}, name=#{name}, description=#{description} where id = #{id}")
    public void update(Book book);
    @Delete("delete from ssm_db.tbl_book where id=#{id}")
    public void delete(Integer id);
    @Select("select * from ssm_db.tbl_book where id=#{id}")
    public Book getById(Integer id);
    @Select("select * from ssm_db.tbl_book")
    public List<Book> getAll();
}

Service（业务层）

BookService

package com.wang.service;

import com.wang.domain.Book;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * @author Wang
 */


@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<Book> getAll();
}

BookServiceImpl

package com.wang.service.impl;

import com.wang.dao.BookDao;
import com.wang.domain.Book;
import com.wang.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@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<Book> getAll() {
        return bookDao.getAll();
    }
}

Domain（实体类）

Book

package com.wang.domain;

public class Book {
    private Integer id;
    private String type;
    private String name;
    private String description;


    public Book() {
    }

    public Book(Integer id, String type, String name, String description) {
        this.id = id;
        this.type = type;
        this.name = name;
        this.description = description;
    }

    /**
     * 获取
     * @return id
     */
    public Integer getId() {
        return id;
    }

    /**
     * 设置
     * @param id
     */
    public void setId(Integer id) {
        this.id = id;
    }

    /**
     * 获取
     * @return type
     */
    public String getType() {
        return type;
    }

    /**
     * 设置
     * @param type
     */
    public void setType(String type) {
        this.type = type;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return description
     */
    public String getDescription() {
        return description;
    }

    /**
     * 设置
     * @param description
     */
    public void setDescription(String description) {
        this.description = description;
    }

    public String toString() {
        return "Book{id = " + id + ", type = " + type + ", name = " + name + ", description = " + description + "}";
    }
}

测试类

BookServiceTest

package wang;

import com.wang.config.SpringConfig;
import com.wang.domain.Book;
import com.wang.service.BookService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

@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<Book> books = bookService.getAll();
        System.out.println(books);
    }

}

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.example</groupId>
  <artifactId>SSMtest</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>SSMtest Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.6</version>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>

    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.16</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <port>80</port>
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

JUC

Sun, 25 Jun 2023 16:00:00 GMT

Java.util.concurrent

进程:指在系统中正在运行的一个应用程序﹔程序一旦运行就是进程﹔进程——资源分配的最小单位。。
线程:系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。

线程的状态（可以通过Thread.State枚举类查看）

NEW （新建态）
RUNNABLE（准备就绪）
BLOCKED（阻塞）
WAITING（不见不散）
TIMED WAITING（过时不候）
TERMINATED（终止）

Wait和Sleep的区别

sleep是Thread的静态方法，wait是 Object的方法，任何对象实例都能调用
sleep不会释放锁，它也不需要占用锁。wait会释放锁，但调用它的前提是当前线程占有锁(即代码要在synchronized中)
它们都可以被interrupted方法中断

项目重构

Sat, 24 Jun 2023 16:00:00 GMT

环境搭建

准备数据库表（dept，emp)
创建SpringBoot工程
- 引入web开发起步依赖，mybatis依赖（mybatis依赖和mysql驱动），lombok依赖
在application.properties中引入mybatis的配置信息
准备对应的实体类
准备对应的Mapper、Service(接口、实现类)、Controller基础结构

部门管理开发：根据接口文档阅读开发Restful风格

明确三层架构的功能
Controller
- 1.接收请求
- 2.调用service层功能
- 3.响应
Service
- 调用mapper接口功能
Mapper
- 执行对应的SQL语句与数据库进行互动

简化开发：二者效果相同
@RequestNapping(value = "/depts", method = RequestNethod.GET)
@GetMapping("/ depts")
注意在接口中注入Bean对象，例如Controller中注入Service对象，Service中注入Mapper对象，达到解耦的效果

==接口测试，postman / 前后端联调==

==日志：@Slf4j==

==注意某些路径的 @PathVariable==

==注意解析json格式的前端请求参数可以使用@RequestBody来将json封装到实体类中==

==@RequestMapping(“/depts”) 公共路径抽取：完整的请求路径，应该是类上的@RequestMapping 的value属性＋方法上的@RequestMapping的value属性。==

员工管理开发：

难点：分页查询

分页查询

需要两条SQL语句

显示当前页面

select * from emp limit ?, ?;

显示所有数据

select count(*) from emp;

前端传来的数据

当前页码:page
每页展示记录数:pageSize

后端响应的数据

数据列表:List select * from emp limit ?,?;
总记录数:total select count (*) from emp;

==目前需要返回两项数据，方法只能返回一个数据，使用实体类封装返回==

==@ResultParam(defaultvalue = ”默认值“) 参数可以设置参数的默认值==

分页查询插件PageHelper

使用 PageHelper 时，先确保项目已引入匹配的依赖并注册分页拦截器，再在要分页的 MyBatis 查询前紧邻调用 PageHelper.startPage(page, pageSize)，随后立即执行目标查询，避免夹入其他查询。分页插件负责改写分页 SQL，并可按配置执行总数查询；返回时将本页数据与总记录数封装到同一个响应对象。检查页码与每页条数的范围、排序是否稳定，以及筛选条件是否同时作用于数据和总数，不要分页之后再对结果重复做内存切片。

文件上传

文件上传请求使用 multipart/form-data，让普通字段与文件作为不同部分传给后端。接口联调时，对本文带普通参数的示例填写 username、age，将 image 字段设为文件并选择本地文件；字段名应与接收参数一致。服务端用 MultipartFile 读取文件，校验大小与实际类型后生成安全的唯一名称，再保存到本地目录或交给 OSS 工具。浏览器提交 FormData 时应让浏览器生成含 boundary 的请求头，不要手写一个缺少 boundary 的 Content-Type。

方法1：将文件保存到本地

/*@PostMapping("/upload")
public Result upload(String username, Integer age, MultipartFile image) throws Exception {
    log.info("文件上传：{}，{}，{}", username, age, image);

    //获取原始文件名
    String originalFilename = image.getOriginalFilename();

    //构造唯一的文件名（不能重复）-- uuid（通用唯一识别码）
    int index = originalFilename.lastIndexOf('.');
    String extname = originalFilename.substring(index);
    String newFileName = UUID.randomUUID().toString() + extname;
    log.info("新的文件名：{}", newFileName);

    //将接收到的文件存储在服务器的磁盘目录中 D:\image
    image.transferTo(new File("D:\\image\\" + newFileName));

    return Result.success();
}*/

方法2：将文件保存到AliOSS

@PostMapping("/upload")
public Result upload(MultipartFile image) throws Exception {
    log.info("文件上传，文件名：{}", image.getOriginalFilename());

    //调用阿里云OSS工具类
    String url = aliOSSUtils.upload(image);
    log.info("文件上传完成，文件访问的url为：{}", url);

    return Result.success(url);
}

==修改员工需要查询回显和update语句==

==配置注入使用@Value(“#{配置中的key}”)注解来防止硬编码==

登陆校验（难点）

==若按照普通的开发区编写映射页面，通过数据库判别是否用户名与密码正确式不可取的==

如此的话，直接访问类似于 /emps /depts 等页面可以直接进入控制台面板而跳过了判断是否为管理员的步骤

因此，我们需要在 /login /depts /emps 之间建立一种联系

实现思路：

员工登陆成功存储一个标记
在每一个方法接口前判断员工是否登陆，登陆则访问，未登录则返回给前端错误信息
因此，需要两种技术==1.统一拦截== ==2.登陆标记缓存==
- 统一拦截
  - Servlet提供的过滤器Filter
  - Spring提供的拦截器Interceptor
- 用户登陆
  - 会话技术

会话技术

会话：指的是用户打开浏览器，访问web服务器的资源，会话建立，直到有一方断开连接，会话结束。在一次会话中可以包含多次请求和响应。
会话跟踪：一种维护浏览器状态的方法，服务器需要识别多次请求是否来自于同一浏览器，以便在同一次会话的多次请求间共享数据。

http协议是无状态协议，不会携带上一次会话的信息，因此无法数据共享

会话跟踪方案
- 客户端会话跟踪技术：Cookie（存储在浏览器）
- 服务端会话跟踪技术：Session（存储在服务器端）
- 令牌技术

Cookie：浏览器第一次请求时在服务器端设置Cookie，响应时携带Cookie，而后Cookie缓存在浏览器本地，之后的每次请求都会携带Cookie与客户端进行对比，服务器自动响应Cookie，浏览器自动保存Cookie，发起请求自动携带Cookie，三个自动表名Http支持Cookie技术

请求头Cookie

响应头Set-Cookie

优点：HTTP协议支持

缺点：1.移动端无法使用 2.不安全，用户可以自己禁用 3.Cookie不能跨域（跨域：协议、IP/域名、端口不同）

Session：浏览器第一次请求时在服务器端设置Session（ID），响应时通过Cookie返回Session的ID，之后的每次请求都会携带Cookie中的Session的ID到服务器端对比

优点：存储在服务器端，安全

缺点：1.服务器集群在负载均衡后有可能无法使用，因此无法在服务器集群环境下使用 2.Cookie的缺点

令牌技术（==建议使用==）：用户身份表示，登陆成功生成令牌，响应给浏览器，可以存储在Cookie或者其他存储空间中，之后的每次请求都会携带令牌，比对是否有效，而且想要共享数据只需要将数据保存在令牌中即可

优点：1.支持PC、移动端 2、解决集群环境下的认证问题 3、减轻了服务器端的存储压力

缺点：需要自己去实现

JWT（JSON Web Token）令牌

定义了一种简洁的、自包含的格式，用于在通信双方以json数据格式安全的传输信息。由于数字签名的存在，这些信息是可靠的。

jwt令牌组成

第一部分:Header(头)，记录令牌类型、签名算法等。例如: {“alg”:”HS256” ,”type”:”JWT”}
第二部分:Payload(有效载荷)，携带一些自定义信息、默认信息等。例如: {“id”:” 1” ,”username”:”Tom”}
第三部分:Signature(签名)，防止Token被篡改、确保安全性。将header、 payload，并加入指定秘钥，通过指定签名算法计算而来。

pom.xml引入

<!--JTW令牌-->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

jwt生成

public class JwtUtils {

    private static String signKey = "wangnine";
    private static Long expire = 43200000L;

    /**
     * 生成JWT令牌
     * @param claims JWT第二部分负载 payload 中存储的内容
     * @return
     */
    public static String generateJwt(Map<String, Object> claims){
        String jwt = Jwts.builder()
                .addClaims(claims)
                .signWith(SignatureAlgorithm.HS256, signKey)
                .setExpiration(new Date(System.currentTimeMillis() + expire))
                .compact();
        return jwt;
    }

    /**
     * 解析JWT令牌
     * @param jwt JWT令牌
     * @return JWT第二部分负载 payload 中存储的内容
     */
    public static Claims parseJWT(String jwt){
        Claims claims = Jwts.parser()
                .setSigningKey(signKey)
                .parseClaimsJws(jwt)
                .getBody();
        return claims;
    }
}

统一拦截技术

Filter过滤器

JavaWeb三大组件(Servlet、Filter、Listener)之一。

过滤器可以把对资源的请求拦截下来，从而实现一些特殊的功能。
过滤器一般完成一些通用的操作，比如:登录校验、统一编码处理、敏感字符处理等。

相当于抽取了各个页面的登陆校验，优点aop的思想

==如何实现过滤器==

1.定义Filter:定义一个类，实现 Filter接口，并重写其所有方法。
配置Filter: Filter类上加@WebFilter注解，配置拦截资源的路径。引导类上加@ServletComponentScan开启Servlet组件支持。

结合了jwt后的代码如下：

@Slf4j
//@WebFilter(urlPatterns = "/*")  //拦截所有
public class LoginCheckFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) servletRequest;
        HttpServletResponse resp = (HttpServletResponse) servletResponse;
        //1.获取请求url
        String url = req.getRequestURL().toString();
        log.info("请求的url：{}", url);

        //2.判断请求的url中是否包含login，如果包含，说明是登录操作，直接放行
        if(url.contains("login")) {
            log.info("登录操作，放行...");
            filterChain.doFilter(servletRequest, servletResponse);
            return;
        }

        //3.获取请求头中的token令牌
        String jwt = req.getHeader("token");

        //4.判断令牌是否存在，如果不存在，则返回错误结果（未登录）
        if(!StringUtils.hasLength(jwt)) {
            log.info("请求头token为空，返回未登录的信息");
            Result error = Result.error("NOT_LOGIN");
            //手动将对象转换为json格式
            String notLogin = JSONObject.toJSONString(error);
            resp.getWriter().write(notLogin);
            return;
        }

        //5.解析token，如果解析失败，则返回错误结果（未登录）
        try {
            JwtUtils.parseJWT(jwt);
        } catch (Exception e) {
            log.info("解析令牌失败，返回未登录的误信息");
            Result error = Result.error("NOT_LOGIN");
            //手动将对象转换为json格式
            String notLogin = JSONObject.toJSONString(error);
            resp.getWriter().write(notLogin);
            return;
        }

        //6.放行
        log.info("令牌合法，放行");
        filterChain.doFilter(servletRequest, servletResponse);
    }
}

//对于init 和 destroy 有默认实现，二者只调用一次

Interceptor拦截器

@Slf4j
@Component
public class LoginCheckInterceptor implements HandlerInterceptor {

    @Override   //目标资源方法运行前运行，返回true放行，返回false不放行
    public boolean preHandle(HttpServletRequest req, HttpServletResponse resp, Object handler) throws Exception {

        //1.获取请求url
        String url = req.getRequestURL().toString();
        log.info("请求的url：{}", url);

        //2.判断请求的url中是否包含login，如果包含，说明是登录操作，直接放行
        if(url.contains("login")) {
            log.info("登录操作，放行...");
            return true;
        }

        //3.获取请求头中的token令牌
        String jwt = req.getHeader("token");

        //4.判断令牌是否存在，如果不存在，则返回错误结果（未登录）
        if(!StringUtils.hasLength(jwt)) {
            log.info("请求头token为空，返回未登录的信息");
            Result error = Result.error("NOT_LOGIN");
            //手动将对象转换为json格式
            String notLogin = JSONObject.toJSONString(error);
            resp.getWriter().write(notLogin);
            return false;
        }

        //5.解析token，如果解析失败，则返回错误结果（未登录）
        try {
            JwtUtils.parseJWT(jwt);
        } catch (Exception e) {
            log.info("解析令牌失败，返回未登录的误信息");
            Result error = Result.error("NOT_LOGIN");
            //手动将对象转换为json格式
            String notLogin = JSONObject.toJSONString(error);
            resp.getWriter().write(notLogin);
            return false;
        }

        //6.放行
        log.info("令牌合法，放行");
        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...");
    }
}

异常处理

在Controller层定义一个全局异常处理器

import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

/**
 * 全局异常处理器
 */

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)      //捕获所有的异常
    public Result ex(Exception ex) {
        ex.printStackTrace();
        return Result.error("对不起，操作失败，请联系管理员");
    }
}

@RestControllerAdvice

@ExceptionHandler(Exception.class) //捕获所有的异常

JavaSE02-Java中的文件与方法递归与IO流

Sat, 24 Jun 2023 15:00:00 GMT

详细的描述了Java中 File类的使用，一步一步剖析了IO流如何创建、如何使用以及其中的注意事项。

File类使用：详细的描述了使用File的对象操作文件，如:删除、获取文件信息、创建文件夹等
方法递归：详细的描述了递归算法思想并能完成常见递归题目，以及文件搜索
字符集：程序中经常要读取文件中的数据，知道数据的底层形式才能够去学习如何读写数据
IO流的作用：使用IO流完成文件数据的读写等操作
字节流与字符流：数据的类型很多，要学会选择不同的流进行读写操作

File

File类在包java.io.File下、代表操作系统的文件对象（文件、文件夹）。
File类提供了诸如∶定位文件，获取文件本身的信息、删除文件、创建文件（文件夹）等功能
但是不能读写文件内容。

File类创建对象API

方法名称	说明
public File(String pathname)	根据文件路径创建文件对象
public File(String parent, String child)	从父路径名字符串和子路径名字符串创建文件对象
public File(File parent, String child)	根据父路径对应文件对象和子路径名字符串创建文件对象

案例：查询文件的大小

import java.io.File;

public class Main {
    public static void main(String[] args) {
        // 1.创建一个FILE文件，指代某个具体的文件
        File f1 = new File("D:\\test.txt");
        File f2 = new File("D:" + File.separator + "test.txt"); //跨平台写法，不同系统的文件分隔符不同
        System.out.println(f1.length());    //文件大小
        System.out.println(f2.length());
    }
}

注意

查询文件夹大小为文件夹大小，不包括文件夹内部内容大小。
File对象既可以代表文件、也可以代表文件夹。
File封装的对象仅仅是一个路径名，这个路径可以是存在的，也允许是不存在的。

FILE类的常用方法

File提供的判断文件类型、获取文件信息功能

方法名称	说明
public boolean exists()	判断当前文件对象，对应的文件路径是否存在，存在返回true
public boolean isFile()	判断当前文件对象指代的是否是文件，是文件返回true，反之。
public boolean isDirectory()	判断当前文件对象指代的是否是文件夹，是文件夹返回true，反之。
public string getName()	获取文件的名称((包含后缀)
public long length()	获取文件的大小，返回字节个数
public long lastModified()	获取文件的最后修改时间。
public string getPath()	获取创建文件对象时，使用的路径
public string getAbsolutePath()	获取绝对路径

FILE提供的创建文件，删除文件

方法名称	说明
public boolean preateNewFile()	创建一个新文件（文件内容为空，创建成功返回true，反之。
public boolean mkdir()	用于创建文件夹，注意：只能创建一级文件夹
public boolean mkdirs()	用于创建文件夹，注意：可以创建多级文件夹
public boolean delete()	删除文件，或者空文件，注意：不能删除非空文件夹。

注意：delete方法默认只能删除文件和空文件夹，删除后的文件不会进入回收站。

FILE提供的遍历文件夹

方法名称	说明
public string[] list()	获取当前目录下所有的”一级文件名称”到一个字符串数组中去返回。
public File[] listFiles()	获取当前目录下所有的”—级文件对象”到一个文件对象数组中去返口

使用listFiles方法时的注意事项：

当主调是文件，或者路径不存在时，返回null
当主调是空文件夹时，返回一个长度为O的数组
当主调是一个有内容的文件夹时，将里面所有一级文件和文件夹的路径放在File数组中返回
当主调是一个文件夹，且里面有隐藏文件时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏文件
当主调是一个文件夹，但是没有权限访问该文件夹时，返回null

SSM08-REST风格

Sat, 24 Jun 2023 14:00:00 GMT

详细的描述了Spring中的REST开发风格

REST简介

REST (Representational state Transfer)，表现形式状态转换

传统风格资源描述形式
- http://localhost/user/getById?id=1
- http://localhost/user/saveUser
REST风格描述形式
- http://localhost/user/1
- http://localhost/user
优点:
- 隐藏资源的访问行为，无法通过地址得知对资源是何种操作
- 书写简化
按照REST风格访问资源时使用行为动作区分对资源进行了何种操作
- http://localhost/users 查询全部用户信息 GET(查询)
- http://localhost/users/1 查询指定用户信息 GET(查询)
- http://localhost/users 添加用户信息 POST(新增/保存)
- http://localhost/users 修改用户信息 PUT(修改/更新)
- http://localhost/users/1 删除用户信息 DELETE(删除)
根据REST风格对资源进行访问称为 RESTful

注意事项
上述行为是约定方式，约定不是规范，可以打破，所以称REST风格，而不是REST规范
描述模块的名称通常使用复数，也就是加s的格式描述，表示此类资源，而非单个资源，例如: users、books、account..

样例

//设置当前请求方法为POST，表示REST风格中的添加操作
@RequestMapping(value = "/users",method = RequestMethod.POST)
@ResponseBody
public String save(){
    System.out.println("user save...");
    return "{'module':'user save'}";
}

//设置当前请求方法为DELETE，表示REST风格中的删除操作
//@PathVariable注解用于设置路径变量（路径参数），要求路径上设置对应的占位符，并且占位符名称与方法形参名称相同
@RequestMapping(value = "/users/{id}",method = RequestMethod.DELETE)
@ResponseBody
public String delete(@PathVariable Integer id){
    System.out.println("user delete..." + id);
    return "{'module':'user delete'}";
}

@RequestMapping

方法注解，SpringMVC控制器方法定义上方，设置当前控制器方法请求访问路径

属性

value (默认)：请求访问路径

method：http请求动作，标准动作(GET/POST/PUT/DELETE)

放在类上方时，即设置了公共路径

@RequestBody @RequestParam @Pathvariable

区别
- @RequestParam用于接收url地址传参或表单传参
- @RequestBody用于接收json数据
- @Pathvariable用于接收路径参数，使用{参数名称}描述路径参数
应用
- 后期开发中，发送请求参数超过1个时，以json格式为主，@RequestBody应用较广
- 如果发送非json格式数据，选用@RequestParam接收请求参数
- 采用RESTful进行开发，当参数数量较少时，例如1个，可以采用@PathVariable接收请求路径变量，通常用于传递id值

@RestController

类注解

@RestController = @ResponseBody + @Controller

@GetMapping @PostMapping @PutMapping @DeleteMapping

方法注解
基于SpringMVC的RESTful开发控制器方法定义上方
设置当前控制器方法请求访问路径与请求动作，每种对应一个请求动作，例如@GetMapping对应GET请求

注意直接访问页面会404，需要添加访问过滤，本来使用Tomcat负责，现在由SpringMVC拦截，需要放行

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;

@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/");
    }
}

SpringBoot基础原理

Fri, 23 Jun 2023 16:00:00 GMT

优先级(低→高)

application.yaml （忽略)
application.yml
application.properties
java系统属性(-Dxxx=xxx)
命令行参数(- -xxx=xxx)

获取Bean

默认情况下，Spring项目启动时，会把bean都创建好放在IOC容器中，如果想要主动获取这些bean，可以通过如下方式：
- 根据name获取bean：object getBean (String name)
- 根据类型获取bean： T getBean(ClasscrequiredType)
- 根据name获取bean(带类型转换): T getBean(String name，Class requiredType)

上述所说的【Spring项目启动时，会把其中的bean都创建好】还会受到作用域及延迟初始化影响，这里主要针对于默认的单例非延迟加载的bean而言。

Bean的作用域

作用域	说明
singleton	容器内同名称的bean只有一个实例(单例)（默认)
prototype	每次使用该 bean时会创建新的实例(非单例)
request	每个请求范围内会创建新的实例（web环境中，了解)
session	每个会话范围内会创建新的实例(web环境中，了解)
application	每个应用范围内会创建新的实例(web环境中，了解)

注意事项

默认singleton的bean，在容器启动时被创建，可以使用@Lazy注解来延迟初始化(延迟到第一次使用时）

prototype的bean，每一次使用该bean的时候都会创建一个新的实例。

实际开发当中，绝大部分的Bean是单例的，也就是说绝大部分Bean不需要配置scope属性。

第三方Bean

==@Bean==
==如果要管理的bean对象来自于第三方〈不是自定义的)，是无法用@Component及衍生注解声明bean的，就需要用到@Bean注解。==

Mybatis基础入门

Thu, 22 Jun 2023 16:00:00 GMT

Mybatis

MyBatis是一款优秀的持久层框架，==用于简化JDBC的开发。==

JDBC

JDBC：（Java DataBase Connectivity），就是使用ava语言操作关系型数据库的一套API。

sun公司官方定义的一套操作所有关系型数据库的规范，即接口。
各个数据库厂商去实现这套接口，提供数据库驱动jar包。
我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类。

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

@SpringBootTest //springboot整合单元测试的注解
class SpringbootMybatisQuickstartApplicationTests {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testListUser(){
        List<User> userList = userMapper.list();
        userList.stream().forEach(user -> {
            System.out.println(user);
        });
    }

    @Test
    public void testJdbc() throws Exception {
        //1. 注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");

        //2. 获取连接对象
        String url = "jdbc:mysql://localhost:3306/mybatis";
        String username = "root";
        String password = "1234";
        Connection connection = DriverManager.getConnection(url, username, password);

        //3. 获取执行SQL的对象Statement,执行SQL,返回结果
        String sql = "select * from user";
        Statement statement = connection.createStatement();
        ResultSet resultSet = statement.executeQuery(sql);

        //4. 封装结果数据
        List<User> userList = new ArrayList<>();
        while (resultSet.next()){
            int id = resultSet.getInt("id");
            String name = resultSet.getString("name");
            short age = resultSet.getShort("age");
            short gender = resultSet.getShort("gender");
            String phone = resultSet.getString("phone");

            User user = new User(id,name,age,gender,phone);
            userList.add(user);
        }

        //5. 释放资源
        statement.close();
        connection.close();
    }
}

MyBatis使用流程

1.准备工作(创建springboot工程、数据库表user、实体类User)
2.引入Mybatis的相关依赖，配置Mybatis
3.编写SQL语句(注解/XML)

数据库连接池

数据库连接池是个容器，负责分配、管理数据库连接(Connection)
它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个
释放空闲时间超过最大空闲时间的连接，来避免因为没有释放连接而引起的数据库连接遗漏

优点：

资源重用

提升系统响应速度

避免数据库连接遗漏

lombok

Lombok是一个实用的Java类库，能通过注解的形式自动生成构造器、getter/setter、equals、hashcode、toString等方法，并可以自动化生成日志变量，简化java开发、提高效率。

注解	作用
@Getter/ @Setter	为所有的属性提供get/set方法
@ToString	会给类自动生成易阅读的toString方法
@EqualsAndHashcode	根据类所拥有的非静态字段自动重写equals方法和 hashCode方法
@Data	提供了更综合的生成代码功能(@Getter + @Setter +@ToString +@EqualsAndHashCode)
@NoArgsConstructor	为实体类生成无参的构造器方法
@AllArgsConstructor	为实体类生成除了static修饰的字段之外带有各参数的构造器方法。

第一步：准备工作

准备好数据库表 Emp （员工表）
创建一个新的springboot工程，选择引入对应的起步依赖（mybatis、mysql驱动、lombok）
application.properties中引入数据库连接信息
创建对应的实体类Emp（实体类属性采用驼峰命名）
准备Mapper接口EmpMapper（加上Mapper接口）

第二步：先开发简单的增删改查Mapper

使用@Delete @Insert @Select

注意SQL语句中的占位符 #{变量名}

注意接口方法的返回值现在先可以自己定义，在后期会统一换成自己设定的Result类，确保返回给前端的数据解析方便

每次开发好一个接口方法时，进行测试，确保测试的覆盖率
application.properties配置mybatis的日志，指定输出到控制台

#配置mybatis的日志，指定输出到控制台
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdoutImpl

==注意变量名与pojo中一致，表示获取实体类的属性==

预编译SQL

为什么java会使用预编译的SQL语句？

性能更高

更安全（防止SQL注入）

java项目在执行SQL语句时的步骤

缓存

SQL语法解析检查

优化SQL

编译SQL

执行SQL

为什么性能更高呢？

例如：

delete from emp where id = 1;

delete from emp where id = 2;

delete from emp where id = 3;

上述三条不进行预编译会缓存编译三次

预编译如下添加占位符：

delete from emp where id = ?

1 2 3

缓存编译一次

为什么更安全呢？

SQL注入是通过操作输入的数据来修改事先定义好的SQL语句，以达到执行代码对服务器进行攻击的方法

解决了SQL注入

例如正常的账号 wang 密码 123456

SQL语句：select conut(*) from emp where username = ‘wang’ and password = ‘123456’;

SQL注入攻击：

账号：whatever 密码 ‘ or ’1‘ = ’1

SQL语句：select conut(*) from emp where username = ‘whatever’ and password = ‘==‘ or ’1‘ = ’1==’;

上述语句必然成立，达到了攻击的效果

预编译SQL：

SQL语句：select count(*) from emp where username =? and password = ?

参数传递，避免了SQL注入

==使用预编译SQL语句（#{}）==
==使用拼接SQL语句（${}）==

如何拿到主键值？

正常的属性方法getId无法拿到主键值，需要使用注解

@Options(keyProperty=“id”, useGeneratedKeys=true)

useGeneratedKeys=true代表我们需要拿到主键，keyProperty=‘Id’表示我们需要将主键封装的emp的Id中去

数据封装

实体类属性名和数据库表查询返回的字段名一致，mybatis会自动封装。
实体类属性名和数据库表查询返回的字段名不一致，不能自动封装。

如何封装

1.为字段不同的字段起别名，就是SQL中的as起别名，将别名与实体类属性名一致即可
2.通过@Results，@Result注解手动映射封装（不建议）

@Results({
	@Result(column = "dept_id", property = "deptId" ),
	@Result(column = "create_time", property = "createTime")
    @Result(column = "update_time", property = "updateTime")
})

3.开启Mybatis驼峰命名映射开关（==建议，但是要确保开发时的命名规范==）

application.properties配置mybatis的驼峰命名映射开关

#开启mybatis的驼峰命名自动映射开关a_column ------> aCloumn
mybatis.configuration.map-underscore-to-camel-case=true

注意${}的使用时机

{}不能出现在引号中，所以类似于SQL中的like ‘%#{name}%’ 这类模糊匹配需要改为

like ‘%${name}%’ ==性能低，存在SQL注入攻击问题==
concat(‘%’, #{name}, ‘%’) ==性能高，更安全==

XML映射文件

规范

XML映射文件的名称与Mapper接口名称一致，并且将XML映射文件和Mapper接口放置在相同包下(同包同名)
XML映射文件的namespace属性为Mapper接口全限定名一致。
XML映射文件中sql语句的id与Mapper接口中的方法名一致，并保持返回类型一致。

原理示意：Mapper 代理通过接口全限定名对应 XML 的 namespace，通过方法名对应语句 id。执行时绑定参数，再把查询结果封装为实体或集合；列名与属性名不一致时，需要别名、显式映射或开启驼峰映射，不能仅靠文件同名完成结果转换。

动态SQL

标签	作用
\ \	用于判断条件是否成立。使用test属性进行条件判断，如果条件为true，则拼接SQL
\\	where 元素只会在子元素有内容的情况下才插入where子句。而且会自动去除子句的开头的AND或OR。
\\	动态地在行首插入SET关键字，并会删掉额外的逗号。(用在update语句中)
\\	collection:遍历的集合 <br>item:遍历出来的元素 <br>separator:分隔符 <br>open:遍历开始前拼接的SQL工片段 <br>close:遍历结束后拼接的SQL片段
\\	抽取相同的SQL片段
\\	引用SQL片段

VIM基础教程

Tue, 20 Jun 2023 16:00:00 GMT

1、vim 三种基本的工作模式

vim有三种基本的工作模式，分别为：命令模式、末行模式、编辑模式。关于这三种工作模式的介绍，请见下文。

1.1、命令模式

使用vim打开文件之后，首先进入命令模式，它是vim编辑器的入口模式。在命令模式下，通过使用命令对文件进行常规的编辑操作，例如：复制、粘贴、删除、定位、翻页等等。

1.2、末行模式

末行模式是vim编辑器的出口，要退出vim，必须要在末行模式下。在末行模式下，执行退出文件、保存并退出文件等操作。

1.3、编辑模式

正常的编辑文字模式。

2、三种模式的切换操作

（1）vim打开一个文件进入的就是命令模式，另外两种模式需要回到命令模式才能进入彼此。

（2）在命令模式中按下i，I，o，O，a，A，r，R任何一个字母后进入编辑模式，进入编辑模式后，下方会出现INSERT或者REPLACE字样，按Esc键退出编辑模式，回到命令模式。

（3）在命令模式中按下:，/，?中任意一个即可进入末行模式，末行模式可以对文档或者vim环境进行操作，例如查找、读取、存盘、替换、离开、显示行号等。

3、各种模式切换

普通模式 - - NORMAL - - ———> 插入模式 - - INSERT - -

insert
- i 在光标前插入
- I 在行首插入
open a new line
- o 在下一行插入
- O 在上一行插入
append
- a 在光标后插入
- A 在行尾插入

普通模式 - - NORMAL - - <——— 插入模式 - - INSERT - -

ESC
jj / CapsLock

普通模式 - - NORMAL - - ———> 可视模式 - - VISUAL - -

普通模式 - - NORMAL - - <——— 可视模式 - - VISUAL - -

普通模式 - - NORMAL - - ———> 命令模式

普通模式 - - NORMAL - - <——— 命令模式

总结

先区分输入内容与执行命令：普通模式下按键用于移动和编辑，不会直接写入文本；按 i 进入插入模式后才开始输入正文，按 Esc 回到普通模式。若不确定当前状态，先按 Esc 再执行下一步，比连续尝试不同按键更容易判断行为。后续的移动、删除与复制示例，除非另有说明，都以普通模式为起点。

进入插入模式要先选好位置：i 在光标前插入，a 在光标后追加；I 移到当前行第一个非空白字符前插入，A 移到行尾追加。练习时在同一行分别尝试这些入口，输入少量文字后按 Esc，观察光标位置与文本变化。这里的大写和小写是不同命令，不能把 I 简单当作 i 的另一种写法。

需要新增一行时，在普通模式按 o 会在当前行下方打开新行并进入插入模式，按 O 则在上方打开新行。它们不同于只移动光标的命令，也不同于在原行内部插入字符；如果只是想定位到邻行，应使用移动命令。输入完成后按 Esc 返回普通模式，下一次按键才会继续作为编辑指令解释。

可视模式用于先选范围再执行操作：普通模式按 v 开始按字符选择，随后通过移动命令扩大或缩小选区，再决定复制、删除或修改。放弃当前选择时按 Esc 返回普通模式，不必执行破坏性操作来退出。要留意状态栏显示的模式，避免把选择阶段的移动按键误认为已经在插入正文。

普通模式按 : 进入命令行后，可以输入保存、退出或设置命令，按回车执行，按 Esc 取消本次命令输入。jj 或把 CapsLock 当作退出键并不是 Vim 原生的统一行为，它们需要相应映射或系统配置；迁移到新环境时先使用 Esc。单字符替换 r 也不同于持续输入的插入模式，不应把所有编辑入口混为一类。

4、光标移动

光标移动先从 h、j、k、l 开始：分别向左、下、上、右移动。可以在命令前加次数，例如 3j 向下移动三行，这里的数字属于移动次数，不会写入正文。移动只改变位置，不会删改文本；在普通模式熟悉方向后，再把相同的移动范围组合进删除或复制命令，能更清楚地判断操作影响。

按单词移动时，w 去下一个单词开头，b 返回当前或前一个单词开头，e 到当前或下一个单词结尾，ge 向后寻找前一个单词结尾。大写的 W、B、E 以空白分隔的较大文本块为单位，对包含标点的代码行尤其有区别。练习时把光标放在单词中间再比较各命令，注意起始位置会影响实际落点。

解释：

w : word
b : begin
e : end
ge : 不太常用

行内与文件级定位分开记忆：0 到行的第一个字符，^ 到第一个非空白字符，$ 到行尾；gg 到文件首行，G 到末行，nG 或 ngg 到指定行号。处理有缩进的代码时，0 与 ^ 的落点不同，前者包含缩进位置。先准确到行，再用单词或字符查找细调，通常比重复逐字符移动更容易控制。

当前行内查找字符可用 f{字符} 向前落在目标字符上，t{字符} 向前停在目标字符之前；大写 F 与 T 反向查找。按 ; 沿原方向重复，按 , 反向重复，不需要重新输入目标字符。跨越更大文本结构时，可以使用 (、) 按句子移动，或 {、} 按段落边界移动，先分清搜索范围再选择命令。

字符	单词	行	跳转	句和段
h 左	w下一个单词开头	0 行首	f char 跳到char位置	( 到句首
j 下	b本单词或上一个单词开头	^ 行首非空字符	F char 反向	) 到句尾
k 上	e本单词或下一个单词结尾	$ 行尾	t char char前一位置	{ 到段首
l 右	ge上一个单词结尾	gg 首行	T char char后一位置	} 到段尾
	W长单词 E长单词 B长单词	G 尾行	; 重复上次的跳转
		ngg 第n行	, 反向查找上次的查找

5、动作 motion

移动命令描述从当前位置到目标位置的范围，文本对象则描述当前位置所属的一块结构。使用文本对象时通常先输入操作符或进入可视模式，再选择范围，例如 iw 表示单词内部，aw 包含单词及相关空白。把“要做什么”和“作用在哪一块”分开思考，能避免先手动选很长一段文本，再猜测是否漏选边界。

文本对象的 i 表示内部范围，a 通常连同外围分隔或相关空白一起选取。it 面向标签内部，is 面向句子内部，ip 面向段落内部；它们是操作范围，不是普通模式下任意单独敲击就会完成编辑的命令。可以先用 v 配合对象检查选区，再决定执行复制或修改；不同对象的边界规则不同，遇到嵌套结构时尤其要先确认范围。

it : inner tag
is : inner sentence
ip : inner paragraph

6、操作符

操作符按“操作 + 范围”组合：d 删除指定范围，c 删除后进入插入模式，y 复制范围；例如 yy 复制当前行，dd 删除当前行。p 是把寄存器内容放到当前位置之后的命令，不需要再跟一个移动范围。表中的 b、B 可用于特定括号文本对象，而不是通用操作符；e 在原生 Vim 中是移到单词结尾，不能当作默认全选命令。

操作符	说明
d(delete)	删除
c(change)	修改（删除并且进入插入模式）
y(yank)	复制
v(visual)	选中并且进入 VISUAL 模式
p(paste)	粘贴
b(bracket)	小括号的简写
B(Bracket)	大括号的简写
e(entire)	全选

7、大小写

大小写转换使用明确的操作范围：gU 把范围转为大写，gu 转为小写，g~ 切换大小写；例如 gUw 对当前移动范围执行大写转换，guu 将当前行转为小写。可视模式中先选定文本，再按 U 或 u 也能转换选区。普通模式单独的 u 是撤销，不是转小写；也不要把所有 g 前缀命令都理解成跳转，应按完整命令记忆。

‘g’ means goto
‘U’ means Uppercase
‘u’ 与上一个相反

Tips

gd : goto definition 跳转到定义
ctrl + o : 跳回
gh : goto (mouse) hover 鼠标悬浮
gt : goto tab 跳转下一个标签页
gT : 与上一个相反跳转上一个标签页
ngt / ngT : 跳转到第n个标签页

VSCode中的Vim

vscode中默认为space
S{Charactor} : 寻找某个字符
xxx : 详见配置

Motion Command	Description
`<leader><leader> s <char>`	Search character
`<leader><leader> f <char>`	Find character forwards
`<leader><leader> F <char>`	Find character backwards
`<leader><leader> t <char>`	Til character forwards
`<leader><leader> T <char>`	Til character backwards
`<leader><leader> w`	Start of word forwards
`<leader><leader> b`	Start of word backwards
`<leader><leader> l`	Matches beginning & ending of word, camelCase, after `_`, and after `#` forwards
`<leader><leader> h`	Matches beginning & ending of word, camelCase, after `_`, and after `#` backwards
`<leader><leader> e`	End of word forwards
`<leader><leader> ge`	End of word backwards
`<leader><leader> j`	Start of line forwards
`<leader><leader> k`	Start of line backwards
`<leader><leader> / <char>... <CR>`	Search n-character
`<leader><leader><leader> bdt`	Til character
`<leader><leader><leader> bdw`	Start of word
`<leader><leader><leader> bde`	End of word
`<leader><leader><leader> bdjk`	Start of line
`<leader><leader><leader> j`	JumpToAnywhere motion; default behavior matches beginning & ending of word, camelCase, after `_` and after `#`

<leader><leader> (2s|2f|2F|2t|2T) <char><char> and <leader><leader><leader> bd2t <char>char> are also available. The difference is character count required for search. For example, <leader><leader> 2s <char><char> requires two characters, and search by two characters. This mapping is not a standard mapping, so it is recommended to use your custom mapping.

surround

Surround Command	Description
`y s <motion> <desired>`	Add `desired` surround around text defined by `<motion>`
`d s <existing>`	Delete `existing` surround
`c s <existing> <desired>`	Change `existing` surround to `desired`
`S <desired>`	Surround when in visual modes (surrounds full selection)

Some examples:

"test" with cursor inside quotes type cs"' to end up with 'test'
"test" with cursor inside quotes type ds" to end up with test
"test" with cursor inside quotes type cs"t and enter 123> to end up with <123>test</123>

多光标功能

🖱️ Multi-Cursor Mode

:warning: Multi-Cursor mode is experimental. Please report issues in our feedback thread.

Enter multi-cursor mode by:

On OSX, cmd-d. On Windows, ctrl-d.
gb, a new shortcut we added which is equivalent to cmd-d (OSX) or ctrl-d (Windows). It adds another cursor at the next word that matches the word the cursor is currently on.
Running “Add Cursor Above/Below” or the shortcut on any platform.

Once you have multiple cursors, you should be able to use Vim commands as you see fit. Most should work; some are unsupported (ref PR#587).

Each cursor has its own clipboard.
Pressing Escape in Multi-Cursor Visual Mode will bring you to Multi-Cursor Normal mode. Pressing it again will return you to Normal mode.

vscode中可以使用 cmd + d 批量修改

vim中可以使用 gb 批量膝盖

将光标定位到终端

在settings.json添加如下快捷键

//由editor 转到 terminal
{
    "before": ["leader", "t"],
    "commands": ["workbench.action.terminal.focus"]
}

space + t 即可跳转到终端中

跳转Tab

进入命令模式 :

输入 tabn : tab next 即进入下一个标签页
输入 tabp : tab prev 即进入下一个标签页

MySQL11-InnoDB引擎02-事务原理

Sat, 10 Jun 2023 16:00:00 GMT

详细的描述了MySQL中的InnoDB引擎的事务原理。

事务回顾

事务

事务是一组操作的集合，它是一个不可分割的工作单位，事务会把所有的操作作为一个整体一起向系统提交或撤销操作请求，即这些操作要么同时成功，要么同时失败。

特性

原子性(Atomicity):事务是不可分割的最小操作单元，要么全部成功，要么全部失败。
一致性(Consistency) :事务完成时，必须使所有的数据都保持一致状态。
隔离性(lsolation)∶数据库系统提供的隔离机制，保证事务在不受外部并发操作影响的独立环境下运行。
持久性(Durability):事务一旦提交或回滚，它对数据库中的数据的改变就是永久的。

事务原理

原理示意：撤销信息支持失败时回滚，重做日志配合先写日志原则支持崩溃恢复，锁与多版本机制按隔离级别协调并发访问。数据一致性还依赖约束及正确的业务事务逻辑，并非重做日志单独实现。提交的持久性与刷盘策略有关，也不意味着每个修改过的数据页都已立即写回磁盘。

redolog(一致性)

重做日志，记录的是事务提交时数据页的物理修改，是用来实现事务的持久性。
该日志文件由两部分组成:重做日志缓冲(redo log buffer)以及重做日志文件(redo log file) ,前者是在内存中，后者在磁盘中。当事务提交之后会把所有修改信息都存到该日志文件中，用于在刷新脏页到磁盘,发生错误时,进行数据恢复使用。

undolog(原子性)

回滚日志，用于记录数据被修改前的信息，作用包含两个:提供回滚和MVCC(多版本并发控制)。
undo log和redo log记录物理日志不一样，它是逻辑日志。可以认为当delete一条记录时,undo log中会记录一条对应的insert记录，反之亦然，当update一条记录时，它记录一条对应相反的update记录。当执行rollback时，就可以从undo log中的逻辑记录读取到相应的内容并进行回滚。

Undo log销毁: undo log在事务执行时产生，事务提交时，并不会立即删除undo log，因为这些日志可能还用于MVCC。

Undo log存储: undo log采用段的方式进行管理和记录，存放在前面介绍的 rollback segment回滚段中，内部包含1024个undo log segment。

MySQL10-锁

Wed, 07 Jun 2023 10:00:00 GMT

详细的描述了MySQL中的锁。

概述

锁是计算机协调多个进程或线程并发访问某一资源的机制。在数据库中，除传统的计算资源(CPU、RAM、I/O)的争用以外，数据也是一种供许多用户共享的资源。如何保证数据并发访问的一致性、有效性是所有数据库必须解决的一个问题，锁冲突也是影响数据库并发访问性能的一个重要因素。从这个角度来说，锁对数据库而言显得尤其重要，也更加复杂。

全局锁

全局锁就是对整个数据库实例加锁，加锁后整个实例就处于只读状态，后续的DML的写语句，DDL语句，已经更新操作的事务提交语句都将被阻塞。
==其典型的使用场景是做全库的逻辑备份，对所有的表进行锁定，从而获取一致性视图，保证数据的完整性==

原理示意：持锁连接执行 FLUSH TABLES WITH READ LOCK 后，备份可以读取稳定的数据，而其他连接的相应写入和结构变更需要等待。备份结束应由持锁连接执行 UNLOCK TABLES。这是一条操作关系图，不表示实际等待时长；纯 InnoDB 的一致性事务备份是另一种方案。

flush tables with read lock; -- 加全局锁

mysqldump [-h192.168.xxx.xxx] -uroot -p123456 databasename > D:/xxx.sql  //数据备份 访问远程加 -h

unlock table; -- 释放锁

==数据库中加全局锁，是一个比较重的操作，存在以下问题:==

如果在主库上备份，那么在备份期间都不能执行更新，业务基本上就得停摆。
如果在从库上备份，那么在备份期间从库不能执行主库同步过来的二进制日志（binlog)，会导致主从延迟。

在InnoDB引擎中，我们可以在备份时加上参数—single-transaction 参数来完成不加锁的一致性数据备份。

mysqldump --single-transaction -uroot-p123456 Wang > Wang.sql

表级锁

表级锁，每次操作锁住整张表。锁定粒度大，发生锁冲突的概率最高，并发度最低。应用在MyISAM、InnoDB、BDB等存储引擎中。

对于表级锁，主要分为以下三类：

表锁
元数据锁（meta datallock，MDL)
意向锁

表锁

表共享读锁（read lock）
表独占写锁（wirte lock）

语法

加锁

lock tables 表名... read/write

释放锁

unlock tables / 客户端断开连接

读锁与写锁的特点

原理示意：针对同一张表，某连接持有显式表读锁时，其他连接仍可读，但写入需要等待；持有显式表写锁时，其他连接的读写都需要等待。此处讨论 LOCK TABLES，不是把普通 InnoDB 快照读当作共享行锁；图下方另列索引记录上共享锁与排他锁的兼容关系。

==读锁不会阻塞其他客户端的读，但是会阻塞写。写锁既会阻塞其他客户端的读，又会阻塞其他客户端的写。==

元数据锁(meta data lock, MDL)

==MDL加锁过程是系统自动控制，无需显式使用，在访问一张表的时候会自动加上。MDL锁主要作用是维护表元数据的数据一致性，在表上有活动事务的时候，不可以对元数据进行写入操作。主要作用是避免DML与DDL冲突，保证读写的正确性。==

在MySQL5.5中引入了MDL，当对一张表进行增删改查的时候，加MDL读锁(共享);当对表结构进行变更操作的时候，加MDL写锁(排他)。

对于SQL	锁类型	说明
lock tables xxx read / write	SHARED_READ_ONLY / SHARED_NO_READ_WRITE	/
select . select … lock in share mode	SHARE_READ	与SHARED_READ、SHARED_WRITE兼容，与EXCLUSIVE互斥
insert . update、delete、select … for update	SHARED_WRITE	与SHARED_READ、SHARED_WRITE兼容,与EXCLUSIVE互斥
alter table …	EXCLUSIVE	与其他的MDL都互斥

查看元数据锁

select object type,object schema,object_name,lock_type,lock_ duration from performance schema.metadata loacks;

意向锁

为了避免 DML 在执行时，加的行锁与表锁的冲突，在InnoDB中引入了意向锁，使得表锁不用检查每行数据是否加锁，使用意向锁来减少表锁的检查。

意向共享锁(IS)

==电语句select … lock in share mode添加。==

和与表锁共享锁(read)兼容，与表锁排它锁(write）互斥。

意向排他锁(IX)︰

==由insert、update、delete、select … for update添加。==

与表锁共享锁(read)及排它锁(write)都互斥。意向锁之间不会互斥。

查看意向锁和行锁加锁情况

select object schema,object_name,index_name,lock_type.lock mode,Jock_data from performance schema.data_locks;

行级锁

行级锁，每次操作锁住对应的行数据，锁定粒度最小，发生锁冲突的概率最低，并发度最高，应用在InnoDB引擎中。

InnoDB的数据是基于索引组织的，行锁是通过对索引上的索引项加锁来实现的，而不是对记录加的锁。对于行级锁，主要分为以下三类:

行锁(Record Lock)

锁定单个行记录的锁，防止其他事务对此行进行update和delete。在RC、RR隔离级别下都支持。

nnoDB实现了以下两种类型的行锁

共享锁(S)

允许一个事务去读一行，阻止其他事务获得相同数据集的排它锁。

排他锁(X)

允许获取排他锁的事务更新数据，阻止其他事务获得相同数据集的共享锁和排他锁。

兼容情况

锁类型	S(共享锁)	X(排它锁)
S(共享锁)	兼容	冲突
X(排它锁)	冲突	冲突

加锁情况

SQL	行锁类型	说明
INSERT …	排他锁	自动加锁
UPDATE …	排他锁	自动加锁
DELETE …	排他锁	自动加锁
SELECT(正常)	不加任何锁	/
SELECT … LOCK IN SHARE MODE	共享锁	需要手动在SELECT之后加LOCK IN SHARE MODE
SELECT … FOR UPDATE	排他锁	需要手动在SELECT之后加FOR UPDATE

行锁的注意事项

默认情况下，InnoDB在REPEATABLE READ事务隔离级别运行，InnoDB使用next-key锁进行搜索和索引扫描，以防止幻读。

针对唯一索引进行检索时，对已存在的记录进行等值匹配时，将会自动优化为行锁。
InnoDB的行锁是针对于索引加的锁，不通过索引条件检索数据，那么InnoDB将对表中的所有记录加锁，此时就会升级为表锁。

查看意向锁和行锁加锁情况

select object schema,object_name,index_name,lock_type.lock mode,Jock_data from performance schema.data_locks;

间隙锁(Gap Lock)与临键锁(Next-Key Lock)

锁定索引记录间隙（不含该记录)，确保索引记录间隙不变，防止其他事务在这个间隙进行insert，产生幻读。在RRP隔离级别下都支持。

行锁和间隙锁组合，同时锁住数据，并锁住数据前面的间隙Gap。在RR隔离级别下支持。

默认情况下，InnoDB 在 REPEATABLE READ事务隔离级别运行，InnoDB使用next-key锁进行搜索和索引扫描，以防止幻读。

索引上的等值查询(唯一索引)，给不存在的记录加锁时,优化为间隙锁。
索引上的等值查询(普通索引)，向右遍历时最后一个值不满足查询需求时，next-key lock退化为间隙锁。
索引上的范围查询(唯一索引) — 会访问到不满足条件的第一个值为止。

==注意：间隙锁唯一目的是防止其他事务插入间隙。间隙锁可以共存，一个事务采用的间隙锁不会阻止另一个事务在同一间隙上采用间隙锁。==

乐观锁与悲观锁

乐观锁：（Optimistic Locking）认为对同一数据的并发操作不会总发生，属于小概率事件，不用每次都对数据上锁，也就是不采用数据库自身的锁机制，而是通过程序来实现。在程序上，我们可以采用版本号机制或者时间戳机制实现。（在程序上进行实现）

版本号机制：设计一个版本字段 version，第一次读的时候，会获取 version 字段的取值。然后对数据进行更新或删除操作时，会执行UPDATE ... SET version=version+1 WHERE version=version。此时如果已经有事务对这条数据进行了更改，修改就不会成功。（先获取一个版本号，在后续进行更新删除操作时，确认版本号是否正确）
时间戳机制：与版本号机制一样，只不过这里叫做时间戳

悲观锁：认为会出现并发操作，使用数据库本身的锁机制

这里可以看到基本的使用场景：

乐观锁适合读操作比较多的场景
悲观锁适合写操作比较多的场景

解决死锁：乐观锁（治标不治本），MyISAM储存引擎，一次获取所有锁，就不会死锁，大粒度锁；

MySQL11-InnoDB引擎01-架构

Tue, 06 Jun 2023 16:00:00 GMT

详细的描述了MySQL中的InnoDB引擎的架构。

逻辑存储结构

原理示意：表空间组织存储页，索引使用段管理叶节点与非叶节点的空间，区由连续页构成，记录再组织在页内。默认页大小为十六千字节时，一个区包含六十四页；该关系不能无条件套到所有页大小配置，段也可以先分配零散页，长字段还可能引用溢出页。

架构

总架构

原理示意：缓冲池缓存数据页和索引页，日志缓冲区暂存重做记录。脏页经过相应保护路径写回表空间，而重做日志独立持久化，用于崩溃恢复。两条路径并不意味着提交时全部脏页已经落盘；更改缓冲、自适应哈希及不同表空间也不能混为同一种缓存文件。

内存结构

缓冲池

原理示意：读写请求访问的是缓冲池中的页，命中时直接使用，未命中时才需要从相应表空间装入。修改后的页成为脏页，之后由刷新机制写回数据文件，相关重做记录必须先满足持久化要求。缓冲池不是查询结果缓存，也不能仅凭这张关系图推断命中率、磁盘读取量或查询耗时。

更改缓冲区

更改缓冲区针对尚未在缓冲池中的、符合条件的非唯一二级索引页，暂存其索引项变更，等到页面被读入或后台合并时再应用。它不是缓存所有表行修改的通用队列，也不能替代重做日志。其内存部分占用缓冲池，持久化部分位于系统表空间；是否启用以及哪些操作可缓冲，取决于配置与索引条件。

自适应哈希

自适应哈希索引由 InnoDB 观察索引访问模式后，按需为经常访问的索引页建立内存中的辅助查找结构。它可能只涉及部分索引键前缀，不是把整棵索引永久转换成哈希表，也不是用户创建的一种独立哈希索引。原有树形索引仍然存在；是否受益、是否启用，应结合实际工作负载判断。

日志缓冲区

原理示意：日志缓冲区保存待写入磁盘的重做记录，而不是待刷新的完整数据页。日志写入与刷盘时机受提交及刷新策略控制，不能把日志仍在内存理解为已经具备断电后的持久性。下方的双写页路径是另一类保护：页落盘前，相关重做记录须先持久化。

磁盘结构

系统表空间与单个表文件空间

系统表空间与独立表空间的职责不同。系统表空间保存更改缓冲等共享结构，也可按布局容纳表和索引；独立表空间则把单表的数据与索引组织在对应文件中。innodb_file_per_table 控制新建表的默认布局，但不代表所有既有表都自动搬入独立文件；数据字典与双写区域的位置还需要结合具体版本判断。

通用表空间与撤销表空间与临时表空间

通用表空间允许多个表共享同一表空间，不能与一表一文件的布局混同。撤销表空间组织撤销日志，为事务回滚和一致性读重建历史版本提供信息；临时表空间则服务于相应临时表活动，不是保存持久业务行的替代位置。这几类名称表示用途与生命周期的差异，并不意味着每次更新都会向所有类型的文件各写一份相同数据。

双写缓冲区与重做日志

原理示意：启用完整双写保护时，脏页先进入双写区域，再写入数据文件的最终位置，以便在页写入中断时取得完整副本。重做日志则记录必要的修改，用于崩溃恢复；二者不是同一种日志，也不是把日志简单复制两遍。双写区域的具体文件位置随版本变化，图中不固定文件名和个数。

后台线程

后台工作把前台事务产生的状态逐步整理为可持续运行的存储结构：页面清理负责推动脏页刷新，清理历史版本的工作在旧版本不再被回滚或一致性读需要后回收相应信息，异步读写由相关后台机制协作处理。更改缓冲也可能延后合并；这些任务并非每次提交都同步执行完毕，不能从职责名称推断固定线程数或执行耗时。

MySQL09-视图

Tue, 06 Jun 2023 11:00:00 GMT

详细的描述了MySQL中的视图。

视图的简介

视图(View)是一种虚拟存在的表。视图中的数据并不在数据库中实际存在，行和列数据来自定义视图的查询中使用的表，并且是在使用视图时动态生成的。
通俗的讲，视图只保存了查询的SQL逻辑，不保存查询结果。所以我们在创建视图的时候，主要的工作在创建这条SQL查询语句上。

视图的语法

创建

CREATE [OR REPLACE] VIEW 视图名称 [(列名列表)] AS SELECT 语句[WITH[CASCADED|LOCAL] CHECK OPTION ]

查询

SHOW CREATE VIEW 视图名称; --查看创建视图语句
SELECT * FROM 视图名称.......; --查看视图数据

修改

-- 方式一
CREATE [OR REPLACE] VIEW 视图名称(列名列表)] AS SELECT语句 [WITH[CASCADED|LOCAL] CHECK OPTION]
-- 方式二
ALTER VIEW 视图名称(列名列表)] AS SELECT语句 [WITH[CASCADED|LOCAL] CHECK OPTION]

删除

DROP VIEW [IF EXISTS] 视图名称[视图名称] ...

视图的检查选项

当使用 WITH CHECK OPTION 子句创建视图时，My5QL会通过视图检查正在更改的每个行，例如插入，更新，删除，以使其符合视图的定义。

MySQL允许基于另一个视图创建视图，它还会检查依赖视图中的规则以保持一致性。为了确定检查的范围，mysql 提供了两个选项: CASCADED和LOCAL，默认值为CASCADED。

cascaded

WITH CASCADED CHECK OPTION 约束通过可更新视图执行的插入和更新：新行必须满足当前视图条件，并递归满足所依赖视图的条件，即使底层视图没有显式声明检查选项也要检查。未写检查范围关键字时默认为级联检查；它不是给删除操作附加同样的新行条件，也不会把虚拟视图变成保存查询结果的实体表。

local

WITH LOCAL CHECK OPTION 检查当前视图条件，并继续沿依赖关系处理底层视图自身的检查规则；底层视图若没有检查选项，就不强制检查它自己的条件，但仍继续向下递归。因此，局部检查不等于完全忽略所有底层检查，也不能绕过底层已声明的级联约束。这里关注的是插入和更新后行是否仍满足相应可见条件。

视图的更新

要使视图可更新，视图中的行与基础表中的行之间必须存在一对一的关系。如果视图包含以下任何一项，则该视图不可更新:

聚合函数或窗口函数(SUM()、MIN()、MAX()、COUNT()等)
DISTINCT
GROUP BY
HAVING
UNION 或者 UNION ALL

MySQL07-存储函数

Mon, 05 Jun 2023 15:50:00 GMT

详细的描述了MySQL中的存储函数。

存储函数

存储函数是有返回值的存储过程，存储函数的参数只能是IN类型的。

语法

CREATE FUNCTION 存储函数名称([参数列表])
RETURNS type [characteristic ...]
BEGIN
	--SQL语句
	RETURN ...;
END;

characteristic说明:
 + DETERMINISTIC:相同的输入参数总是产生相同的结果
 + NO SQL:不包含SQL语句。
 + READS SQL DATA:包含读取数据的语句，但不包含写入数据的语句。

样例

-- 存储函数
-- 计算从1到n的累加
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);

注意当未添加 deterministic 会产生如下bug：

此例中，函数仅按输入整数做累加，相同输入能确定相同结果，因此声明 DETERMINISTIC 有明确依据。若启用了二进制日志，且函数创建者信任设置保持严格，创建函数时未声明确定性、无数据访问或只读数据等特征，可能被拒绝。这里讨论的是创建阶段的日志安全限制，并非所有环境中省略确定性声明都会出错。

运行结果：

此例中，函数从传入的 100 开始，每轮先累加再递减，直到参数不再为正，最后通过 RETURN total 返回总和。由一至一百的等差求和可得 5050，因此 SELECT fun1(100) 读取的是这一标量值；这与存储过程中直接执行查询返回结果集的写法不同。

注意

存储函数必须要有返回值，而且参数只能是输入类型的参数，其过程实现完全可以被存储过程所代替。

因此存储函数的使用较少，这里仅做了解。

MySQL08-触发器

Mon, 05 Jun 2023 15:50:00 GMT

详细的描述了MySQL中的触发器。

触发器简介

简介

触发器是与表有关的数据库对象，指在 insert / update / delete 之前或之后，触发并执行触发器中定义的SQL语句集合。触发器的这种特性可以协助应用在数据库端确保数据的完整性，日志记录，数据校验等操作。

使用别名 OLD 和 NEW 来引用触发器中发生变化的记录内容，这与其他的数据库是相似的。

现在触发器还只支持行级触发（影响几行触发几次）

现在触发器不支持语句级触发（执行一条语句触发一次）

触发器类型	NEW 和 OLD
INSERT触发器	NEW表示将要或者已经新增的数据
UPDATE型触发器	OLD表示修改之前的数据，NEW表示将要或已经修改后的数据
DELETE型触发器	OLD表示将要或者已经删除的数据

语法

创建

CREATE TRIGGER trigger_name
BEFORE/AFTER INSERT/UPDATE/DELETE
ON tbl_name FOR EACH ROW --行级触发器
BEGIN
	trigger_stmt;
END;

查看

SHOW TRIGGERS;

删除

DROP TRIGGER [schema_name.]Jtrigger_name; --如果没有指定schema_name，默认为当前数据库。

INSERT 类型触发器样例

样例：

通过触发器记录 tb_user 表的数据变更日志，将变更日志插入到日志表user_logs中，包含增加，修改，删除；、、

建表语句如下：

create table user_logs(
  id int(11) not null auto_increment,
  operation varchar(20) not null comment '操作类型, insert/update/delete',
  operate_time datetime not null comment '操作时间',
  operate_id int(11) not null comment '操作的ID',
  operate_params varchar(500) comment '操作参数',
  primary key(`id`)
)engine=innodb default charset=utf8;

-- 插入数据时的触发器
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;

-- 插入数据
insert into tb_user(id, name, phone, email, profession, age, gender, status, createtime)
values (25,'Wang','99999999999','wang-nine@gmail.com','计科',19,'1','1',now());

运行结果：

此处的 SHOW TRIGGERS 用于查看当前数据库中已创建的触发器定义信息，重点核对名称、触发事件、关联表、触发时机与触发语句，而不是查看用户变更日志。目标定义是用户表上的逐行插入后触发器；但上方插入日志语句的拼接括号提前结束，须先修正列值数量不匹配的问题，不能仅凭这段文本认定创建已经成功。

此例的意图是：用户记录成功插入后，逐行触发器读取 NEW 中的新行字段，再向日志表写入操作类型、用户主键与描述。上方日志插入语句需要把邮箱、专业也纳入同一个拼接表达式，使值的数量与目标列一致。修正并成功创建后，插入的用户主键为 25，日志引用 NEW.id；日志自增编号和执行时间则由运行环境决定。

UPDATE 类型触发器样例

-- 更新数据时的触发器
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;

-- 查看触发器指令
show triggers;

-- 更新数据
update tb_user set age = 99 where id = 25;

运行结果：

此处查看触发器时，应核对更新触发器是否关联 tb_user、事件是否为更新、时机是否在更新之后，以及是否声明逐行执行。SHOW TRIGGERS 展示的是触发器元信息，不会展示某次更新前后的用户数据，也不等同于查询日志表；实际返回哪些定义取决于当前数据库中已成功创建的对象。

此例中，若主键为 25 的用户存在且年龄实际发生变化，更新后的 NEW.age 为 99，更新前的值则来自 OLD.age。不过触发器的日志拼接只包含主键、姓名、电话、邮箱和专业，并未记录年龄，所以这次年龄变化不会直接显示在描述字段里；两段文案还都写成了“更新前”，应与 OLD、NEW 的真实含义区分。

DELETE 类型触发器样例

-- 删除数据时的触发器
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, 'delete', now(), old.id, concat('插入的数据内容为: id = ', old.id, ' name = ', old.name, ' phone = ', old.phone,
     ' email = ', old.email, ' profession = ', old.profession));
end;

-- 查看触发器指令
show triggers;

-- 删除数据
delete from tb_user where id = 25;

运行结果：

此处的查看命令用于确认删除触发器的定义：事件为删除，时机在删除之后，并对每个被删除的用户行执行一次。删除场景只能从 OLD 读取原行字段，不存在删除后的新行可供 NEW 引用。查看定义不会删除用户，也不会直接返回删除操作写入日志表的内容。

此例中，删除语句针对主键为 25 的用户；若该行存在并成功删除，触发器就用 OLD 保存的原行字段生成删除日志，操作类型取字面量 delete。描述字符串虽然写着“插入的数据内容为”，并不改变它属于删除事件这一事实。若目标行不存在便没有相应的逐行触发，不能预设日志条数、自增编号或操作时间。

MySQL06-存储过程

Sun, 04 Jun 2023 14:30:00 GMT

详细的描述了MySQL中的存储过程。

存储过程介绍

简介

存储过程是事先经过编译并存储在数据库中的一段SQL语句的集合，调用存储过程可以简化应用开发人员的很多工作，减少数据在数据库和应用服务器之间的传输，对于提高数据处理的效率是有好处的。
存储过程思想上很简单，就是数据库SQL语言层面的代码封装与重用。

特点

封装，复用
可以接收参数，也可以返回数据
减少网络交互，效率提升

存储过程语法

创建

CREATE PROCEDURE 存储过程名称([参数列表])
BEGIN
	...SQL语句
END;

调用

CALL 名称([参数]);

查看

SELECT * FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUINE_SQHEMA = 'xxx';  --查询指定数据库的存储过程及状态信息

SHOW CREATE PROCEDURE 存储过程名称; --查询某个存储过程的定义

删除

DROP PROCEDURE [IF EXISTS] 存储过程名称;

注意

注意：在命令行中，执行创建存储过程的SQL时，需要通过关键字 delimiter 指定SQL语句的结束符。

可以设置为两个$$符号

delimiter $$

变量

系统变量

系统变量是MySQL服务器提供，不是用户定义的，属于服务器层面。分为全局变量（GLOBAL）、会话变量（SESSION）

查看系统变量

SHOW [SESSION|GLOBAL] VARIABLES; --查看所有系统变量

SHOW [SESSION|GLOBAL] VARIABLES LIKE ...; --可以通过LIKE模糊匹配方式查找变量

SELECT @@[SESSION|GLOBAL] 系统变量名; --查看指定变量的值

设置系统变量

SET [SESSION|GLOBAL] 系统变量名 = 值;

SET @@[SESSION|GLOBAL] 系统变量名 = 值;

注意:

如果没有指定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 表名;

使用

SELECT @var_name;

注意：

在MySQL中， = 既可以作为赋值，也可以作为比较，因此在赋值时建议使用 :=
用户定义的变量无需对其进行声明或初始化，只不过获取到的值为NULL.

局部变量

局部变量是根据需要定义的在局部生效的变量，访问之前，需要DECLARE声明。可用作存储过程内的局部变量和输入参数，局部变量的范围是在其内声明的BEGIN….END块。

声明

DECLARE 变量名变量类型 [DEFAULT ...];

赋值

SET 变量名 = 值;
SET 变量名 := 值;
SELECT 字段名 INTO 变量名 FROM 表名 ...;

存储过程

存储过程 - if 判断

语法

IF 条件1 THEN
	...
ELSE IF 条件2 THEN --可选
	...
ELSE --可选
	...
END IF;

无参数的存储过程样例

-- 判定分数对应的分数等级。
-- score >= 85分，等级为优秀。
-- score >= 60分且score < 85分，等级为及格。
-- score < 60分，等级为不及格。
create procedure p1()
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;

call p1();

运行结果：

此例中，局部变量 score 初始为 58，既不满足优秀分支，也不满足及格分支，因此进入最后的分支，将 result 设为“不及格”。过程末尾的 SELECT result 返回这一等级文本；这是根据分支与初值推导的含义，不涉及用户表中的数据。

参数

类型	含义	备注
IN	该类参数作为输入，也就是需要调用时传入值	默认
OUT	该类参数作为输出,也就是该参数可以作为返回值	/
INOUT	既可以作为输入参数,也可以作为输出参数	/

语法

CREATE PROCEDURE 存储过程名称 ([IN / OUT / INOUT 参数名 参数类型])
BEGIN
	--SQL语句
END;

有参数的存储过程样例

-- 根据传入(in)参数score，判定当前分数对应的分数等级，并返回(out)。
-- score >= 85分，等级为优秀。
-- score >= 60分且score < 85分，等级为及格。
-- score < 60分，等级为不及格。
create procedure p1(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 p1(68, @result);
select @result;

运行结果：

此例中，传入的分数为 68，未达到优秀阈值，但满足及格条件，因此输出参数 result 被赋为“及格”。调用结束后，输出值写入当前会话变量 @result，随后 SELECT @result 读取该等级；不要把输出参数与过程内部直接返回结果集混为一谈。

-- 将传入的 200分制的分数,进行换算,换算成百分制，然后返阿分数---> inout
create procedure p2(inout score double)
begin
    set score := score * 0.5;
end;

set @score = 163;
call p2(@score);
select @score;

运行结果：

此例中，@score 先设为 163，再作为输入输出参数传给过程。过程把分数乘以 0.5，按算术可得 81.5，并将新值写回同一个会话变量。随后的 SELECT @score 读取换算后的百分制分数，体现输入输出参数既接收值又带回修改值的作用。

存储过程 - Case

语法一

CASE case_value
	WHEN when_value1 THEN statement_list1
	[WHEN when_value2 THEN statement_Kist 2] ...
	[ELSE statement_list]
END CASE;

语法二

CASE
	WHEN search_condition1 THEN statement_list1
	[WHEN search_condition2 THEN statement_list2] ...
	[ELSE statemept tlist]
END CASE;

样例

-- 根据传入的月份，判定月份所属的季节（要求采用case结构)。
-- 1.1-3月份,为第一季度
-- 2.4-6月份，为第二季度
-- 3.7-9月份，为第三季度
-- 4.10-12月份，为第四季度
create procedure p3(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;
    select concat('您输入的月份为', month, '所属的季度为', result);
end;

call p3(4)

运行结果：

此例中，月份参数为 4，命中四月至六月的分支，因而将结果设为“第二季度”。末尾的字符串拼接表达式会形成“您输入的月份为4所属的季度为第二季度”。这里实际判断的是季度而不是气象季节；其余合法月份按各自区间分类，区间之外进入非法参数分支。

存储过程循环 - while

while循环是有条件的循环控制语句。满足条件后，再执行循环体中的SQL语句。

语法

#先判定条件，如果条件为true，则执行逻辑，否则，不执行逻辑
WHILE 条件 DO
	SQL逻辑...
END WHILE;

样例

-- 计算从1紧加到的值，n为传入的参数值。
-- 1. 定义局部变量，记录累加后的值
-- 2. 每新环一次,就会n进行减1,如果n减到0，则退出循环
create procedure p4(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 p4(10);

运行结果：

此例中，初始参数为 10、累计值为零，循环逐次把当前参数加入累计值，再将参数减一，直到退出。因此，从十累加到一可推导出 total = 55，末尾的 SELECT total 读取该累计值。这一输入下，先判断的循环、后判断的循环以及显式退出的循环可得到相同总和，但退出条件的检查位置不同。

存储过程循环 - repeat

repeat是有条件的循环控制语句，当满足条件的时候退出循环。

语法

#先执行一次逻辑，然后判定逻辑是否满足，如果满足，则退出。如果不满足，则继续下一次循环
REPEAT
	SQL逻辑 ...
	UNTIL 条件
END REPEAT;

样例

-- 计算从1紧加到的值，n为传入的参数值。
-- 1. 定义局部变量，记录累加后的值
-- 2. 每新环一次,就会n进行减1,如果n减到0，则退出循环
create procedure p5(in n int)
begin
    declare total int default 0;
    repeat
        set total := total + n;
        set n := n - 1;
    until n <= 0
    end repeat;
    select total;
end;

call p5(10);

运行结果：

存储过程循环 - loop

LOOP实现简单的循环，如果不在SQL逻辑中增加退出循环的条件，可以用其来实现简单的死循环。

OOP可以配合一下两个语句使用**

LEAVE：配合循环使用，退出循环。
ITERATE：必须用在循环中，作用是跳过当前循环剩下的语句，直接进入下一次循环。

语法

[begin_label:] LOOP
	SQL逻辑 ...
END LOOP [end_label];

LEAVE label; --退出指定标记的循环体
ITERATE label; --直接进入下一次循环

样例1

-- 计算从1紧加到的值,n为传入的参数值。
-- 1. 定义局部变量,记录累加后的值
-- 2. 每新环一次,就会n进行减1,如果n减到0，则退出循环   ---> leave xxx;
create procedure p6(in n int)
begin
    declare total int default 0;
    sum : loop
        if n <= 0 then
            leave sum;
        end if;

        set total := total + n;
        set n := n - 1;
    end loop;
    select total;
end;

call p6(10);

运行结果：

样例2

-- 计算从1到n之问的偶数累加的值，n为传入的参数值。
-- 1．定义局部变量，记录累加之后的值;
-- 2．每循环一次，就会对n进行-1，如果n减到0，则退出循环   ---> leave xxx
-- 3．如果当次累加的数据是奇数，则直接进入下一次循环   ---> iterate xxx
create procedure p7(in n int)
begin
    declare total int default 0;
    sum : loop
        if n <= 0 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;
    select total;
end;

call p7(10);

运行结果：

此例中，p7(10) 只累加十以内的正偶数。遇到奇数时，先把参数减一，再通过 ITERATE 跳过本轮余下语句；偶数则加入累计值。因而十、八、六、四、二之和为 30，最后的 SELECT total 读取该值；当参数降到零时，由 LEAVE 退出循环。

游标 - Cursor

游标（CURSOR）是用来存储查询结果集的数据类型，在存储过程和函数中可以使用游标对结果集进行循环的处理。

游标的使用包括游标的声明、OPEN、FETCH 和 CLOSE，其语法分别如下。

语法：

声明游标

DECLARE 游标名称 CURSOR FOR 查询语句;

打开游标

OPEN 游标名称;

获取游标记录

FETCH 游标名称 INTO 变量[变量];

关闭游标

CLOSE 游标名称;

样例

-- 游标
-- 根据传入的参数uage，来查询用户表tb_user中，所有的用户年龄小于等于uage的用户姓名(name)和专业（profession)，
-- 并将用户的姓名和专业插入到所创建的一张新表(id,name,profession)中

-- 逻辑
-- 1. 声明游标，存储查询到的结果集
-- 2. 准备：创建表结构
-- 3. 开启游标
-- 4， 获取游标中的记录
-- 5. 将记录插入到新的表中
-- 6. 关闭游标
create procedure p8(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;

call p8(30);

注意while的循环退出条件为true，即死循环，产生如下bug

此例中，游标读取年龄不大于三十的用户姓名和专业，但 WHILE TRUE 本身没有退出条件。结果集耗尽后，下一次 FETCH 会触发 NOT FOUND 条件（SQLSTATE '02000'）。按 MySQL 的处理器规则，正常产生的 NOT FOUND 在没有处理器时默认执行 CONTINUE，而不是 EXIT，所以过程不会自动退出控制流：它会继续执行后面的 INSERT，再次进入循环并执行下一次 FETCH。要结束循环，必须在过程中显式处理耗尽，例如像后面的改进例那样用退出型处理器捕获该条件并关闭游标；实际插入次数和最终表内容取决于运行时的游标与表状态，不能仅凭这段代码确定。

注意

普通变量的声明先与游标
循环中如何得知循环结束的条件？即游标什么时候遍历完？

条件处理程序

条件处理程序（Handler）可以用来定义在流程控制结构执行过程中遇到问题时相应的处理步骤。

语法

DECLARE handler_action HANDLER FOR condition_value [,condition_value] ... statement;

handler_action
	cONTINUE:继续执行当前程序
	EXIT:终止执行当前程序
condition_value
	SQLSTATE:sqlstate_value:状态码，如02000
	SQLWARNING:所有以01开头的SQLSTATE代码的简写
	NOT FOUND:所有以02开头的SQLSTATE代码的简写
	SQLEXCEPTION:所有没有被SQLWARNING 或 NOT FOUND捕获的SQLSTATE代码的简写

样例(改进了循环退出判断条件)

-- 游标
-- 根据传入的参数uage，来查询用户表tb_user中，所有的用户年龄小于等于uage的用户姓名(name)和专业（profession)，
-- 并将用户的姓名和专业插入到所创建的一张新表(id,name,profession)中

-- 逻辑
-- 1. 声明游标，存储查询到的结果集
-- 2. 准备：创建表结构
-- 3. 开启游标
-- 4， 获取游标中的记录
-- 5. 将记录插入到新的表中
-- 6. 关闭游标
create procedure p8(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 时关闭游标
    -- 也可以写为 declare exit handler for not found close u_cursor;
    declare exit handler for sqlstate '02000' 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;

call p8(30);

具体的详细的官方解释的状态码如下

MySQL官网文档状态码解释

HTML5+CSS301-HTML

Sat, 03 Jun 2023 16:00:00 GMT

第一天笔记

HTML

HTML超文本标记语言―—HyperText Markup Language。

超文本是什么? 链接
标记是什么? 标记也叫标签，带尖括号的文本

标签语法

标签成对出现，中间包裹内容
<>里面放英文字母(标签名)
结束标签比开始标签多/
拓展
- 双标签:成对出现的标签
- 单标签:只有开始标签，没有结束标签

基本骨架

html:整个网页
head:网页头部，用来存放给浏览器看的信息，例如CSS
- title:网页标题
body:网页主体，用来存放给用户看的信息，例如图片、文字

标签的关系

作用：明确标签的书写位置;让代码格式更整齐

父子关系（嵌套关系)
兄弟关系（并列关系)
代码格式
父子关系：子级标签换行且缩进(Tab键)
兄弟关系：兄弟标签换行要对齐

注释

排版标签，标题和段落

标题标签

一般用在新闻标题、文章标题、网页区域名称、产品名称等等。

标签名: h1 ~h6（双标签）

显示特点：

文字加粗
字号逐渐减小
独占一行（换行）

经验分享：

h1标签在一个网页中只能用一次
用来放新闻标题或网页的logo. h2~ h6没有使用次数的限制

段落标签

一般用在新闻段落、文章段落、产品描述信息等等。

标签名: p（双标签）

显示特点：

独占一行
段落之间存在间隙

换行和水平线标签

换行标签 \ （单标签）
水平线标签 \ （单标签）

文本格式化标签

作用：为文本添加特殊格式，以突出重点。常见的文本格式

加粗
倾斜
下划线
~~删除线~~
等等

标签名	效果
\\	加粗
\\	倾斜
\\	下划线
\\	删除线

标签名	效果
b	加错
i	倾斜
u	下划线
s	删除线

strong、em、ins、 del标签自带强调含义（语义），一般使用这一套

两个文本格式化标签是在一行显示

图像标签

作用：在网页中插入图片。

<img src="图片的url">

src用于指定图像的位置和名称，是的必须属性。

标签属性

属性	作用	说明
alt	替换文本	图片无法显示时显示的文字
title	提示文本	鼠标悬停在图片上时显示的文字
width	图片的宽度	值为数字，没有单位
height	图片的高度	值为数字，没有单位

属性名=”属性值”
属性写在尖括号里面，标签名后面，标签名和属性之间用空格隔开，不区分先后顺序

文件路径

路径分类：

相对路径：从当前文件位置出发查找目标文件
绝对路径：从盘符出发查找目标文件

相对路径写法：

. 当前文件所在文件夹
../ 当前文件上一级文件夹
/ 进入某个文件夹里面

绝对路径写法：

Windows 默认是\，其他系统是/，建议统一写为/

超链接标签

作用：点击跳转到其他页面。

注意：属性 target=”_blank” 表示新窗口跳转页面

经验分享：开发初期，不知道超链接的跳转地址，href属性值写#，表示空链接，不会跳转

音频标签

常见属性

属性	作用	特殊说明
src（必须属性）	音频URL	支持格式：MP3、Ogg、Wav
controls	展示音频控制面板	/
loop	循环播放	/
autoplay	自动播放	为了提升用户体验，浏览器一般会禁用自动播放

简写：属性名和属性值一样，可以进行简写，例如

<audio src="音频的url" contrils loop></audio>

视频标签

常见属性

属性	作用	特殊说明
src（必须属性）	视频URL	支持格式：MP4、WebM、Ogg
controls	展示音频控制面板	/
loop	循环播放	/
muted	静音播放	/
autoplay	自动播放	为了提升用户体验，浏览器支持在静音模式下自动播放

列表

作用：布局内容排列整齐的区域。

无序列表

作用：布局排列整齐的不需要规定顺序的区域。

标签：ul嵌套li，ul是无序列表，li是列表条目。

<ul>
	<li>第一项</li>
    <li>第二项</li>
    <li>第三项</li>
    ......
</ul>

注意：

ul标签里面只能包裹li标签
li标签里面可以包裹任何内容

有序列表

作用：布局排列整齐的需要规定顺序的区域。

标签：ol嵌套li，ol是有序列表，li是列表条目。

<ol>
	<li>第一项</li>
    <li>第二项</li>
    <li>第三项</li>
    ......
</ol>

注意：

ol标签里面只能包裹li标签
li标签里面可以包裹任何内容

定义列表

标签：dl嵌套dt和dd，dl是定义列表，dt是定义列表的标题，dd是定义列表的描述/详情。

<dl>
	<dt>列表标题</dt>
	<dd>列表描述/详情</dd>
    ......
</dl>

注意：

dl标签里面只能包裹li标签
dt和dd标签里面可以包裹任何内容

表格

表格标签

网页中的表格与Excel表格类似，用来展示数据。

标签:table嵌套tr，tr嵌套td / th。

标签名	说明
table	表格
tr	行
td	表头单元格
th	内容单元格

提示：在网页中，表格默认没有边框线，使用border属性可以为表格添加边框线。

表格结构标签

作用：用表格结构标签把内容划分区域，让表格结构更清晰，语义更清晰。

标签名	含义	特殊说明
thead	表格头部	表格头部内容
tbody	表格主体	主要内容区域
tfoot	表格底部	汇总信息区域

合并单元格

作用：将多个单元格合并成一个单元格，以合并同类信息

跨行合并
跨列合并

合并单元格的步骤：

1．明确合并的目标

2．保留最左最上的单元格，添加属性（取值是数字，表示需要合并的单元格数量）

跨行合并，保留最上单元格，添加属性rowspan
跨列合并，保留最左单元格，添加属性colspan

3．删除其他单元格

表单

input 标签的 type 属性不同，则功能不同

type属性值	说明
text	文本框，用于输入单行文本
password	密码框
radio	单选框
checkbox	多选框
file	上传文件

input 标签的占位文本：即为提示信息

<input type="xxx" placeholder="提示信息">

单选框 radio

常用属性

属性名	作用	说明
name	控件名称	控件功能，同时只能选中一个（单选功能）
checked	默认选中	属性名和属性值相同，简写为一个单词

上传文件 file

常用属性

属性名	作用	说明
multiple	多选文件	多选文件上传

多选框 checkedbox

常用属性

属性名	作用	说明
checked	默认选中	属性名和属性值相同，简写为一个单词

下拉菜单

标签：select嵌套option，select是下拉菜单整体，option是下拉菜单的每一项。

默认选中：selected

文本域

标签：textarea，双标签。

不用于input的text，这个会自动换行

有拖拽功能，一般会禁用

一般使用css设置尺寸

label 标签

作用：网页中，某个标签的说明文本

经验：用label标签绑定文字和表单控件的关系，增大表单控件的点击范围。

示例：增大单选框点击范围

写法1
- label标签只包裹内容，不包裹表单控件
- 设置label标签的for属性值和表单控件的id属性值相同
```
<input type="radio" id="man">
<label for="man">男</label>
```
写法2
- 使用label标签包裹文字和表单控件，不需要属性
```
<label><input type="radio">女</label>
```

注意：

outline: none 屬性可取消表单控件的焦点框
如何设置 placeholder 的文字属性呢？::placeholder 选中就是 placeholder 属性文字样式

按钮标签

<button type=""></button>

常用属性（记得使用form表单标签包裹使button发挥作用）

属性名	说明
submit	提交按钮，点击后可以提交数据到后台（默认功能）
reset	重置按钮，点击后可以将表单控件恢复默认值
button	普通按钮，默认没有功能，一般配合JavaScript使用

无语义的布局标签

作用：布局网页（划分网页区域，摆放内容）
- div（默认换行展示）大盒子
- span（不换行）小盒子

字符实体

作用：在网页中显示预留字符

显示结果	描述	实体名称
\&nbsp	空格	不换行空格
\<	小于	<
>	大于	>

在代码中敲的键盘的空格，在网页中只会被识别成一个空格

SSM07-SpringMVC的请求与响应

Sat, 03 Jun 2023 11:00:00 GMT

详细的描述了SpringMVC中的请求与响应

SpringMVC概述

SpringMVC是一种基于Java实现MVC模型的轻量级web框架

优点

使用简单，开发便捷（相比于Servlet）
灵活性强

样例

样例代码

使用SpringMVC技术需要先导入SpringMIVC坐标与Servlet坐标

<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
  <version>3.1.0</version>
  <scope>provided</scope>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>5.2.10.RELEASE</version>
</dependency>

创建SpringMvc控制器类（等同于servlet功能）

// 2.定义Controller
// 2.1 使用Controller定义Bean
@Controller
public class UserController {
    // 2.2 设置当前操作的访问路径
    @RequestMapping("/save")
    // 2.3 设置当前操作的返回值类型
    @ResponseBody
    public String save(){
        System.out.println("user save...");
        return "{'moudle' : 'springmvc'}";
    }
}

初始化SpringMVC环境(同Spring环境)，设定SpringMVC加载对应的bean

// 3.创建springmvc的配置文件，加载controller对应的Bean
@Configuration
@ComponentScan("com.wang.controller")
public class SpringMvcConfig {
}

初始化Servlet容器，加载SpringMVC环境，并设置SpringMVC技术处理的请求

// 4.定义一个Servlet容器启动的配置类，在里面加载spring的配置
public class ServletContainerInitConfig extends AbstractDispatcherServletInitializer {

    //加载springmvc容器配置
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringMvcConfig.class);
        return ctx;
    }

    //设置哪些请求归属springmvc处理
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    //加载spring容器配置
    protected WebApplicationContext createRootApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringConfig.class);
        return ctx;
    }
}

上述案例中用到的注解说明：

@Controller

类注解，放置于SpringMVC控制器定义上方，作用为设定SpringMVC的核心控制器Bean

@RequestMapping

方法注解，放置于SpringMVC控制器方法上方，作用为设定当前控制器方法的请求访问路径

@ResponseBody

方法注解，放置于SpringMVC控制器方法上方，作用为设置当前控制器方法的响应内容为当前返回值，无需解析

@ComponentScan

属性1：excludeFilters：排除扫描路径中加载的bean，需要指定类别(type)与具体项(classes)

属性2：includeFilters：加载指定的bean，需要指定类别(type)与具体项(classes)

SpringMVC入门程序开发总结（1+N）

一次性工作
- 创建工程，设置服务器，加载工程
- 导入坐标
- 创建web容器启动类，加载SpringMVC配置，并设置SpringMVC请求拦截路径
- SpringMvc核心配置类（设置配置类，扫描controller包，加载Controller控制器bean）
多次工作
- 定义处理请求的控制器类
- 定义处理请求的控制器方法，并配置映射路径（@RequestMapping）与返回json数据（@ResponseBody）

工作流程

启动服务器初始化过程

服务器启动，执行ServletcontainersInitConfig类，初始化web容器
执行createServletApplicationcontext方法，创建了webApplicationContext对象
加载SpringMvcConfig
执行@ComponentScan加载对应的bean
加载UserController，每个@RequestMapping的名称对应一个具体的方法
执行getServletMappings方法，定义所有的请求都通过springMVC

单次请求过程

发送请求localhost/save
web容器发现所有请求都经过SpringMVC，将请求交给SpringMVC处理
解析请求路径/save
由/save匹配执行对应的方法save()
执行save()
检测到有@ResponseBody直接将save()方法的返回值作为响应求体返回给请求方

问题

因为功能不同，如何避免Spring错误的加载到SpringMVC的bean？

加载Spring控制的bean的时候排除掉SpringMVC控制的bean

SpringMIVC相关bean(表现层bean)

Spring控制的bean

业务bean (Service)
功能bean (DataSource等)

SpringMVC相关bean加载控制

SpringMVC加载的bean对应的包均在com.xxx.controller包内

Spring相关bean加载控制

方式一：Spring加载的bean设定扫描范围为com.xxx，排除掉controller包内的bean
方式二： Spring加载的bean设定扫描范围为精准范围，例如service包、dao包等
方式三：不区分Spring与SpringMVC的环境，加载到同一个环境中

方式一如下：

@ComponentScan(value = "com.wang",
        excludeFilters = @ComponentScan.Filter(
                type = FilterType.ANNOTATION,
                classes = Controller.class
        ))

方式二如下：

@ComponentScan({"com.wang.service", "com.wang.dao"})

注意：简化开发代码如下：

public class ServletContainerInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

请求

设置请求的映射路径

团队多人开发，每人设置不同的请求路径，冲突问题如何解决？

设置模块名作为请求路径前缀

@RequestMapping(“/xxx”)

当写在类上方时，即为统计设置请求路径的前缀，类方法中的@RequestMapping会自动加上前缀

PostMan发送get请求和post请求

get请求

普通参数：url地址传参，地址参数名与形参变量名相同，定义形参即可接收参数

post请求

普通参数：form表单post请求传参，表单参数名与形参变量名相同，定义形参即可接收参数

post请求中文乱码问题：

为web容器添加过滤器并指定字符集，Spring-web包中提供了专用的字符过滤器

//乱码处理
@override
protected Filter[] getServletFilters(){
	CharacterEncodingFilter filter = new CharacterEncodingFilter();
    filter.setEncoding("UTF-8");
	return new Filter[](filter);
}

参数种类

若传入的属性名与实体类中的属性名一致，则会自动放入实体类中

样例代码：

//请求参数
@Controller
public class UserController {

    //普通参数：请求参数与形参名称对应即可完成参数传递
    @RequestMapping("/commonParam")
    @ResponseBody
    public String commonParam(String name ,int age){
        System.out.println("普通参数传递 name ==> "+name);
        System.out.println("普通参数传递 age ==> "+age);
        return "{'module':'common param'}";
    }

    //普通参数：请求参数名与形参名不同时，使用@RequestParam注解关联请求参数名称与形参名称之间的关系
    @RequestMapping("/commonParamDifferentName")
    @ResponseBody
    public String commonParamDifferentName(@RequestParam("name") String userName , int age){
        System.out.println("普通参数传递 userName ==> "+userName);
        System.out.println("普通参数传递 age ==> "+age);
        return "{'module':'common param different name'}";
    }

    //POJO参数：请求参数与形参对象中的属性对应即可完成参数传递
    @RequestMapping("/pojoParam")
    @ResponseBody
    public String pojoParam(User user){
        System.out.println("pojo参数传递 user ==> "+user);
        return "{'module':'pojo param'}";
    }

    //嵌套POJO参数：嵌套属性按照层次结构设定名称即可完成参数传递
    @RequestMapping("/pojoContainPojoParam")
    @ResponseBody
    public String pojoContainPojoParam(User user){
        System.out.println("pojo嵌套pojo参数传递 user ==> "+user);
        return "{'module':'pojo contain pojo param'}";
    }

    //数组参数：同名请求参数可以直接映射到对应名称的形参数组对象中
    @RequestMapping("/arrayParam")
    @ResponseBody
    public String arrayParam(String[] likes){
        System.out.println("数组参数传递 likes ==> "+ Arrays.toString(likes));
        return "{'module':'array param'}";
    }

    //集合参数：同名请求参数可以使用@RequestParam注解映射到对应名称的集合对象中作为数据
    @RequestMapping("/listParam")
    @ResponseBody
    public String listParam(@RequestParam List<String> likes){
        System.out.println("集合参数传递 likes ==> "+ likes);
        return "{'module':'list param'}";
    }


    //集合参数：json格式
    //1.开启json数据格式的自动转换，在配置类中开启@EnableWebMvc
    //2.使用@RequestBody注解将外部传递的json数组数据映射到形参的集合对象中作为数据
    @RequestMapping("/listParamForJson")
    @ResponseBody
    public String listParamForJson(@RequestBody List<String> likes){
        System.out.println("list common(json)参数传递 list ==> "+likes);
        return "{'module':'list common for json param'}";
    }

    //POJO参数：json格式
    //1.开启json数据格式的自动转换，在配置类中开启@EnableWebMvc
    //2.使用@RequestBody注解将外部传递的json数据映射到形参的实体类对象中，要求属性名称一一对应
    @RequestMapping("/pojoParamForJson")
    @ResponseBody
    public String pojoParamForJson(@RequestBody User user){
        System.out.println("pojo(json)参数传递 user ==> "+user);
        return "{'module':'pojo for json param'}";
    }

    //集合参数：json格式
    //1.开启json数据格式的自动转换，在配置类中开启@EnableWebMvc
    //2.使用@RequestBody注解将外部传递的json数组数据映射到形参的保存实体类对象的集合对象中，要求属性名称一一对应
    @RequestMapping("/listPojoParamForJson")
    @ResponseBody
    public String listPojoParamForJson(@RequestBody List<User> list){
        System.out.println("list pojo(json)参数传递 list ==> "+list);
        return "{'module':'list pojo for json param'}";
    }

    //日期参数
    //使用@DateTimeFormat注解设置日期类型数据格式，默认格式yyyy/MM/dd
    @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'}";
    }
}

总结

普通的形参

若形参与请求参数名称相同，则会自动绑定

@RequestParam

可以绑定请求参数与处理器方法形参之间的关系

参数：required:是否为必传参数 defaultValue:参数默认值

Pojo参数

请求参数名与形参对象属性名相同，定义PO30类型形参即可接收参数

嵌套的Pojo参数

请求参数名与形参对象属性名相同，按照对象层次结构关系即可接收嵌套POJo属性参数

数组参数

请求参数名与形参对象属性名相同且请求参数为多个，定义数组类型形参即可接收参数

集合保存普通参数

请求参数名与形参集合对象名相同且请求参数为多个，@RequestParam绑定参数关系

json 数据参数

四个步骤：

pom.xml中添加json坐标

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.0</version>
</dependency>

主配置类中加入注解

@EnableWebMvc

开启由json对象装换位对象的功能

postman中传入参数
在参数前面加上@RequestBody

json数组

["game","music","hobby"]

json对象(Pojo)

{
	"name":"wang",
    "age":15,
	"address":{
		"province":"beijing",
        "city":"beijing"
    }
}

json数组(Pojo)

[
    {"name":"wang","age":9},
    {"name":"nine","age":99}
]

@RequestBody与@RequestParam区别

区别
- @RequestParam用于接收url地址传参，表单传参【application/x-www-form-urlencoded】
- @RequestBody用于接收json数据【application/json】
应用
- 后期开发中，发送json格式数据为主，@RequestBody应用较广
- 如果发送非json格式数据，选用@Requestparam接收请求参数

日期格式参数

@DateTimeFormat(patter=“yyyy-MM-dd”)

指定日期的格式

类型转换器

Convert接口

public interface Converter<S, T> {
    @Nullable
    T convert(S var1);
}

响应

响应页面
响应数据
- 文本数据
- json数据

样例代码：

@Controller
public class UserController {

    //响应页面/跳转页面
    //返回值为String类型，设置返回值为页面名称，即可实现页面跳转
    @RequestMapping("/toJumpPage")
    public String toJumpPage(){
        System.out.println("跳转页面");
        return "page.jsp";
    }

    //响应文本数据
    //返回值为String类型，设置返回值为任意字符串信息，即可实现返回指定字符串信息，需要依赖@ResponseBody注解
    @RequestMapping("/toText")
    @ResponseBody
    public String toText(){
        System.out.println("返回纯文本数据");
        return "response text";
    }

    //响应POJO对象
    //返回值为实体类对象，设置返回值为实体类类型，即可实现返回对应对象的json数据，需要依赖@ResponseBody注解和@EnableWebMvc注解
    @RequestMapping("/toJsonPOJO")
    @ResponseBody
    public User toJsonPOJO(){
        System.out.println("返回json对象数据");
        User user = new User();
        user.setName("itcast");
        user.setAge(15);
        return user;
    }

    //响应POJO集合对象
    //返回值为集合对象，设置返回值为集合类型，即可实现返回对应集合的json数组数据，需要依赖@ResponseBody注解和@EnableWebMvc注解
    @RequestMapping("/toJsonList")
    @ResponseBody
    public List<User> toJsonList(){
        System.out.println("返回json集合数据");
        User user1 = new User();
        user1.setName("Tom");
        user1.setAge(15);

        User user2 = new User();
        user2.setName("Jerry");
        user2.setAge(12);

        List<User> userList = new ArrayList<User>();
        userList.add(user1);
        userList.add(user2);

        return userList;
    }
}

@ResponseBody

方法注解，SpringMVC控制器方法定义上方，设置当前控制器方法响应内容为当前返回值，无需解析

内部是由类型转换器 HttpMessageConverter 接口发挥作用

SSM06-Spring中的事务

Sat, 03 Jun 2023 10:00:00 GMT

详细的描述了Spring中的事务概念。

事务的简介

事务作用：在数据层保障一系列的数据库操作同成功同失败
Spring事务作用：在数据层或业务层保障一系列的数据库操作同成功同失败

如何开启事务管理？

步骤如下：

在业务层接口上添加Spring事务管理

public interface xxxxx {
    @Transactional
    public void xxx {
        代码体
    }
}

注意事项：
Spring注解式事务通常添加在业务层接口中而不会添加到业务层实现类中，降低耦合
注解式事务可以添加到业务方法上表示当前方法开启事务，也可以添加到接口上表示当前接口所有方法开启事务

设置事务管理器

@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource){
	DataSourceTransactionManager ptm = new DataSourceTransactionManager();
    ptm.setDataSource(dataSource);
	return ptm;
}

在主配置类中开启事务型驱动添加如下注解：

@EnableTransactionmanagement

Spring事务角色

事务角色

事务管理员

发起事务方，在Spring中通常指代业务层开启事务的方法

事务协调员

加入事务方，在Spring中通常指代数据层方法，也可以是业务层方法

事务属性

属性	作用	实例
readOnly	设置是否为只读事务	readOnly = true 只读事务
timeout	设置事务的超过时间	timeout = -1 永不超时
rollbackFor	设置事务回滚异常(class)	rollbackFor = (NullPointException.class)
rollbackForClassName	设置事务回滚异常(String)	同上格式为字符串
noRollbackFor	设置事务不回滚异常(class)	noRollbackFor = (NullPointException.class)
noRollbackForClassName	设置事务不回滚异常(String)	同上格式为字符串
propagation	设置事务传播行为	…

事务传播行为：事务协调员对事务管理员所携带事务的处理态度

原理示意：已有事务时，REQUIRED 加入同一个物理事务，REQUIRES_NEW 挂起外层并新建独立事务，NESTED 在支持时使用同一事务内的保存点。没有外层事务时，这三种通常都开启事务；SUPPORTS、MANDATORY、NEVER 与 NOT_SUPPORTED 则分别决定是否加入、是否强制存在或排除事务。传播描述的是调用边界的处理方式，需经过事务代理且由具体事务管理器支持。

SSM05-Spring中的AOP概念

Tue, 30 May 2023 13:00:00 GMT

详细的描述了Spring中的AOP概念。

AOP简介

基础概念

AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构

OOP(object Oriented Programming)面向对象编程

作用：在不惊动原始设计的基础上为其进行功能增强

Spring理念：无入侵式/无侵入式

核心概念

连接点 ( JoinPoint )：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等

在SpringAOP中，理解为方法的执行
切入点 ( Pointcut )：匹配连接点的式子
- 在springAoP中，一个切入点可以只描述一个具体方法，也可以匹配多个方法
  - 一个具体方法: com.itheima.dao包下的BookDao接口中的无形参无返回值的save方法
  - 匹配多个方法:所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法

通知(Advice) ：在切入点处执行的操作，也就是共性功能

在SpringAOP中，功能最终以方法的形式呈现

通知类∶定义通知的类
切面( Aspect )︰描述通知与切入点的对应关系

样例（源自黑马程序员，侵删）

原理示意：连接点是可匹配的方法执行，切入点描述哪些方法需要增强，通知实现要加入的共性功能，切面把二者绑定。调用者使用容器提供的代理，代理组织通知与目标方法的执行，目标对象仍保留原始业务职责。是否经过代理是重要边界，同一对象内部的 this 调用不会自动再次触发代理增强。

AOP入门案例

案例设定:测定接口执行效率
简化设定:在接口执行前输出当前系统时间
开发模式:XML or 注解

思路分析∶

导入坐标（ pom.xml )
制作连接点方法（原始操作，Dao接口与实现类）
制作共性功能（通知类与通知)
定义切入点
绑定切入点与通知关系（切面)

基础代码样例（源自黑马程序员）：

导入坐标

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.2.10.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.9.4</version>
</dependency>

切面类

@Component
@Aspect
public class MyAdvice {

    @Pointcut("execution(切入点表达式)")
    private void pt(){}

    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("------------------------------");
        Long startTime = System.currentTimeMillis();
        for (int i = 0 ; i<10000 ; i++) {
            //调用原始操作
            pjp.proceed();
        }
        Long endTime = System.currentTimeMillis();
        Long totalTime = endTime-startTime;
        System.out.println("执行万次消耗时间：" + totalTime + "ms");
        return null;
    }

}

主配置类

加上注解 @EnableAspectJAutoProxy

剩余的代码不变，例如Dao接口和实现类，主函数

以上步骤总结：

导入AOP坐标
定义dao接口与实现类
定义通知类，制作通知
定义切入点 说明︰切入点定义依托一个不具有实际意义的方法进行，即无参数，无返回值，方法体无实际逻辑
绑定切入点与通知关系，并指定通知添加到原始连接点的具体执行位置
定义通知类受Spring容器管理，并定义当前类为切面类，即添加 @Component 和 @Aspect
开启Spring对AOP注解驱动支持，即在主配置类添加 @EnableAspectJAutoProxy

AOP工作流程

Spring容器启动
读取所有切面配置中的切入点
初始化bean，判定bean对应的类中的方法是否匹配到任意切入点

匹配失败：创建对象
匹配成功：创建原始对象（目标对象）的代理对象

获取bean的执行方法

获取bean，调用方法并执行，完成操作
获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作
目标对象（Target ）：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的
代理（Proxy）：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现

AOP深入

AOP的切入点表达式

切入点∶要进行增强的方法
切入点表达式∶要进行增强的方法的描述方式

语法格式

即可以对接口进行描述，也可以对实现类进行描述

切入点表达式标准格式

动作关键字（访问修饰符返回值.包名.类/接口名.方法名（参数）异常名)

execution (public User com.xxx.service.UserService.findById (int))

动作关键字∶描述切入点的行为动作，例如execution表示执行到指定切入点
访问修饰符：public , private等，可以省略
返回值
包名
类/接口名
方法名
参数
异常名：方法定义中抛出指定异常，可以省略

可以使用通配符描述切入点，快速描述

- ︰单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现
execution (public com.xxx..UserService.find*(*))
匹配com.xxx包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法
.. ：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写

execution (public User com..UserService.findById (..) )
匹配com包下的任意包中的UserService类或接口中所有名称为findByld的方法
+︰专用于匹配子类类型
execution(..Service+.(..))

切入点表达式的书写技巧

所有代码按照标准规范开发，否则以下技巧全部失效
描述切入点通常描述接口，而不描述实现类
访问控制修饰符针对接口开发均采用public描述（可省略访问控制修饰符描述）
返回值类型对于增删改类使用精准类型加速匹配，对于查询类使用*通配快速描述
包名书写尽量不使用..匹配，效率过低，常用*做单个包描述匹配，或精准匹配
接口名/类名书写名称与模块相关的采用*匹配，例如UserService书写成*Service，绑定业务层接口名
方法名书写以动词进行精准匹配，名词采用匹配，例如getByld书写成getBy,selectAll书写成selectAll
参数规则较为复杂，根据业务方法灵活调整
通常不使用异常作为匹配规则

AOP通知类型

AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置AOP通知共分为5种类型

前置通知 @Before
后置通知 @After
环绕通知（重点） @Around****需要对原始操作进行调用
返回后通知（了解） @AfterReturning 正常运行完才会运行
抛出异常后通知（了解） @AfterThrowing 抛出异常才会运行

环绕通知对原始操作的调用样例（注意有返回值时需要返回原始操作的返回值）：

public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("around before advice ...");
        Object ret = pjp.proceed();
        System.out.println("around after advice ...");
        return ret;
    }

@Around注意事项

环绕通知必须依赖形参ProceedingJoinPoint才能实现对原始方法的调用，进而实现原始方法调用前后同时添加通知
通知中如果未使用ProceedingJoinPoint对原始方法进行调用将跳过原始方法的执行
对原始方法的调用可以不接收返回值，通知方法设置成void即可，如果接收返回值，必须设定为Object类型
原始方法的返回值如果是void类型，通知方法的返回值类型可以设置成void，也可以设置成Object
由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必须抛出Throwable对象

signature signature = pjp.getsignature();	//获取代理类和被代理类的信息。
system.out.println(signature.getDeclaringTypeName());	//获取原始方法的类名
system.out.println(signature.getName());	//获取原始方法的方法名

AOP通知获取数据

获取参数

获取切入点方法的参数

JoinPoint :适用于前置、后置、返回后、抛出异常后通知
ProceedJointPoint :适用于环绕通知

获取返回值

获取切入点方法返回值

返回后通知
环绕通知

获取异常

获取切入点方法运行异常信息

抛出异常后通知
环绕通知

样例代码如下（来自黑马程序员，侵删）

原理示意：普通通知可通过 JoinPoint 读取方法参数，环绕通知使用 ProceedingJoinPoint，并以 proceed() 调用后续执行链。正常返回与抛出异常是不同分支，分别由返回后通知和异常后通知接收数据；环绕通知若接收了原始结果，应把结果返回给调用者。图中不规定多个切面的执行次序。

MySQL05-SQL优化

Mon, 29 May 2023 07:00:00 GMT

详细的描述了MySQL中的SQL语句的优化。

MySQL语句优化

插入数据优化

批量插入

客户端连接服务端时，加上参数

—local-infilemysql —local-infile -u root -p

设置全局参数local_infile为，开启从本地加载文件导入数据的开关

set global local_infile = 1;

执行load指令将准备好的数据，加载到表结构中

load data local infile ‘/root/sql1.log’ into table ‘table’ fields terminated by ‘,’ lines terminated by ‘\n’;

手动提交事务

主键顺序插入

主键顺序插入性能高于乱序插入

主键优化

数据组织方式

在InnoDB存储引擎中，表数据都是根据主键顺序组织存放的，这种存储方式的表称为索引组织表(index organized table IOT)。

页分裂

页可以为空，也可以填充一半，也可以填充100%。每个页包含了2-N行数据(如果一行数据多大，会行溢出)，根据主键排列。
主键乱序插入

页合并

当删除一行记录时，实际上记录并没有被物理删除，只是记录被标记（flaged)为删除并且它的空间变得允许被其他记录声明使用。
当页中删除的记录达到MERGE_THRESHOLD(默认为页的50%)，InnoDB会开始寻找最靠近的页（前或后）看看是否可以将两个页合并以优化空间使用。

主键设计原则

满足业务需求的情况下，尽量降低主键的长度。

插入数据时，尽量选择顺序插入，选择使用AUTO_INCREMENT自增主键。

尽量不要使用UUID做主键或者是其他自然主键，如身份证号。

order by 语句优化

Using flesort

通过表的索引或全表扫描，读取满足条件的数据行，然后在排序缓冲区sort buffer中完成排序操作，所有不是通过索引直接返回排序结果的排序都叫FileSort排序。

Using index

通过有序索引顺序扫描直接返回有序数据，这种情况即为using index，不需要额外排序，操作效率高。

优化原则

根据排序字段建立合适的索引，多字段排序时，也遵循最左前缀法则。

尽量使用覆盖索引。

多字段排序,一个升序一个降序，此时需要注意联合索引在创建时的规则(ASC/DESC)。

如果不可避免的出现filesort，大数据量排序时，可以适当增大排序缓冲区大小 sort_buffer_size(默认256k)。

group by 语句优化

优化原则

在分组操作时，可以通过索引来提高效率。

分组操作时，索引的使用也是满足最左前缀法则的。

limit 语句优化

一个常见又非常头疼的问题就是limit 20000000,10，此时需要MySQL排序前2000010记录，仅仅返回2000000 - 2000010的记录，其他记录丢弃，查询排序的代价非常大。

优化原则

一般分页查询时，通过创建覆盖索引能够比较好地提高性能，可以通过覆盖索引加子查询形式进行优化。

count 语句优化

MylSAM引擎把二个表的总行数存在了磁盘上，因此执行count()的时候会直接返回这个数，效率很高
InnoDB引擎就麻烦了，它执行count()的时候，需要把数据一行一行地从引擎里面读出来，然后累积计数

优化原则：自己计数

count (主键)

InnoDB引擎会遍历整张表，把每一行的主键id值都取出来，返回给服务层。服务层拿到主键后，直接按行进行累加(主键不可能为null)

count (字段) 没有not null约束: InnoDB引擎会遍历整张表把每一行的字段值都取出来，返回给服务层，服务层判断，不为null，计数累加。有not null约束: InnoDB引擎会遍历整张表把每一行的字段值都取出来，返回给服务层，直接按行进行累加。

count (1) InnoDB引擎遍历整张表，但不取值。服务层对于返回的每一行，放一个数字“1”进去，直接按行进行累加。

count (*) lnnoDB引擎并不会把全部字段取出来，而是专门做了优化，不取值，服务层直接按行进行累加。

按照效率排序的话，count(字段):xcount(主键id)< count(1) = count()，所以尽量使用count()。

update 语句优化(避免行级锁变为表级锁)

优化原则

InnoDB的行锁是针对索引加的锁，不是针对记录加的锁,并且该索引不能失效，否则会从行锁升级为表锁。

MySQL优化总结

插入数据

insert:批量插入、手动控制事务、主键顺序插入
大批量插入: load data local infile

主键优化

主键长度尽量短、顺序插入
AUTO_INCREMENT ~~UUID~~

order by优化

using index:直接通过索引返回数据，性能高
using filesort:需要将返回的结果在排序缓冲区排序

group by优化

索引，多字段分组满足最左前缀法则

limit优化

覆盖索引+子查询

count优化

性能: count(字段) < count(主键id) < count(1) < count(*)

update优化

尽量根据主键/索引字段进行数据更新

SSM04-Spring整合MyBatis

Sat, 27 May 2023 11:00:00 GMT

详细的描述了Spring整合myBatis和Spring整合Junit。

Spring整合myBatis

正常的mybatis核心代码如下：

public class App {
    public static void main(String[] args) throws IOException {
        
//----------------------------------------------------------------------------------------------------//
        // 1. 创建SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        // 2. 加载SqlMapConfig.xml配置文件
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml.bak");
        // 3. 创建SqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
//---------------------------------  一、初始化SqlSessionFactory对象   ----------------------------------//

        // 4. 获取SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 5. 执行SqlSession对象执行查询，获取结果User
        AccountDao accountDao = sqlSession.getMapper(AccountDao.class);

//---------------------------------  二、获取连接，获取实现   --------------------------------------------//

        Account ac = accountDao.findById(2);
        System.out.println(ac);

//---------------------------------  三、获取数据层接口   -----------------------------------------------//

        // 6. 释放资源
        sqlSession.close();

//---------------------------------  四、关闭连接   ----------------------------------------------------//
    }
}

那么上述的代码需要将那个核心对象放入IoC中进行管理呢

SqlSessionFactory 最核心

原来的整合方法

xml配置：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="jdbc.properties"></properties>
    <typeAliases>
        <package name="com.itheima.domain"/>
    </typeAliases>
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"></property>
                <property name="url" value="${jdbc.url}"></property>
                <property name="username" value="${jdbc.username}"></property>
                <property name="password" value="${jdbc.password}"></property>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <package name="com.itheima.dao"></package>
    </mappers>
</configuration>

主函数：

即上述的mybatis核心代码

注意：xml配置与配置类的写法一一对应，原来的配置文件被新的配置类所代替，如下位配置类。

更改后的

配置类：

import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

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;
    }
}

注意在主配置类中添加当前配置类的扫描

注意：第二种方法中 pom.xml 新增两个坐标

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>5.2.10.RELEASE</version>
</dependency>

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>1.3.0</version>
</dependency>

主函数：

import com.itheima.config.SpringConfig;
import com.itheima.domain.Account;
import com.itheima.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class App2 {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

        AccountService accountService = ctx.getBean(AccountService.class);

        Account ac = accountService.findById(1);
        System.out.println(ac);
    }
}

Spring整合Junit

新增依赖

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>test</scope>
</dependency>

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>5.2.10.RELEASE</version>
</dependency>

测试样例：

package com.itheima.service;

import com.itheima.config.SpringConfig;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
//设置类运行器
@RunWith(SpringJUnit4ClassRunner.class)
//设置Spring环境对应的配置类
@ContextConfiguration(classes = SpringConfig.class)
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环境对应的配置类：@ContextConfiguration(classes = SpringConfig.class)

想用什么用@Autowired自动注入即可

MySQL04-索引03-使用规则

Sat, 27 May 2023 07:00:00 GMT

详细的描述了MySQL中的索引的使用规则和设计原则。

使用规则

联合索引

最左前缀法则

如果索引了多列(联合索引)，要遵守最左前缀法则。最左前缀法则指的是查询从索引的最左列开始，并且不跳过索引中的列。如果跳跃某一列，索引将部分失效(后面的字段索引失效)。

范围查询

联合索引中，出现范围查询(>,<)，范围查询右侧的列索引失效

索引失效

索引列运算

不要在索引列上进行运算操作,索引将失效。

字符串不加引号

字符串类型字段使用时，不加引号，索引将失效。会在内部自动进行隐式类型转换。

模糊查询

如果仅仅是尾部模糊匹配，索引不会失效。如果是头部模糊匹配，索引失效。

or连接的条件

用or分割开的条件，如果or前的条件中的列有索引，而后面的列中没有索引，那么涉及的索引都不会被用到。

解决办法：针对另一个数据列也建立索引即可

数据分布影响

如果MysQL评估使用索引比全表更慢，则不使用索引。

SQL提示

SQL提示，是优化数据库的一个重要手段，简单来说，就是在SQL语句中加入一些人为的提示来达到优化操作的目的。

放在where条件前，use/ignore/force index(索引名)

use index: 建议使用索引，数据库可以选择不使用

ignore index: 忽略某个索引

force index: 强制使用某个索引

覆盖索引

尽量使用覆盖索引（查询使用了索引，并且需要返回的列，在该索引中已经全部能够找到)，减少select *。

尽量避免回表查询

extra中：
using index condition :查找使用了索引,但是需要回表查询数据
using where; using index:查找使用了索引，但是需要的数据都在索引列中能找到，所以不需要回表查询数据

前缀索引

当字段类型为字符串(varchar, text等）时，有时候需要索引很长的字符串，这会让索引变得很大，查询时，浪费大量的磁盘IO，影响查询效率。此时可以只将字符串的一部分前缀，建立索引，这样可以大大节约索引空间，从而提高索引效率。

语法：
create index idx_xxx on table_name(column(n)) ; - - n为前缀长度

前缀长度的选择：
可以根据索引的选择性来决定，选择性是指不重复的索引值（基数）和数据表的记录总数的比值，索引选择性越高则查询效率越高，
唯一索引的选择性是1，这是最好的索引选择性，性能也是最好的。
可以使用聚合函数查询选择性
select count(distinct substring(xxx,1,5))/ count(*) from table ; - - 即长度为5的选择性

单列/联合索引

单列索引与联合索引

单列索引:即一个索引只包含单个列。

联合索引:即一个索引包含了多个列。

在业务场景中，如果存在多个查询条件，考虑针对于查询字段建立索引时，建议建立联合索引，而非单列索引。

多条件联合查询时，MySQL优化器会评估哪个字段的索引效率更高，会选择该索引完成本次查询。

索引设计原则（总结自黑马程序员，侵删）

索引设计原则

针对于数据量较大，且查询比较频繁的表建立索引。

针对于常作为查询条件（where)、排序(order by)、分组(group by)操作的字段建立索引。

尽量选择区分度高的列作为索引，尽量建立唯一索引，区分度越高，使用索引的效率越高。

如果是字符串类型的字段，字段的长度较长，可以针对于字段的特点，建立前缀索引。

尽量使用联合索引，减少单列索引，查询时，联合索引很多时候可以覆盖索引，节省存储空间，避免回表，提高查询效率。

要控制索引的数量，索引并不是多多益善，索引越多，维护索引结构的代价也就越大，会影响增删改的效率。

如果索引列不能存储NULL值，请在创建表时使用NOT NULL约束它。当优化器知道每列是否包含NULL值时，它可以更好地确定哪个索引最有效地用于查询。

==模型数空运最快==

模：字符串的模糊匹配

型：数据类型

数：索引字段使用函数会失效

空：不限制索引 not null

运：对索引列进行运算失效

最：最左前缀法则

快：全表比索引快，则不适用

Hexo-Butterfly主题博客搭建03

Thu, 25 May 2023 07:00:00 GMT

Hexo-Butterfly主题博客搭建02

Wed, 24 May 2023 07:00:00 GMT

Hexo+Butterfly主题博客搭建02 ——— 下载有关butterfly主题并进行配置

Butterfly主题的安装

在 hexo 项目根目录下执行操作clone主题

git clone -b master https://github.com/jerryc127/hexo-theme-butterfly.git themes/butterfly

如果沒有 pug 以及 stylus 的渲染器，还需要下载，否则在项目运行时会报错：

npm install hexo-renderer-pug hexo-renderer-stylus --save

修改项目根目录下的_config.yml文件（称为站点配置文件），开启主题

# extensions
## plugins: https://hexo.io/plugins/
## themes: https://hexo.io/themes/
#theme: landscape
theme: butterfly

升级建议

为了減少升级主题带来的不便，我们还需要做以下操作：
把主题文件夹中的 _config.yml 复制到 hexo 根目录下，同重命名为 _config.butterfly.yml

hexo会自动合并主题中的 _config.yml 和 _config.butterfly.yml 里的配置，如果存在同名配置，会使用 _config.butterfly.yml 的配置，其优先度较高。

butterfly主题

MySQL4-索引02-性能分析

Wed, 24 May 2023 06:00:00 GMT

详细的描述了MySQL中的索引的性能分析。

索引创建的语法

创建索引

CREATE [UNIQUE|FULLTEXT] INDEX index_name ON table_name ( index_col_name … ) ;

查看索引

SHOW INDEX FROM table_name ;

删除索引

DROP INDEX index_name ON table_name ;

性能分析

SQL执行频次

MySQL客户端连接成功后，通过show [session] global status 命令可以提供服务器状态信息。通过如下指令，可以查看当前数据库的INSERT、UPDATE、DELETE、SELECT的访问频次:
SHOW GLOBAL STATUS LIKE ‘Com**__**‘；
注：Com后面六个下划线即为INSERT、UPDATE、DELETE、SELECTINSERT、UPDATE、DELETE、SELECT等单词的长度。

慢查询日志

慢查询日志记录了所有执行时间超过指定参数 (long_query_time，单位:秒，默认10秒) 的所有SQL语句的日志。

MySQL的慢查询日志默认没有开启，需要在MySQL的配置文件 (/etc/my.cnf) 中配置如下信息:

开启MySQL慢日志查询开关

slow_query_log=1

设置慢日志的时间为2秒，SQL语句执行时间超过2秒，就会视为慢查询，记录慢查询日志

long_query_time=2

配置完毕之后，通过以下指令重新启动MySQL服务器进行测试，查看慢日志文件中记录的信息/var/lib/mysql/localhost-slow.log

profile详情

show profiles能够在做SQL优化时帮助我们了解时间的具体耗费。通过have_profiling参数，能够看到当前MySQL是否支持profile操作

SELECT @@have_profiling;

默认profiling是关闭的，可以通过set语句在session/global级别开启profiling

SET profiling = 1;

(重要！！！)explain执行计划

EXPLAIN 或者 DESC 命令获取MySQL如何执行SELECT语句的信息，包括在SELECT语句执行过程中表如何连接和连接的顺序。

语法：

直接在select语句之前加上关键字explain / desc

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

explain执行计划中包含的信息如下：

id: 查询序列号
select_type: 查询类型
table: 表名或者别名
partitions: 匹配的分区
type: 访问类型
possible_keys: 可能用到的索引
key: 实际用到的索引
key_len: 索引长度
ref: 与索引比较的列
rows: 估算的行数
filtered: 按表条件筛选的行百分比
Extra: 额外信息

一、id列

select查询的序列号(一组数字)，表示查询中执行select子句或者操作表的顺序。
id列分为三种情况：

如果id相同，那么执行顺序从上到下
如果id不同，如果是子查询，id的序号会递增，id值越大优先级越高，越先被执行
id相同和不同的，同时存在，同时满足以上两种规则即可。

二、select_type列

复制代码主要用来分辨查询的类型，是普通查询还是联合查询还是子查询

sample: 简单的查询，不包含子查询和union
primary: 查询中若包含任何复杂的子查询，最外层查询则被标记为Primary
union: 在union，union all和子查询中的第二个和随后的select被标记为union
dependent union: 在包含UNION或者UNION ALL的大查询中，如果各个小查询都依赖于外层查询的话，那除了最左边的那个小查询之外，其余的小查询的select_type的值就是DEPENDENT UNION。
union result: 从union表获取结果的select。
subquery: 在select或者where列表中包含子查询（不在from子句中）
dependent subquery: 子查询中的第一个select（不在from子句中），而且取决于外面的查询。
derived: 在FROM列表中包含的子查询被标记为DERIVED，也叫做派生类
UNCACHEABLE SUBQUERY：一个子查询的结果不能被缓存，必须重新评估外链接的第一行对于外层的主表，子查询不可被物化，每次都需要计算（耗时操作）
uncacheable union: 表示union的查询结果不能被缓存：没找到具体的sql语句验证

三、table列

对应行正在访问哪一个表，表名或者别名，可能是临时表或者union合并结果集.

如果是具体的表名，则表明从实际的物理表中获取数据，当然也可以是表的别名.
表名是derivedN的形式，表示使用了id为N的查询产生的衍生表.
当有union result的时候，表名是union n1,n2等的形式，n1,n2表示参与union的id.

四，type列

type是访问类型，访问类型表示以何种方式去访问我们的数据，
访问类型很多，效率从最好到最坏是：
NULL > system > const > eq_ref > ref > fulltext > ref_or_null > index_merge > unique_subquery > index_subquery > range > index > ALL

all: 全表扫描，需要扫描整张表，从头到尾找到需要的数据行。一般情况下出现这样的sql语句而且数据量比较大的话那么就需要进行优化。
index：全索引扫描这个比all的效率要好，主要有两种情况，一种是当前的查询时覆盖索引，即我们需要的数据在索引中就可以索取，或者是使用了索引进行排序，这样就避免数据的重排序
range：表示利用索引查询的时候限制了范围，在指定范围内进行查询，这样避免了index的全索引扫描，适用的操作符：=, <>, >, >=, <, <=, IS NULL, BETWEEN, LIKE, or IN()
index_subquery：利用索引来关联子查询，不再扫描全表但是大多数情况下使用SELECT子查询时，MySQL查询优化器会自动将子查询优化为联表查询，因此 type 不会显示为 index_subquery,而是ref
unique_subquery: 该连接类型类似于index_subquery,使用的是唯一索引。大多数情况下使用SELECT子查询时，MySQL查询优化器会自动将子查询优化为联表查询，因此 type 不会显示为 index_subquery,而是eq_ref
index_merge：在查询过程中需要多个索引组合使用.
ref_or_null：对于某个字段即需要关联条件，也需要null值的情况下，查询优化器会选择这种访问方式.
ref：使用了非唯一性索引进行数据的查找
eq_ref ：当进行等值联表查询使用主键索引或者唯一性非空索引进行数据查找(实际上唯一索引等值查询type不是eq_ref而是const)
const：最多只能匹配到一条数据，通常使用主键或唯一索引进行等值条件查询
system：表只有一行记录（等于系统表），这是const类型的特例，平时不会出现,不需要进行磁盘io
NULL：直接显示，例如 SELECT ‘A’ ，一般业务不可能优化为NULL

五、possible_keys列

显示可能应用在这张表中的索引，一个或多个，查询涉及到的字段上若存在索引，则该索引将被列出，但不一定被查询实际使用。

六、key列

实际使用的索引，如果为null，则没有使用索引，查询中若使用了覆盖索引，则该索引和查询的select字段重叠。

七、key_len列

表示索引中使用的字节数，可以通过key_len计算查询中使用的索引长度，在不损失精度的情况下长度越短越好。
索引越大占用存储空间越大，这样io的次数和量就会增加，影响执行效率

八、ref列

显示之前的表在key列记录的索引中查找值所用的列或者常量

九、rows列

根据表的统计信息及索引使用情况，大致估算出找出所需记录需要读取的行数，此参数很重要，直接反应的sql找了多少数据，在完成目的的情况下越少越好。

十、filtered列

针对表中符合某个条件(where子句或者联接条件)的记录数的百分比所做的一个悲观估算。

十一、extra列

包含额外的信息。

using filesort: 说明mysql无法利用索引进行排序，只能利用排序算法进行排序，会消耗额外的资源
using temporary: 建立临时表来保存中间结果，查询完成之后把临时表删除
using index: 这个表示当前的查询是覆盖索引的，直接从索引中读取数据，而不用访问数据表。如果同时出现using where 表名索引被用来执行索引键值的查找，如果没有，表面索引被用来读取数据，而不是真的查找
using where: 使用where进行条件过滤
using join buffer: 使用连接缓存
impossible where：where语句的结果总是false

SSM03-Spring的纯注解开发模式

Tue, 23 May 2023 17:03:00 GMT

详细的描述了Spring中的注解开发。

注解开发定义Bean

步骤：

1.使用@Component定义Bean

以下两种方式都可以定义Bean

@Component(“Bean的名称”)

@Component

其中第一种方式可以使用 ctx.getBean(“名称”)

其中第二种方式只能使用 ctx.getBean(“类型.class”) 因为没有指定名称

2.核心配置文件中通过组件扫描加载Bean

<context:component-scan base-package="wang"/> <!-- 递归扫描 wang -->

注意：

Spring提供@Component注解的三个衍生注解

@controller：用于表现层bean定义
@service：用于业务层bean定义.
@Repository：用于数据层bean定义

样例代码：

impl实现类：

package wang.dao.impl;

import org.springframework.stereotype.Component;
import wang.dao.Dao;

@Component("dao")
public class DaoImpl implements Dao {
    @Override
    public void save() {
        System.out.println("Dao save() ...");
    }
}

xml配置文件：

<?xml version="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
            ">

    <context:component-scan base-package="wang"/>

</beans>

主函数：

package wang;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import wang.dao.Dao;

public class App4 {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml.bak");
        Dao dao = (Dao) ctx.getBean("dao");
        dao.save();
    }
}

运行结果：

DaoImpl 上的 @Component 注解显式提供 dao 这个 Bean 名称，XML 中对 wang 包的组件扫描负责发现这个类并注册它。主函数从容器按 dao 取出对象后调用 save()，展示的是注解定义对象、XML 保留扫描入口的组合方式。需要特别核对资源名：示例主函数读取 applicationContext.xml.bak，实际保存的配置文件必须与这个名称一致，否则还没有进入业务方法就会在加载配置阶段失败。

纯注解开发模式

Spring3.0升级了纯注解开发模式，使用Java类替代配置文件，开启了Spring快速开发赛道

如何取消配置文件呢，使用一个配置类来代替配置文件

package wang.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("wang")
public class SpringConfig {

}

注意：

@ComponentScan(“wang”) 代替了中间的组件扫描器的功能

@Configuration代替了 xml 配置文件中的其他配置，如下图：

原理示意：@Configuration 把 SpringConfig 声明为配置类，@ComponentScan 指定扫描 wang 包，表达原来 XML 的包扫描入口；两种路径都能发现标注组件的 DaoImpl。切换为纯注解时，容器入口也应改为读取配置类。这里对应的是本例的组件扫描配置，不代表加一个注解就能自动搬走全部 XML 功能，其他配置仍需逐项转换。

注意：ComponentScan({“wang.xxx01”, “wang.xxx02”}) 可以扫描多个类

主函数中需要改变一行代码：

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

改为：

ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

此时删除xml配置文件运行结果相同：

主函数改用 AnnotationConfigApplicationContext(SpringConfig.class) 后，容器从配置类读取扫描范围，不再靠原来的 XML 文件寻找 DaoImpl。只要扫描范围包含带组件注解的实现类，注册名称仍与获取方式对应，原来获取 Bean 并调用 save() 的职责就可以保持不变。验证纯注解切换时，应确认配置类与扫描结果完整，而不是仅凭删除 XML 后的一段提示语判断所有配置都已经迁移。

Bean的管理

Bean的作用范围

@Scope(“prototype”)即可更改

Bean的生命周期

如下代码：

实现类：

package wang.dao.impl;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import wang.dao.Dao;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
@Scope("singleton")
public class DaoImpl implements Dao {
    @Override
    public void save() {
        System.out.println("Dao save() ...");
    }

    @PostConstruct
    public void init() {
        System.out.println("init() ... ");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("destroy() ...");
    }
}

主函数：

package wang;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import wang.config.SpringConfig;
import wang.dao.Dao;

public class AppForAnnotation {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        Dao dao1 = ctx.getBean(Dao.class);
        Dao dao2 = ctx.getBean(Dao.class);
        System.out.println(dao1);
        System.out.println(dao2);
        ctx.close();
    }
}

注意关闭容器或关闭钩子可以看到销毁操作

运行结果如下：

本例 DaoImpl 被设置为 singleton，主函数连续两次按 Dao 类型获取对象，因此在候选唯一的前提下，两次引用都指向同一个受管实例。@PostConstruct 标记初始化回调，ctx.close() 则触发该单例的 @PreDestroy 回调。注意主函数只是打印两次对象引用，并没有调用 save()，所以不能把业务方法提示语当作这一段代码的必然输出；对象打印出来的具体地址样式也不是判断单例的固定值。

注解开发依赖注入

@AutoWired —> 实现了引用类型的注入

注意：自动装配基于反射设计创建对象并暴力反射对应属性为私有属性初始化数据，因此无需提供setter方法

注意：自动装配建议使用无参构造方法创建对象（默认），如果不提供对应构造方法，请提供唯一的构造方法

样例代码如下：

package wang.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import wang.dao.Dao;
import wang.service.Service;

@Service
public class ServiceImpl implements Service {
    @Autowired
    @Qualifier("dao")
    private Dao dao;

    @Override
    public void save() {
        System.out.println("Service save() ...");
        dao.save();
    }
}

@Value(“变量值”) —> 实现了简单类型的注入

简单的样例代码如下：

@Service
public class ServiceImpl implements Service {
    @Value("wang")
    private string name;

    @Override
    public void save() {
        System.out.println("Service save() ..." + name);
    }
}

那么为什么不直接将name定义为“wang”呢？为什么还要多此一举呢？

因为可以通过@Value注入properties

在配置类中加入如下注解

@PropertySource({“xxx.properties”，“xxx.properties”}) 注意：不允许使用通配符

此时可以通过@Value(“${ 属性名 }”) 访问properties中的属性

注解开发管理第三方Bean

@Bean 表示当前方法的返回值是一个Bean

@Configuration
public class SpringConfig {
    //1.定义一个方法获得要管理的对象
    //2.添加@Bean，表示当前方法的返回值是一个bean
    @Bean
    public Datasource dataSource() {
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysq1.jdbc.Driver");
        ds.setUr1("jdbc:mysql://localhost:3306/spring_db");
        ds.setUsername("root");
        ds.setPassword("1234");
        return ds;
    }
}

写好当前配置文件后，在独立的配置类中导入当前配置类

方法1.扫描式 @ComponentScan({“xxx.service”, “xxx.dao”, “xxx.config”}) 不推荐

方法2.导入式 @Import(xxxconfig.class) 推荐，更为清晰

注入普通类型：

@Value("com.mysql.jdbc.Driver")
private string driver;
@value("jdbc:mysq1://localhost:3306/spring_db")
private string url;
@Value("root")
private string userName;
@Value("1234")
private string password;

使用@Value注入

注入引用类型

public Datasource dataSource() {
    DruidDataSource ds = new DruidDataSource(Dao dao);
    System.out.println(dao);
}

直接在形参声明即可，自动注入

XML配置对比注解配置

功能	XML配置	注解配置
定义Bean	bean标签 <br> • id属性 <br> • class属性	@Component <br> • @Controller <br> • @Service <br> • @Repository<br>@ComponentScan
设置依赖注入	setter注入（set方法） <br> • 引用类型/简单类型 <br>构造器注入（构造方法） <br> • 引用类型/简单类型 <br>自动装配	@AutoWired <br> • @Qualifier<br>@Value
配置第三方Bean	bean标签 <br>静态工厂、实例工厂、FactoryBean	@Bean
作用范围	• scope属性	@Scope
生命周期	标椎接口 <br> • init-method <br> • destroy-method	@PostConstructor<br>@PreDestroy

MySQL04-索引01-结构

Tue, 23 May 2023 17:00:00 GMT

详细的描述了MySQL中的索引的结构。

介绍

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

优缺点

优势	劣势
提高数据检索的效率，降低数据库的IO成本	索引列也会占用空间
通过索引列对数据进行排序，降低数据排序的成本，降低CPU的消耗。	索引大大提高了查询效率，同时却也降低更新表的速度，如对表进行INSERT、UPDATE、DELETE时,效率降低。

但是：

目前磁盘很便宜，无所谓占用空间

目前业务查询 SELECT 频次很高，INSERT、UPDATE、DELETE等操作频次较少

综上，使用索引是非常有必要的

结构

分类

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

引擎对于索引的支持情况

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

具体结构可以点击以下链接进入页面进行模拟操作：

点击此处链接进行模拟数据结构

点击此处链接进行模拟B+树结构

具体数据结构在《数据结构》课中都有详细描述。

B树结构样例如下：

原理示意：两棵树使用同一组示例键。B 树中的二十和四十对应记录保存在根中，不再重复放入叶子；B+ 树的内部节点只用分隔键导航，全部键对应的记录都在叶子。下半图按 InnoDB 的形式画出双向叶链，便于说明范围扫描，不表示实际页容量或磁盘读取次数。

B+树结构样例如下：

说明：图中数字均为示例键值。根节点以 20、40 作为分隔键，通过子指针将查找路由到相应键区间；全部示例记录保存在叶节点中，分隔键对应的记录也在叶层。叶节点内部及节点之间按键有序，相邻叶节点用双向链连接，体现 InnoDB 叶层顺序访问的概念。例如查询 20 ≤ 键 ≤ 48 时，先从根节点定位到包含 20 的叶节点，再沿叶链向右读取至 48。图中的“记录”泛指叶子索引记录：InnoDB 聚集索引的叶子保存行记录，二级索引的叶子包含索引列与对应主键；此图不表示实际物理页中的键排列、页内记录组织或容量。

B树与B+树的区别：

1.所有的数据都会出现在叶子节点

2.叶子节点形成了一个单向链表

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

Hash索引

Hash通过hash算法将键值对映射到指定位置，出现碰撞（hash冲突）可以通过链表解决。

Hash索引特点
1.Hash索引只能用于对等比较(=，in)，不支持范围查询(between，>，<，….
2.无法利用索引完成排序操作
3.查询效率高，通常只需要一次检索就可以了，效率通常要高于B+tree索引

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

为什么InnoDB存储引擎选择使用B+tree索引结构?

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

索引分类

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

InnoDB索引分类

分类	含义	特点
聚集索引(Clustered Index)	数据与索引放在一起，叶子节点保存了一行的数据	必须存在，且只有一个
二级索引(Secondary Index)	数据与索引分开存储，叶子节点存储对应主键	可以多个

聚集索引选取规则：
1.如果存在主键，主键索引就是聚集索引。
2.如果不存在主键，将使用第一含唯一（UNIQUE）索引作为聚集索引。
3.如果表没有主键，或没有合适的唯一索引，则InnoDB会自动生成一个rowid作为隐藏的聚集索引。

回表查询：

在二级索引中查询到主键，在聚集索引中根据主键查询到想要的数据

InnoDB主键索引的B+树高度为多高呢？

假设:
一行数据大小为1k，一页中可以存储16行这样的数据。InnoDB的指针占用6个字节的空间，主键即使为bigint，占用字节数为8。
高度为2:
n 8 + (n + 1) 6 = 16 1024，算出n约为1170
1171 16=18736
高度为3:
1171 1171 16 = 21939856

博客更新文档

Tue, 23 May 2023 16:00:00 GMT

[toc]

新增或修改的文件结构

root
│
├─_config.yml(修改)
│
├─_config.butterfly.yml(修改)
│
└─themes
    └─butterfly
        ├─layout
        │   ├─includes
        │	│	├─custom
        │	│	│	└─switch.pug(明暗切换动画)
        │	│	│
        │	│	├─header
        │	│	│	└─menu_item.pug(修改，添加子菜单栏居中)
        │	│	│
        │   │   ├─wedget
        │   │   │   ├─card_calendar.pug(新增写作日历)
        │	│	│	├─card_webinfo.pug(新增写作日历)
        │	│	│	└─index.pug(修改，添加写作日历)
		│	│	│
        │	│	└─rightside.pug(黑暗模式一图流)
        │	│	
        │	│	
        │   ├─head.pug(新增，引入昼夜切换)	
        │	├─rightside.pug(修改，昼夜切换)
        │   └─sliderbar.pug
        └─source
            ├─css
            │   ├─_layout
            │   │   ├─calendar.styl(新增日历样式)
            │   │   ├─footer.styl(修改，删除底部蓝条)
            │   │   └─switch.styl(新增，明暗切换样式)
            │   ├─custom
            │   │   ├─background.css(黑暗模式一图流配置)
            │	│	├─fontface.css(字体样式)
            │	│	├─header_beautify.css(子菜单美化)
            │	│	├─slideshow.css
            │	│	├─starlight.css(星光背景)
            │	│	├─twikoo_beautify.css(Twikoo评论美化)
            │	│	└─double_row.css(双栏布局美化)
            │	├─FangZhengKaiTiJianTi-1.ttf(字体美化)
            │	│
            │   └─img(新增，主题图片)
            │   
            └─js
            	└─custom
            		├─foot.js(页脚修改)
            		├─jquery.js(页脚修改支持)
            		├─sakura.js(樱花背景动效)
            		├─snow.js(雪花背景动效)
            		├─snowflake.js(雪花背景动效)
            		├─switch.js(切换明暗模式)
            		└─universe.js(星空背景)

注意：abbrlink

100 开头为博客搭建相关

101 开头为JavaSE相关

102 开头为 JavaWeb相关

103 开头为ssm相关

104 开头为MySQL相关

105开头为HTML+CSS相关

106开头为SpringCloud相关

107开头为Redis相关

108开头为JavaScript相关

2 开头为杂项

9开头为刷题笔记

更新日志

2023-05-18

更新相关

bug相关

杂项

初步创建github仓库，安装了nodejs和hexo，初始化了hexo博客

2023-05-19

更新相关

bug相关

杂项

采用next主题，进行了主题优化

2023-05-20

更新相关

bug相关

杂项

放弃使用next主题，改用butterfly主题

2023-05-21

更新相关

bug相关

杂项

计划将博客迁移到腾讯云上，购买了腾讯云服务器与域名，申请了ssl证书，在等待24小时后进行备案

2023-05-22

更新相关

bug相关

杂项

进行备案，同时将空闲的服务器制作成了饥荒游戏的服务器

2023-05-23

更新相关

bug相关

杂项

备案验证

2023-05-24

更新相关

主题优化，更改了博客的背景样式包括不同页面的背景，底部角标如运行时间等，背景透明度
添加了樱花特效与雪花特效，选择了樱花特效
添加了评论系统
添加了文章随机封面
更改了代码块显示
添加了本地搜索功能
修改了头像以及主页封面等
添加了文章版权信息
更改了图片放大查看
添加了相关文章功能
更改了侧边栏显示
更改了公告栏设置
更改了toc目录
更改了鼠标点击效果
更改了打字效果
更改了footer背景
添加了字数统计功能
更改了分享功能
更新了懒加载功能
在iconfont中添加了自定义图标

bug相关

杂项

2023-05-25

更新相关

bug相关

杂项

备案成功，一整天在尝试将自己的博客由github迁移到腾讯云上，晚上成功，博客进行了cdn加速，在国内的访问速度也非常快了

2023-05-26

更新相关

让域名被百度引擎收录
添加了博客日历功能
git贡献日历（已经删除）

bug相关

晚上发现博客更新后会出现cname失效的bug，在dns解析页面删除了存储桶的解析后bug解决（花了一晚上。。）

杂项

知道了腾讯云CDN加速需要收费，不过收费较为便宜

2023-05-27

更新相关

添加了博客搜索功能
更新了评论功能，绑定了域名，新增部署，创建了定时任务，设置了安全域名
更新了评论功能，绑定了qq邮箱，绑定授权码
添加了评论回复显示身份功能
Valine评论功能废弃（改用Twikwoo。。。）

bug相关

发现错误，baidu_url_submit配置的count过大，即git命令行出现{“error”:400,”message”:”over quota”}代码，更改count为20后无错误
上述错误仍然出现，不知道什么原因。
遇到了严重问题，github.io跳转失败，CDN加速无法添加A记录？（失败，github自带CDN加速，而自己的网站已经开启了CDN加速，除非使用子域名解决CNAME冲突？以后有需求再说吧，目前是国内wang-nine.cn访问，国外wang-nine.github.io）

杂项

尝试更新valine，接入自己的域名，但是卡在了部署证书这一步，在论坛反应后等待
晚上发现已绑定（奇怪。）尝试更新评论系统吧
卡在了魔改valine的这一步，彻底放弃了，尝试更新更好的twikoo评论系统

2023-05-28

更新相关

更新twikoo评论功能
MongoDB申请存储管理挂载twikoo评论(暂时不予采用)
腾讯云开发赠送学生免费6个月(采用腾讯云开发对twikoo评论进行配置)
新增公式支持功能

bug相关

杂项

2023-05-29

更新相关

更新Twikoo评论样式美化(在D:\Blog\themes\butterfly\source\css\custom中引入了css)
更新了分离搜索栏与菜单栏
更新了顶栏常驻
更新了文档支持公式

bug相关

顶部导航栏居中出了问题
子菜单栏居中出了问题

杂项

2023-05-30

更新相关

实现了子菜单栏居中的效果
删除了顶栏常驻效果
删除了分离搜索栏和菜单栏
将博客的字体改为了楷体
更新了博客中文章双栏显示（失败）
美化了博客中双栏显示的效果（失败）
修复了双栏显示后页码不居中的bug（失败）
增加了轮播图的功能（在文章配置中添加swiper_index属性，越大越先出现）

bug相关

阅读量和评论数一直加载中（已解决）

杂项

2023-05-31

更新相关

取消了日历功能（取消）（加上了）
增加了夜晚模式下的流星背景特效
增加了首页轮播图
增加了一图流
增加了日夜切换动画
增加了首页轮播图

bug相关

首页透明度bug（使用一图流解决）
黑夜模式首页背景不同bug（使用一图流解决）
封面不加载

杂项

2023-06-01

更新相关

bug相关

博客第二页未更新（重新在cos中上传即可）

杂项

2023-06-02

更新相关

删除了轮播图

bug相关

杂项

2023-06-24

更新相关

bug相关

直接gitbash上传四件套可以解决博客第二页未更新bug

杂项

2023-11-28

更新相关

添加了轮播图
删除了git日历

bug相关

杂项

2023-11-29

更新相关

bug相关

杂项

预计为文章添加description属性

Hexo+Butterfly主题博客搭建01

Tue, 23 May 2023 16:00:00 GMT

Hexo+Butterfly主题博客搭建01 ——— 个人博客搭建的基础环境配置工作

Node.js的配置

nodejs的官网

选择适合自己系统的下载即可，大部分人应该是Windows Installer (.msi) 64位，选择msi位安装程序，mac和linux用户选择适合自己的版本即可。

安装是一路默认选项即可，注意安装的路径可以根据自己的需求，一定要记住安装在哪里了

安装完成之后可以在cmd中测试是否安装成功

node -v

npm -v

安装后重新打开终端，分别执行上面的 node -v 与 npm -v。两条命令都能返回版本号，才说明当前终端可以找到对应程序；具体版本以本机实际输出为准。如果提示命令无法识别，先确认安装过程已完成、终端已重开，再检查安装目录是否加入 PATH。若机器上装过多个版本，还应检查命令实际解析到的路径，避免后续安装 Hexo 时使用了另一套环境。

Git的配置

Git的官网

在 Git 官网进入下载区域，按操作系统与处理器架构选择安装包，不要只依据网页上的某个按钮位置判断版本。Windows 用户安装时留意安装目录、默认编辑器以及命令行可用范围；如果希望在普通终端中使用 Git，应选择包含相应 PATH 集成的方案。完成安装后重开终端并执行 git --version，以能否返回实际版本信息检查命令是否可用，再继续准备博客仓库。

选择适合自己系统的下载即可，大部分人应该是Windows64位，所以直接点击Downloade for Windows即可。

安装是一路默认选项即可，注意安装的路径可以根据自己的需求，一定要记住安装在哪里了

安装完成之后可以在cmd中测试是否安装成功

github的配置

在github新建一个仓库

名称为 你的名称.github.io

个人主页仓库的配置要点：

仓库的关键配置是所有者与名称匹配：个人主页仓库命名为 <用户名>.github.io，其中用户名使用实际的 GitHub 账号名，而不是昵称。登录后从仓库创建入口填写名称，创建后核对仓库地址和所有者。随后在仓库设置中找到 Pages 的发布配置，按采用的部署方式选择分支发布或工作流发布；建好仓库本身并不代表站点已经发布，还需要后续生成并部署博客内容。

博客的初始化

安装Hexo

所有必备的应用程序安装完成后，即可使用npm安装Hexo。不要觉得安装这个框架有多复杂，只需要一条命令就可以了。npm是安装工具，install表示安装，-g表示全局安装，hexo-cli表示安装的是hexo框架。

在 git 命令行下输入下述的命令，若无法安装可能是因为权限不够，可以以管理员权限运行 gitbash

npm install -g hexo-cli

初始化博客

安装完框架之后新建一个存放博客的文件夹Blog，这里在D盘新建了一个Blog文件夹，在该文件夹下右键Git Bash Here并输入hexo init命令初始化这个文件夹。注意新建 Blog 文件夹和初始化这个文件夹只需要下面这条命令就可以了。

启动和配置博客

hexo clean  # 清除缓存
hexo g      # 生成静态网页
hexo d      # 部署到Github
hexo s 		# 是 hexo server 的缩写，启动本地服务器，用于预览主题。默认地址： http://localhost:4000/

此时输入 hexo clean hexo d hexo h hexo s 命令即可初步查看自己的 Blog 页面
在浏览器输入 http://localhost:4000/ 即可访问
顺利的话，在浏览器输入：用户名.github.io 即可初步访问自己的博客

SSM02-Spring中Bean的实例化与依赖注入

Tue, 23 May 2023 09:00:00 GMT

详细的描述了Spring中Bean的实例化与依赖注入。

Bean的实例化

构造方法

Spring创建Bean的时候调用无参构造。（有参构造会报错，私有无参也可以，底层使用了反射）

注意：Spring中的报错从下向上看，直到找到有用的信息。

注意：若不存在无参构造方法，会抛出异常：BeanCreationException

添加无参构造后：
运行结果：
这一节讨论的是直接按 class 配置、又没有提供构造参数时的实例化方式：容器需要找到可调用的无参构造器，再完成对象创建。补上无参构造器解决的是该配置下的实例化条件，并不意味着 Spring 一律禁止有参构造；后文的 constructor-arg 就是在显式描述构造参数。排查创建失败时应继续查看异常原因链，区分构造器选择、依赖缺失与初始化失败。

静态工厂

创建对象不需要自己new，创建一个工厂创建对象达到解耦的效果

样例代码：

package wang.factory;

import wang.dao.Dao;
import wang.dao.impl.DaoImpl;

public class DaoFactory {
    public static Dao getDao() {
    	System.out.println("factory set up ...");
        return new DaoImpl();
    }
}

配置文件添加如下代码：

<bean id="daoFactory" class="wang.factory.DaoFactory" factory-method="getDao"/>

主函数：

package wang;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import wang.dao.Dao;

public class App3 {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        Dao dao = (Dao) ctx.getBean("daoFactory");
        dao.save();
    }
}

运行结果：

这里 bean 的 class 指向 DaoFactory，factory-method 指向静态方法 getDao。容器调用这个方法取得它返回的 DaoImpl，并把该返回对象作为名称为 daoFactory 的 Bean 提供给应用。因此按 daoFactory 名称获取 Bean 的使用者拿到的是 Dao 类型的产品，而不是工厂本身；主函数再调用 dao.save()。对象创建逻辑被集中到工厂方法，调用者无需直接写出产品实现类的构造语句。

实例工厂

工厂代码同上

配置文件修改为如下代码：

<bean id="daoFactorytemp" class="wang.factory.DaoFactory"/>                 <!-- 创建工厂bean -->
<bean id="daoFactory" factory-bean="daoFactorytemp" factory-method="getDao"/>
<!-- factory-bean指定工厂bean -->

第一行为一个无用的bean，改良后即为第四种方法

主函数不变

运行结果：

工厂方式的共同目标是让容器对外提供 Dao 产品，主函数继续按产品的 Bean 名称获取对象并调用 save()。实例工厂配置使用 factory-bean 找到工厂对象，再由 factory-method 指定生产方法；FactoryBean 方式则实现统一的 getObject() 与 getObjectType() 契约。使用 FactoryBean 时，普通名称取到产品，带 & 前缀的名称才取得工厂自身。两者都要正确提供创建逻辑，不能只凭调用端相同就认定配置已经等价。

FactoryBean（重要！）

在第三种方法存在两个问题
一、factory-bean属性使用时会创建一个无用的Bean
二、factory-method属性方法名不固定，非动态实现

因此，对此方法做了改良

factory实现一个接口FactoryBean

工厂代码

package wang.factory;

import org.springframework.beans.factory.FactoryBean;
import wang.dao.Dao;
import wang.dao.impl.DaoImpl;

public class DaoFactoryBean implements FactoryBean<Dao> {
    // 代替原始实例工厂创建对象的方法
    @Override
    public Dao getObject() throws Exception {
        return new DaoImpl();
    }
    // 得到Bean的类型
    @Override
    public Class<?> getObjectType() {
        return Dao.class;
    }
    // 设置Bean是否单例子，return true为单例，false为非单例
    // 该方法一般不重写
    /*@Override
    public boolean isSingleton() {
        return true;
    }*/
}

配置文件修改为如下代码：

<bean id="daoFactory" class="wang.factory.DaoFactoryBean"/>

主函数不变

运行结果：

补充：Bean的生命周期

控制生命周期

方法一：

控制方法代码：

public static DaoImpl implements Dao {
    public void save() {
        System.out.println("Dao save ... ")
    }
    public void init() {
        System.out.println("Dao init ... ")
    }
    public void destroy() {
        System.out.println("Dao destroy ... ")
    }
}

配置控制方法：

<bean id="Dao" class="wang.dao.impl.DaoImpl" init-method="init" destroy-method="destory"/>

方法二

实现InitializingBean, DisposableBean接口

public static DaoImpl implements Dao, InitializingBean, DisposableBean {
    public void save() {
        System.out.println("Dao save ... ")
    }
    public void init() throws Exception {
        System.out.println("Dao init ... ")
    }
    public void destroy() throws Exception {
        System.out.println("Dao destroy ... ")
    }
}

生命周期

初始化容器
1.创建对象（内存分配）
2.执行构造方法
3.执行属性注入( set操作）
4.执行bean初始化方法

使用bean
1.行业务操作

关闭/销毁容器
1.执行bean销毁方法

注：**销毁的时机：**容器关闭前触发bean的销毁
关闭容器方式：
手工关闭容器
ConfigurableApplicationContext接口close（）

操作注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机
ConfigurableApplicationcontext接口registerShutdownHook （）操作

依赖注入

setter注入

引用类型

详情见博客 SSM01-Spring中的Bean

步骤如下
1.在bean中定义引用类型属性并提供可访问的set方法
2.配置中使用property标签ref属性注入引用类型对象

简单类型

步骤如下
1.在bean中定义引用类型属性并提供可访问的set方法
2.配置中使用property标签value属性注入简单类型数据

构造器注入

引用类型（仅做了解）

步骤如下
1.在bean中定义引用类型属性并提供可访问的构造方法
2.配置中使用constructor-arg标签ref属性注入引用类型对象

简单类型

步骤如下
1.在bean中定义引用类型属性并提供可访问的set方法
2.配置中使用property标签value属性注入简单类型数据
注意：
配置中使用constructor-arg标签type属性设置按形参类型注入
配置中使用constructor-arg标签index属性设置按形参位置注入

依赖注入方式的选择（总结自黑马程序员，侵删）

1.强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现
2.可选依赖使用setter注入进行，灵活性强
3.Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨
4.如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入
5.实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入
6.自己开发的模块推荐使用setter注入

自动装配（优先级低于setter注入与构造器注入）

IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配

自动装配方式

按类型（常用）（不能对简单类型装配）

<bean id="daoFactory" class="wang.dao.impl.DaoImpl" autowire="byType"/>

注意：需要set方法

注意：按类型（byType）时，同类型的应该只有一个bean，否则分不清。

按名称(set方法第一个字母改为小写的名称，即标椎的变量名)

<bean id="daoFactory" class="wang.dao.impl.DaoImpl" autowire="byName"/>

注意：因为变量名与byName耦合度高，不建议使用。

按构造方法

集合注入（主要学习格式）

Dao接口

package wang.dao;

public interface DataDao {
    public void save();
}

Dao实现

package wang.dao.impl;

import wang.dao.DataDao;

import java.util.*;

public class DataDaoImpl implements DataDao {

    private int[] array;

    private List<String> list;

    private Set<String> set;

    private Map<String,String> map;

    private Properties properties;




    public void setArray(int[] array) {
        this.array = array;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }




    public void save() {
        System.out.println("book dao save ...");

        System.out.println("遍历数组:" + Arrays.toString(array));

        System.out.println("遍历List" + list);

        System.out.println("遍历Set" + set);

        System.out.println("遍历Map" + map);

        System.out.println("遍历Properties" + properties);
    }
}

配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="dataDao" class="wang.dao.impl.DataDaoImpl">
        <!--数组注入-->
        <property name="array">
            <array>
                <value>100</value>
                <value>200</value>
                <value>300</value>
            </array>
        </property>
        <!--list集合注入-->
        <property name="list">
            <list>
                <value>java</value>
                <value>c++</value>
                <value>python</value>
                <value>php</value>
            </list>
        </property>
        <!--set集合注入-->
        <property name="set">
            <set>
                <value>java</value>
                <value>python</value>
                <value>java</value>
                <value>php</value>
            </set>
        </property>
        <!--map集合注入-->
        <property name="map">
            <map>
                <entry key="country" value="china"/>
                <entry key="province" value="shanxi"/>
                <entry key="city" value="xian"/>
            </map>
        </property>
        <!--Properties注入-->
        <property name="properties">
            <props>
                <prop key="country">china</prop>
                <prop key="province">shanxi</prop>
                <prop key="city">xian</prop>
            </props>
        </property>
    </bean>
</beans>

主函数：

package wang.dao;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App6 {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        DataDao dataDao = (DataDao) ctx.getBean("dataDao");
        dataDao.save();
    }
}

运行结果：

DataDaoImpl 的五个 setter 分别接收数组、List、Set、Map 和 Properties。XML 中 array 与 list 保留配置的元素顺序，set 表达不重复元素，因此配置里重复的 java 不应成为两个独立集合元素；map 与 props 则把键对应到值。save() 会逐项打印这些已注入的属性，检查重点是容器类型与内容是否符合配置，而不是照着某个 Set、Map 或 Properties 的显示顺序判断注入是否正确。

第三方资源注入

容器

两种加载容器的方式

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); //推荐

ApplicationContext ctx = new FileSystemXmlApplicationContext("D:\\ssm\\ssm\\springtest\\springtest\\src\\main\\resources\\applicationContext.xml")	//绝对路径寻找

两种获取bean的方式

Dao dao = (DataDao) ctx.getBean("dao");

Dao dao = ctx.getBean("dao", Dao.class);  //多个同种类型报错

对比ApplicationContext和BeanFactory

BeanFactory是顶级接口的Bean是延迟加载

ApplicationContext是子接口（常用）也可以延迟加载，在bean中加入参数 lazy-init=“true” 即可

加载第三方Bean

加载Properties文件

步骤如下：

开启Context命名空间
使用context加载properties文件
使用属性占位符${}读取properties配置文件中的属性

样例代码如下：

<?xml version="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
            ">
    <!--步骤-->
    <!--1.开启命名空间-->
    <!--2.使用context加载properties文件-->
    <context:property-placeholder location="xxxx.properties"/>

    <!--3.使用属性占位符${}读取properties配置文件中的属性-->
    <bean class="xxxx">
        <property name="xxxx" value="${ 配置中的变量名称 }"/>
    </bean>
</beans>

注意：加载时可以关闭系统属性，因为系统属性的优先级高于

注意：多个配置文件用逗号隔开

注意：专业的写法加载所有配置文件如下

<!-- 加载properties文件标准格式 -->
<context:property-placeholder location="classpath:*.properties" system-properties-mode="NEVER"/>
<!-- 从类路径或jar包中搜索并加载properties文件
<context:property-placeholder location="classpath*:*.properties" system-properties-mode="NEVER"/>

总结（来自黑马程序员，侵删）

容器相关

原理示意：类路径配置与文件系统配置分别交给相应的 ApplicationContext 实现读取，再由容器创建对象、装配依赖并执行初始化。应用按名称和类型获取 Bean；普通上下文通常在刷新时创建非懒加载单例，懒加载设置可推迟创建。关闭容器则为其管理的单例触发销毁回调，不应把所有作用域都理解成同样的生命周期。

bean相关

原理示意：Bean 先实例化，再接受依赖注入，随后执行初始化回调，之后才供应用使用；容器关闭时对受管单例执行销毁回调。XML 可以通过 init-method 与 destroy-method 指定方法，注解写法则标记相应方法。singleton 在容器内共享实例，prototype 每次请求可创建新实例，其完整销毁过程不由容器代管。

依赖注入相关

依赖注入可以先按入口区分：setter 注入使用 property，构造器注入使用 constructor-arg；再按数据区分，ref 指向另一个 Bean，value 提供简单值。集合使用 array、list、set、map、props 描述内容。自动装配则让容器按规则寻找依赖，按类型时要解决候选歧义，按名称时要对应属性与 Bean 名称。选择方式应结合强制依赖与可选依赖，而不是把所有对象都机械地改成同一种装配形式。

MySQL03-存储引擎

Tue, 23 May 2023 08:00:00 GMT

详细的描述了MySQL中的引擎之间的区别和选择。

MySQL体系结构

原理示意：客户端请求先经过连接管理与身份认证，再由服务层解析、优化和执行 SQL，最后通过存储引擎接口访问数据。不同引擎的存储方式不同，不能把 MEMORY 的表数据也理解为磁盘文件；查询结果沿调用链返回。

连接层

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

服务层

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

引擎层

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

存储层

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

存储引擎简介

建表语句中使用 ENGINE = 引擎名可以指定使用何种引擎
查看当前数据库支持的引擎： SHOW ENGINES；

存储引擎的特点

InnoDB

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

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

文件
xxx.ibd: xxx代表的是表名，innoDB引擎的每张表都会对应这样一个表空间文件，存储该表的表结构(frm、gdi) 、数据和索引。参数: innodb_file_per_table

原理示意：采用独立表空间布局时，表的数据和索引位于对应的 .ibd 文件。聚集索引的叶子保存完整行，二级索引叶子携带主键；当所需列不能由二级索引覆盖时，再凭主键回表。图中的姓名和主键仅为示例，事务、外键与行级锁则是引擎能力。

MyISAM

简介
MylSAM是MySQL早期的默认存储引擎。

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

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

Memory

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

特点
内存存放
hash索引（默认)

文件
xxx.sdi:存储表结构信息

比较：（来自黑马程序员，侵删）

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

存储引擎的选择（总结自黑马程序员MySQL课程，侵删）

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

InnoDB:是Mysql的默认存储引擎，支持事务、外键。如果应用对事务的完整性有比较高的要求，在并发条件下要求数据的一致性，数据操怍除了插入和查询之外，还包含很多的更新、删除操作，那么InnoDB存储引擎是比较合适的选择。

MyISAM:如果应用是以读操作和插入操作为主，只有很少的更新和删除操作，并且对事务的完整性、并发性要求不是很高，那么选择这个存储引擎是非常合适的。（被MongoDB取代）

MEMORY:将所有数据保存在内存中，访问速度快，通常用于临时表及缓存。MEMORY的缺陷就是对表的大小有限制，太大的表无法缓存在内存中，而且无法保障数据的安全性。（被Redis取代）

SSM01-Spring中的Bean

Tue, 23 May 2023 04:00:00 GMT

简单的介绍了Spring中的架构以及IOC和DI。

Spring FrameWork架构

Spring Framework是Spring生态圈中最基础的项目，是其他项目的根基

Spirng FrameWork的架构

原理示意：核心容器负责 Bean 的创建、依赖装配和应用上下文，是理解本篇 IoC 与 DI 的入口。在这一基础上，AOP 提供方法增强，数据访问与事务模块协调数据库操作，Web MVC 处理请求与响应。图中按职责分层说明各部分如何使用核心能力，不把它当作某一版本所有模块及依赖的完整清单。

Spring核心概念

IoC ( Inversion of Control )控制反转

使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转

Spring技术对IoC思想进行了实现Spring提供了一个容器，称为IoC容器，用来充当IoC思想中的”外部“

IoC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IoC容器中统称为Bean

DI ( Dependency Injection)依赖注入

在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入

IoC入门案例

思路分析：
1.管理什么? （Service与Dao）
2.如何将被管理的对象告知IoC容器?（配置）
3.被管理的对象交给IoC容器，如何获取到IoC容器?（接口）
4.IoC容器得到后，如何从容器中获取bean ?（接口方法）
5.使用Spring导入哪些坐标?（pom.xml）

非Spring环境下

案例代码如下：

Service层的代码：
接口：

package wang.service;

public interface Service {
    public void save();
}

实现：

package wang.service.impl;

import wang.dao.Dao;
import wang.dao.impl.DaoImpl;
import wang.service.Service;

public class ServiceImpl implements Service {

    private Dao dao = new DaoImpl();

    @Override
    public void save() {
        System.out.println("Service save() ...");
        dao.save();
    }
}

DAO层的代码：
接口：

package wang.dao;

public interface Dao {
    public void save();
}

实现：

package wang.dao.impl;

import wang.dao.Dao;

public class DaoImpl implements Dao {
    @Override
    public void save() {
        System.out.println("Dao save() ...");
    }
}

主函数代码：

package wang;

import wang.service.Service;
import wang.service.impl.ServiceImpl;

public class App {
    public static void main(String[] args) {
        Service service = new ServiceImpl();
        service.save();
    }
}

运行结果：
在不使用 Spring 的写法中，主函数主动创建 ServiceImpl，而 ServiceImpl 的属性初始化又主动创建 DaoImpl。调用 service.save() 时，业务层先执行自己的提示语句，再调用 dao.save() 执行数据层逻辑。这段例子的重点是两层协作及对象创建位置：实现类名称直接写进调用代码，更换依赖实现时需要修改这些创建语句，而不只是修改外部配置。

Spring环境下

别忘记在pom.xml中引入spring-context

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.10.RELEASE</version>
</dependency>

在resources中创建配置文件（名称：applicationContext.xml）：如图
在项目的 resources 资源目录中创建 applicationContext.xml，使它随构建进入运行时类路径。文件以 beans 为根元素，声明正文随后给出的 Spring beans 命名空间与 XML Schema，再用 bean 的 id 指定容器内名称、class 指定实现类全限定名。这里的文件名应与 ClassPathXmlApplicationContext 构造器传入的资源名一致；配置文件的位置和内容才是要点，不依赖编辑器界面的具体样式。

在配置文件中输入以下的代码

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--导入spring的坐标spring-context，对应版本是5.2.10.RELEASE-->

    <!--配置bean-->
    <!--bean标签标示配置bean
    id属性标示给bean起名字
    class属性表示给bean定义类型-->
    <bean id="Dao" class="wang.dao.impl.DaoImpl"/>

    <bean id="Service" class="wang.service.impl.ServiceImpl"/>
</beans>

主函数代码

package wang;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import wang.service.Service;

public class App2 {
    public static void main(String[] args) {
        // 获取IoC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 获取Bean
        Service service = (Service) ctx.getBean("Service");
        service.save();
    }
}

此时运行样例与非Spring方式相同如下：
主函数现在先读取 applicationContext.xml 建立容器，再按名称 Service 取出业务对象，随后仍然调用同一个 save() 方法，所以业务调用链的职责没有改变。不过此时 ServiceImpl 内部的 Dao 仍然由属性初始化中的 new 创建，配置中另外声明一个 Dao Bean 不会自动替换它。这个阶段完成的是对象获取方式的切换，下一步还需用依赖注入建立两个 Bean 之间的关系。

综上：可以分为四步

1.导入Spring坐标

2.定义Spring管理的类（接口）

3.创建Spring配置文件进行配置

4.初始化IoC容器，从容器中获取Bean（getBean方法）

问题：业务层中仍然是使用new创建对象，仍然耦合，那么如何解耦合呢？

DI入门案例

思路分析：
1.基于IoC管理bean
2.Service使用new形式创建的Dao对象是否保留?（否）
3.Service中需要的Dao对象如何进入到service中?（提供方法）
4.Service与Dao间的关系如何描述?（配置）

改变Service层实现代码如下

package wang.service.impl;

import wang.dao.Dao;
import wang.service.Service;

public class ServiceImpl implements Service {
    // 删除业务层以new的方式创建Dao对象
    //private Dao dao = new DaoImpl();
    private Dao dao;

    @Override
    public void save() {
        System.out.println("Service save() ...");
        dao.save();
    }

    // 提供对应的set方法
    public void setDao(Dao dao) {
        this.dao = dao;
    }
}

修改applicationContext.xml中配置：

<bean id="Service" class="wang.service.impl.ServiceImpl">
        <!--7.配置server与dao的关系-->
        <!--property标签表示配置当前bean的属性
        name属性表示配置哪一个具体的属性
        ref属性表示参照哪一个bean-->
        <property name="dao" ref="Dao"/>
    </bean>

注意：name是上述的（private Dao dao;）语句中的变量名，ref是bean的名字。

运行结果与上述一样：

原理示意：容器创建 Service 与 Dao 后，依据 property 的 name 找到 dao 属性对应的 setter，再把 ref 指向的 Dao Bean 传入。Service 不再自行 new DaoImpl，但运行时仍按原来的业务链路调用 dao.save()。因此调用职责保持不变，改变的是依赖对象的来源；属性名与 Bean 名称是不同的配置概念。

综上：可以分为三步

1.删除以new的形式创建对象的代码

2.提供对应的Set方法

3.配置Service与Dao之间的关系

注意在Bean标签中还可以进行以下的配置：

属性name：定义Bean的别名

属性scope：定义作用范围 singleton（默认，单例） prototype（非单例）

MySQL02-事务

Mon, 22 May 2023 14:00:00 GMT

详细的描述了MySQL中的事务的四大特性以及事务的隔离级别。

事务的简介

事务是一组操作的集合，它是一个不可分割的工作单位，事务会把所有的操作作为一个整体一起向系统提交或撤销操作请求，即这些操作要么同时成功，要么同时失败。

默认MySQL的事务是自动提交的，也就是说，当执行一条DML语句，MySQL会立即隐式的提交事务。

事务的操作

提交事务的方式

1.方式一

① 查看/设置事务的提交方式

SELECT @@autocommit;
SET @@autocommit = 0; —1是自动 0是手动

② 提交事务

COMMIT; —提交事务

③ 回滚事务

ROLLBACK; —回滚事务

2.方式二（手动开启并且提交）

① 开启事务

START TRANSACTION / BEGIN;

② 提交事务

COMMIT；

③ 回滚事务

ROLLBACK;

事务的四大特性（ACID）

原子性（Atomicity)：事务是不可分割的最小操作单元，要么全部成功，要么全部失败。

一致性（Consistency)：事务完成时，必须使所有的数据都保持一致状态。

隔离性（Isolation)：数据库系统提供的隔离机制，保证事务在不受外部并发操作影响的独立环境下运行。

持久性（Durability) :事务一旦提交或回滚，它对数据库中的数据的改变就是永久的。

并发事务的问题

问题	描述
脏读	一个事务读到另外一个事务还没有提交的数据。
不可重复读	一个事务先后读取同一条记录，但两次读取的数据不同，称之为不可重复读。
幻读	一个事务按照条件查询数据时，没有对应的数据行，但是在插入数据时，又发现这行数据已存在，好像出现了’幻影”。

事务的隔离级别

隔离级别	脏读	不可重复读	幻读
Read Uncommitted	√	√	√
Read Committed	×	√	√
Repeatable Read（默认）	×	×	√
Serializable	×	×	×

MySQL01-基础语法

Sun, 21 May 2023 14:00:00 GMT

详细的描述了MySQL中的基础语法。

SQL语法

SQL通用语法

1.SQL语句可以单行或多行书写，以分号结尾。
2.SQL语句可以使用空格/缩进来增强语句的可读性。
3.MySQL数据库的SQL语句不区分大小写，关键字建议使用大写。
4.注释：
- 单行注释：—注释内容或#注释内容(MySQL特有)
- 多行注释：/注释内容/

SQL分类

分类	全称	说明
DDL	Data Definition Language	数据定义语言，用来定义数据库对象(数据库，表，字段)
DML	Data Manipulation Language	数据操作语言，用来对数据库表中的数据进行增删改
DQL	Data Query Language	数据查询语言，用来查询数据库中表的记录
DCL	Data Control Language	数据控制语言，用来创建数据库用户、控制数据库的访问权限

DDL(Data Definition Language 数据定义语言)

数据库操作

查询

查询所有数据库

SHOW DATABASES;

查询当前数据库

SELECT DATABASE();

创建

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

删除

DROP DATABASE [IF EXISTS] 数据库名;

使用

USE 数据库名;

表操作

查询

查询当前数据库所有表

SHOW TABLES;

查询表结果

DESC 表明;

查询指定表的建表语句

SHOW CREATE TABLE 表名;

创建

CREATE TABLE表名(
	字段1 字段1类型[COMMENT 字段1注释],
    字段2 字段2类型[COMMENT 字段2注释],
    字段3 字段3类型[COMMENT 字段3注释],
    ......
	字段n 字段n类型[COMMENT 字段n注释]
)[COMMENT 表注释];

最后一个字段后面没有逗号

字段类型如下

数值类型

类型	大小	有符号(SIGNED)范围	无符号(UNSIGNED)范围	描述
TINYINT	1 byte	(-128,127)	(0，255)	小整数值
SMALLINT	2 bytes	(-32768，32767)	(0，65535)	大整数值
MEDIUMINT	3 bytes	(-8388608，8388607)	(0，16777215)	大整数值
INT或INTEGER	4 bytes	(-2147483648，2147483647)	(0，4294967295)	大整数值
BIGINT	8 bytes	(-2^63^，2^63^-1)	(0，2^64^-1)	极大整数值
FLOAT	4 bytes	(-3.402823466 E+38，3.402823466351 E+38)	0和(1.175494351 E-38，3.402823466 E+38)	单精度浮点数值
DOUBLE	8 bytes	(-1.7976931348623157 E+308，1.7976931348623157 E+308)	0和(2.2250738585072014 E-308，1.7976931348623157 E+308)	双精度浮点数值
DECIMAL		依赖于M(精度)和D(标度)的值	依赖于M(精度)和D(标度)的值	小数值(精确定点数)

字符串类型

类型	大小	描述
CHAR	0-255 bytes	定长字符串
VARCHAR	0-65535 bytes	变长字符串
TINYBLOB	0-255 bytes	不超过255个字符的二进制数据
TINYTEXT	0-255 bytes	短文本字符串
BLOB	0-65 535 bytes	二进制形式的长文本数据
TEXT	0-65 535 bytes	长文本数据
MEDIUMBLOB	0-16 777 215 bytes	二进制形式的中等长度文本数据
MEDIUMTEXT	0-16 777 215 bytes	中等长度文本数据
LONGBLOB	0-4 294 967 295 bytes	二进制形式的极大文本数据
LONGTEXT	0-4 294 967 295 bytes	极大文本数据

日期类型

类型	大小	范围	格式	描述
DATE	3	1000-01-01 至 9999-12-31	YYYY-MM-DD	日期值
TIME	3	-838:59:59 至 838:59:59	HH:MM:SS	时间值或持续时间
YEAR	1	1901 至 2155	YYYY	年份值
DATETIME	8	1000-01-01 00:00:00 至 9999-12-31 23:59:59	YYYY-MM-DD HH:MM:SS	混合日期和时间值
TIMESTAMP	4	1970-01-01 00:00:01 至 2038-01-19 03:14:07	YYYY-MM-DD HH:MM:SS	混合日期和时间值时间戳

修改

字段

添加

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

修改

修改数据类型

ALTER TABLE 表名 MODIFY 字段名 新数据类型(长度);

修改字段名和字段类型

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

删除

ALTER TABLE 表名 DROP 字段名;

表

修改表名

ALTER TABLE 表名 RENAME TO 新表名;

删除

删除表

DROP TABLE [IF EXISTS] 表名;

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

TRUNCATE TABLE 表名;

DML(Data Manipulation Language 数据操作语言)

添加数据

给指定字段添加数据

INSERT INTO 表名(字段名1, 字段名2, ...) VALUES (值1, 值2, ...);

给全部字段添加数据

INSERT INTO 表名 VALUES (值1, 值2, ...);

批量添加数据

INSERT INTO 表名(字段名1, 字段名2, ...) VALUES (值1, 值2, ...), (值1, 值2, ...), (值1, 值2, ...);

INSERT INTO 表名 VALUES (值1, 值2, ...), (值1, 值2, ...), (值1, 值2, ...);

注意

插入数据时，指定的字段顺序需要与值的顺序是一一对应

字符串和日期型数据应该包含在引号中

插入的数据大小，应该在字段的规定范围内。

修改数据

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

注意：修改语句的条件可以有，也可以没有，如果没有条件，则会修改整张表的所有数据。

删除数据

DELETE FROM 表名 [WHERE 条件];

注意

DELETE语句的条件可以有，也可以没有，如果没有条件，则会删除整张表的所有数据

DELET语句不能删除某一个字段的值(可以使用UPDATE)

DQL(Data Query Language 数据查询语言，用来查询数据库中表的记录)

语法

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

基本查询

查询多个字段

SELECT 字段1, 字段2, 字段3 ... FROM 表名;

SELECT * FROM 表名;

设置别名

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

去除重复记录

SELECT DISTINCT 字段列表 FROM 表名;

条件查询(WHERE)

聚合函数(count、max、min、avg、sum)

分组查询(GROUP BY)

排序查询(ORDER BY)

分页查询(LIMIT)

博客搭建教程总览

Fri, 19 May 2023 16:00:00 GMT

Hexo+Butterfly主题博客搭建01

Hexo+Butterfly主题博客搭建02

Hexo+Butterfly主题博客搭建03

SSM总览

Fri, 19 May 2023 16:00:00 GMT

SSM01-Spring中的Bean

SSM02-Spring中Bean的实例化与依赖注入

SSM03-Spring的纯注解开发模式

SSM04-Spring整合MyBatis

SSM05-Spring中的AOP概念

SSM06-Spring中的事务

SSM07-SpringMVC的请求与响应

SSM08-REST风格

MySQL总览

Fri, 19 May 2023 16:00:00 GMT

MySQL01-事务

MySQL02-存储引擎

MySQL03-索引01-结构

MySQL03-索引02-性能分析

MySQL03-索引03-使用规则

MySQL04-SQL优化

MySQL05-存储过程

MySQL06-存储函数

MySQL07-触发器

MySQL08-视图

MySQL09-锁

HTML5+CSS3总览

Fri, 19 May 2023 16:00:00 GMT

HTML5+CSS301-HTML

HTML5+CSS302-CSS

HTML5+CSS307-综合页面设计

HTML5+CSS303-综合页面设计

HTML5+CSS304-前端项目学习

HTML5+CSS305-移动端Web

Java中的多线程

Fri, 19 May 2023 14:00:00 GMT

详细的描述了Java中多线程的创建、使用、同步问题，以及线程池的创建、使用问题，详细的描述了定时器的创建和使用，详细的分析了Java中六种不同的线程转态以及转换。

1.Java中的多线程创建

java中多线程的创建可以分为三种不同的形式：

① 继承Thread类

具体步骤：

1.定义一个类MyThread继承
2.创建MyThread对象
3.调用线程对象的start方法启动线程（启动后会自动执行MyThread中重写的run()方法）

具体的例子如下

public class ThreadDemo1 {
    public static void main(String[] args) {
        /**
         * 3.new一个线程对象
         */
        Thread t = new MyThread();
        /**
         * 4.调用start()方法执行线程
         */
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出" + i);
        }
    }
}

/**
 * 1.定义一个线程类继承Thread
 */
class MyThread extends Thread {
    /**
     * 2.重写run方法
     */
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出" + i);
        }
    }
}

注意：
1.为什么不直接调用run方法，而是调用start启动线程
答：直接调用run方法会当成普通方法执行，此时还是相当于单线程执行。
2.为什么主线程任务放在子线程之后？
答：否则会先执行主线程任务再执行子线程任务。

优缺点：
优点：编程简单
缺点：单继承的局限性，不能继承其他类，不便于扩展。

② 实现Runnable接口

具体步骤：

1.定义一个线程任务类MyRunnable实现Runnable接口，重写run方法
2.创建MyRunnable对象
3.把MyRunnable对象交给Thread处理
具体的例子如下

public class ThreadDemo2 {
    public static void main(String[] args) {
        /**
         * 2.创建MyRunnable对象
         */
        Runnable target = new MyRunnable();

        /**
         * 3.把MyRunnable对象交给Thread处理
         */
        Thread t = new Thread(target);
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出" + i);
        }
    }
}


/**
 * 1.定义一个线程任务类MyRunnable实现Runnable接口，重写run方法
 */
class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出" + i);
        }
    }
}

优缺点：
优点：扩展性强，可以继续继承和实现。
缺点：如果线程有执行结果不能直接返回。

注意：也可通过匿名内部类实现（建议的写法）

/**
 * 通过匿名内部类来实现
 */
new Thread(new MyRunnable() {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("匿名内部类子线程的输出" + i);

        }
    }
}).start();

③ 实现Callable接口，通过FutureTask接口接收返回值（JDK5新增）

1.得到任务对象
第一步：定义一个线程任务类MyCallable实现Callable接口，重写call方法，该方法可以返回结果
第二步：用Future吧Callable对象封装成线程任务对象
2.把线程任务对象交给Thread处理
3.调用Thread的start方法启动任务
4.线程执行完毕后，通过FutureTask的get方法获得结果

具体的例子如下

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class ThreadDemo3 {
    public static void main(String[] args) {
        /**
         * 3.创建任务对象
         */
        Callable<String> call1 = new MyCallable(100);

        /**
         * 4.把Callable任务对象交给FutureTask对象
         * FutureTask的作用1：FutureTask实现了Runnable接口，此时就可以交给Thread了
         * FutureTask的作用2：可以在线程执行完毕后调用get方法得到线程执行的结果
         */
        //Thread t = new Thread(call);  报错，Thread不能接收call对象
        FutureTask<String> f1 = new FutureTask<>(call1);

        /**
         * 5.交给线程处理
         */
        Thread t1 = new Thread(f1);

        /**
         * 6.启动线程
         */
        t1.start();



        Callable<String> call2 = new MyCallable(200);
        FutureTask<String> f2 = new FutureTask<>(call2);
        Thread t2 = new Thread(f2);
        t2.start();

        try {
            String rs1 = f1.get();   //直接调用call方法，可能还没有执行完，使用get时若发现线程未执行完会先等线程执行完毕
            System.out.println("第一个结果为：" + rs1);
        } catch (Exception e) {
           e.printStackTrace();
        }

        try {
            String rs2 = f2.get();   //直接调用call方法，可能还没有执行完，使用get时若发现线程未执行完会先等线程执行完毕
            System.out.println("第二个结果为：" + rs2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


/**
 * 1.定义一个实现类，实现Callable接口，记得声明结果的数据类型
 */
class MyCallable implements Callable<String> {
    /**
     * 2.重写call方法
     */

    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return "子线程执行的结果是" + sum;
    }
}

优缺点：
优点：扩展性强，可以继续继承和实现。
可以在线程执行完毕后获取线程执行的结果。
缺点：编程较为复杂。

注意：Callable 与 FutureTask 创建对象时都需要声明类型

2.Java中的多线程常用方法

① 线程名称有关的方法

方法名称	说明
void setName()	设置线程名称
String getName(String name)	获得线程名称
CuurentThread()	获取当前的线程对象，哪个线程执行，拿到哪个线程对象

也可在构造器中取名
public Thread(String name)
public Thread(Runnable target)
public Thread(Runnable target, String name)

② 线程休眠有关的方法

方法名称	说明
sleep(long time)	单位为ms

具体的例子如下

public class ThreadDemo1 {
    public static void main(String[] args) throws Exception {
        Thread t1 = new MyThread("一号线程");
        t1.start();
//        t1.setName("一号线程");
        System.out.println(t1.getName());

        Thread t2 = new MyThread("二号线程");
        t2.start();
//        t2.setName("二号线程");
        System.out.println(t2.getName());

        //哪个线程执行，拿到哪个线程对象
        Thread m = Thread.currentThread();
        System.out.println(m.getName());
        for (int i = 1; i <= 5; i++) {
            System.out.println("Main线程输出" + i);
            if(i == 3)
                Thread.sleep(3 * 1000); //主线程休眠3000ms
        }
    }
}

线程的子类，自定义的线程MyThread

public class MyThread extends Thread{
    public MyThread(String name) {
        //让父类的构造器进行构造
        super(name);
    }

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出" + i);
        }
    }
}

3.Java中的线程安全问题

问题描述

多个线程同时操作一个共享资源可能会出现业务安全问题，称为线程安全问题

例如小明和小红有一个共同账户，余额为10万元，模拟两人同时取钱10万元
基础的定义代码如下：

① 提供一个账户类，创建一个账户对象代表两个人的共享账户

public class Account {
    private String cardId;
    private double money;   //余额


    public Account() {
    }

    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    public void DrawMoney(double money) {
        String name = Thread.currentThread().getName(); //获取取钱人的姓名
        //1.判断账户中的钱是否足够
        if (this.money >= money) {
            //2.取钱
            System.out.println(name + "来取钱成功，吐出：" + money);
            //3.更新余额
            this.money -= money;
            System.out.println("取钱后剩余：" + this.money);
        } else {
            //4.余额不足
            System.out.println(name + "来取钱，余额不足！");
        }
    }

    /**
     * 获取
     * @return cardId
     */
    public String getCardId() {
        return cardId;
    }

    /**
     * 设置
     * @param cardId
     */
    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    /**
     * 获取
     * @return money
     */
    public double getMoney() {
        return money;
    }

    /**
     * 设置
     * @param money
     */
    public void setMoney(double money) {
        this.money = money;
    }

    public String toString() {
        return "Account{cardId = " + cardId + ", money = " + money + "}";
    }
}

② 定义一个线程类，用来处理账户对象

/**
 * 取钱的线程类
 */
public class DrawThread extends Thread {
    private Account acc;    //定义一个账户对象，便于对账户对象进行操作

    public DrawThread(Account acc, String name) {
        super(name);
        this.acc = acc;
    }

    @Override
    public void run() {
        acc.DrawMoney(100000);
    }
}

③ 创建两个线程对象，传入同一个账户对象

④ 启动两个线程，去同一个账户对象中取钱10万

/**
 * 模拟取钱案例
 */
public class ThreadDemo {
    public static void main(String[] args) {
        /**
         * 1.定义线程类，创建一个共享的账户对象
         */
        Account acc = new Account("ICBC-999", 100000);

        /**
         * 2.创建两个线程对象，代表小明和小红同时取钱
         */
        new DrawThread(acc, "小明").start();
        new DrawThread(acc, "小红").start();
    }
}

注意会出现下面的错误样例：

两个取钱线程共享同一个 Account，但余额判断和扣款之间没有互斥保护。如果两者都在第一次扣款完成前通过余额检查，就可能都进入取款分支，破坏余额不能被重复支取的约束。问题在于检查与更新不是一个不可分割的操作；某次看似正常的打印顺序并不能证明线程安全，也不能把某个最终余额当作每次运行的固定结果。

解决方法：线程同步

针对上述错误解决线程安全问题：线程同步（同一个时刻仅有一个线程可以访问共享资源）

① 同步代码块

synchorized(同步锁对象) {
操作共享资源的代码（核心代码）
}

注意：同步锁对象对于不同的对象来说唯一即可，同一时间只能被一个人占用，因此可以使用字符串为同步锁对象，字符串在常量池中
注意：上述同步锁对象对于小明小红唯一，但是若有小黑小白另一家庭取钱，此时也会等待，此时会出问题。
锁对象使用任意的唯一对象可以吗？
答：不可以，会影响其他无关线程的执行。
锁对象的规范要求：使用共享资源作为锁对象
因此：对于实例方法：使用this作为锁对象
对于静态方法：使用字节码（类名.class)作为锁对象

实例代码如下(修改了上述的代码之后，结果正确)

public void DrawMoney(double money) {
    String name = Thread.currentThread().getName(); //获取取钱人的姓名
    //同步代码块
    synchronized (this) {
        //1.判断账户中的钱是否足够
        if (this.money >= money) {
            //2.取钱
            System.out.println(name + "来取钱成功，吐出：" + money);
            //3.更新余额
            this.money -= money;
            System.out.println("取钱后剩余：" + this.money);
        } else {
            //4.余额不足
            System.out.println(name + "来取钱，余额不足！");
        }
    }
}

结果如下：

同步代码块把余额检查、取款提示和余额更新都放在同一个 Account 对象的监视器保护下。按本例初始余额与取款金额，先获锁的一方完成扣款后，另一方再检查时余额已不足；谁先取到钱仍由调度决定。关键不是指定打印顺序，而是让所有访问同一账户的取款线程使用同一把锁，避免同时通过旧余额检查。

② 同步方法

修饰符 synchorized 返回值类型方法名称(形参列表) {
操作共享资源的代码（核心代码）
}

public synchronized void DrawMoney(double money) {     //同步方法
    String name = Thread.currentThread().getName(); //获取取钱人的姓名
    //1.判断账户中的钱是否足够
    if (this.money >= money) {
        //2.取钱
        System.out.println(name + "来取钱成功，吐出：" + money);
        //3.更新余额
        this.money -= money;
        System.out.println("取钱后剩余：" + this.money);
    } else {
        //4.余额不足
        System.out.println(name + "来取钱，余额不足！");
    }
}

注意：同步方法底层也有锁对象，为隐式锁对象，锁的范围是整个方法代码
如果方法是实例方法，会用this作为同步锁对象
如果方法是静态方法，会用类名.class作为同步锁对象

注意，上述两种方法中，同步代码块性能较好，范围越小性能越好，相当于一个在厕所外面排队，一个在坑外面排队，但是同步方法更好些更直观，在实际应用中多数使用同步方法

③ 同步锁（JDK5后提供了新的锁对象Lock，更加的灵活方便）

Lock是接口，采用实现类ReentrantLock来构建Lock锁对象

常用api如下

方法名称	说明
public ReentrantLock()	获得Lock锁的实现类对象
void lock()	获得锁
void unlock()	释放锁

//用final修饰，锁对象是唯一且不可替换的
private final Lock lock = new ReentrantLock();
public void DrawMoney(double money) {     //同步方法
    String name = Thread.currentThread().getName(); //获取取钱人的姓名
    //1.判断账户中的钱是否足够
    lock.lock();    //上锁
    try {
        if (this.money >= money) {
            //2.取钱
            System.out.println(name + "来取钱成功，吐出：" + money);
            //3.更新余额
            this.money -= money;
            System.out.println("取钱后剩余：" + this.money);
        } else {
            //4.余额不足
            System.out.println(name + "来取钱，余额不足！");
        }
    } finally {
        lock.unlock();  //解锁
    }
}

注意：一、锁对象声明为final代表锁是唯一且不可替换的
二、unlock放在finally中，防止代码出错而不执行unlock导致程序卡死

4.Java中的多线程通信（综合以上内容的综合样例）

常用的模型：生产者与消费者模型

object中提供的等待唤醒方法如下

方法名称	说明
void wait()	当前线程等待并且释放所占锁，直到另外一个线程调用notify()或者notifyaAll
void notify()	唤醒正在等待的单个线程
void notufyAll()	唤醒正在等待的所有线程

上述方法应该使用当前同步锁对象调用
注意：一定是先唤醒别人在等待，相当于自己叫醒别人再晕过去，否则相当于自己先晕过去没法叫人。

实例代码如下
账户类：

public class Account {
    private String cardId;
    private double money;   //余额

    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    /**
     * 小红 小明：取钱
     *
     * @param money
     */
    public synchronized void DrawMoney(double money) {
        String name = Thread.currentThread().getName(); //取钱人
        try {
            if (this.money >= money) {
                // 钱够，可以取钱
                this.money -= money;
                System.out.println(name + "取钱成功，取出" + money + "元！余额是：" + this.money);
                // 没钱了
                // 钱不够
                this.notifyAll();   //唤醒其他所有的线程
                this.wait();    //锁对象，让当前线程进入等待
            } else {
                // 钱不够，不可取
                // 唤醒别人存钱，等待自己取钱
                this.notifyAll();   //唤醒其他所有的线程
                this.wait();    //锁对象，让当前线程进入等待
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 亲爹 干爹 岳父：取钱
     *
     * @param money
     */
    public synchronized void depositMoney(double money) {
        String name = Thread.currentThread().getName(); //存钱人
        try {
            if (this.money == 0) {
                //没钱了，存钱
                this.money += money;
                System.out.println(name + "存钱" + money + "元成功，余额为" + this.money + "元！");
                // 存完钱了
                this.notifyAll();   //唤醒其他所有的线程
                this.wait();    //锁对象，让当前线程进入等待
            } else {
                // 有钱了，不用存钱
                this.notifyAll();   //唤醒其他所有的线程
                this.wait();    //锁对象，让当前线程进入等待
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

取钱线程类：

/**
 * 取钱的线程类
 */
public class DrawThread extends Thread {
    private Account acc;    //定义一个账户对象，便于对账户对象进行操作

    public DrawThread(Account acc, String name) {
        super(name);
        this.acc = acc;
    }

    @Override
    public void run() {
        //不断的存取前
        while (true) {
            acc.DrawMoney(100000);
            try {
                Thread.sleep(3 * 1000);     //每隔三秒取一次钱
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

存钱线程类：

/**
 * 取钱的线程类
 */
public class DepositThread extends Thread {
    private Account acc;    //定义一个账户对象，便于对账户对象进行操作

    public DepositThread(Account acc, String name) {
        super(name);
        this.acc = acc;
    }

    @Override
    public void run() {
        //不断的存取前
        while (true) {
            acc.depositMoney(100000);
            try {
                Thread.sleep(2 * 1000);     //每隔两秒存一次钱
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

主程序：

public class ThreadDemo {
    public static void main(String[] args) {
        // 三个父亲线程（生产者） 两个孩子线程（消费者） 模拟存取钱通信思想（一存 一取）
        // 1.创建账户对象，代表五个人共同操作的账户
        Account acc = new Account("ICBC-999", 0);   //初始化零元

        // 2.创建两个取钱线程 小明 小红
        new DrawThread(acc, "小明").start();
        new DrawThread(acc, "小红").start();

        // 3.创建三个存钱线程 亲爹 干爹 岳父
        new DepositThread(acc, "亲爹").start();
        new DepositThread(acc, "干爹").start();
        new DepositThread(acc, "岳父").start();
    }
}

运行结果

这里三个存钱线程与两个取钱线程围绕同一账户协作：存钱逻辑检查余额是否为零，取钱逻辑检查余额是否足够，并通过账户对象的 notifyAll() 与 wait() 传递继续工作的机会。wait() 会释放该对象的监视器，notifyAll() 不会立即释放锁，也不保证谁先执行。实际使用应在 while 条件循环中等待并在醒来后重查条件，不能把本例的 if 与固定人物交替当成可靠的生产者消费者协议。

5.线程池的创建以及使用

线程池是一个可以复用线程的技术。解决了每次都为新请求创建线程，导致开销较大的问题
JDK5.0起提供了代表线程池的接口：ExecutorService
得到线程池对象的两种办法：
一、使用ExecutorService的实现类ThreadPoolExecutor自己创建一个线程池对象。
二、使用Executors（线程池的工具类）调用方法放回不同特点的线程池对象。

① 线程池的API简介

ThreadPoolExecutor构造器：
public ThreadPoolExecutor（int corePoolSize
int maximumPoolSize,
long keepAliveTIme,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
参数一：指定线程池的线程数量（核心线程）：corePoolsize ——-> 不能小于0
参数二：指定线程池可支持的最大线程数：maximumPoolSize ———> 最大数量>=核心线程数量
参数三：指定临时线程的最大存活时间：keepAliveTime ———> 不能小于0
参数四：存活时间的单位（秒，分，时，天）：unit ———> 时间单位
参数五：指定任务队列：workQueue ———> 不能为null
参数六：指定用那个线程工厂创建线程：threadFactory ———> 不能为null
参数七：指定线程忙，任务慢的时候，新任务来了怎么办，即拒绝策略：handler ———> 不能为null

（重要！！！）注意两点：
临时线程什么时候创建：新任务提交时发现核心线程都在忙，任务队列满，还可以创建临时线程时才会创建。
什么时候开始拒绝任务：核心线程和临时线程都在忙，任务队列都满，新任务过来会拒绝。

ExecutorService的常用方法：

方法名称	说明
void execute(Runable command)	执行任务，无返回值，一般用于执行Runnable任务
Future\ submit(Callable\ Task)	执行任务，返回未来任务对象获取线程结果，一般用于执行Callable任务
void shutdown()	等待任务执行完毕后关闭线程池
List\ shutdownNow()	立即关闭，停止正在执行的任务，返回队列中未执行的任务

拒绝策略：

策略	详解
ThreadPoolExecutor.AbortPolicy	丢弃任务抛出RejectedExecutionException异常
ThreadPoolExecutor.DiscardPolicy	丢弃任务不抛出异常（不推荐）
ThreadPoolExecutor.DiscardOldestPolicy	抛弃等待最久的任务并把当前任务加入队列
ThreadPoolExecutor.CallerRunsPolicy	由主线程负责调用的run()方法绕过线程池直接执行，即来新任务主线程亲自服务

② 线程池处理Runnable任务

样例代码：
Runnable实现代码：

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出了：HelloWorld" + i);
        }
        // 睡眠线程，观察线程的执行情况
        try {
            System.out.println(Thread.currentThread().getName() + "本任务与线程绑定了，进入休眠状态了~~~");
            Thread.sleep(1000000);  //让其睡眠时间久一点，便于观察线程池的复用情况
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

线程池创建代码：

import java.util.concurrent.*;

public class threadPoolDemo1 {
    public static void main(String[] args) {
        // 1.创建线程池对象
        /**
         *     public ThreadPoolExecutor(int corePoolSize,
         *                               int maximumPoolSize,
         *                               long keepAliveTime,
         *                               TimeUnit unit,
         *                               BlockingQueue<Runnable> workQueue,
         *                               ThreadFactory threadFactory,
         *                               RejectedExecutionHandler handler) {
         */
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 6,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        // 2.把任务给线程池处理
        Runnable target = new MyRunnable();
        //核心线程运行
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);

        //不创建临时线程
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);       //任务队列满了！！核心线程都忙！！

        //创建临时线程
        pool.execute(target);
        pool.execute(target);

        //拒绝策略触发
        pool.execute(target);

        //关闭线程池（开发一般不使用，线程池作用就是长久存活）
        //pool.shutdownNow();     //立即关闭，即使任务未完成也关闭
        //pool.shutdown();    //等待任务执行完毕再关闭
    }
}

拒绝策略样例：
本例线程池的核心线程数为三、最大线程数为五，等待队列容量为五，并配置 AbortPolicy。在前面提交的任务仍被长时间休眠占住、尚未完成的条件下，前三个任务启动核心线程，接着五个任务入队，再来两个任务使用扩展线程；继续提交就会触发拒绝并抛出 RejectedExecutionException。这是配置和任务占用情况的推导，不代表任何负载下第十一个任务都必然被拒绝。

线程池运行样例：
每次 execute(target) 都提交一次 Runnable 执行，即使传入同一个任务对象，也不代表线程池只执行一次。任务先循环打印，再进入长时间休眠；休眠期间工作线程仍被这次任务占用，队列中的任务必须等待工作线程腾出位置。线程复用发生在一次任务结束之后，因此不能把多个线程名称的交错输出等同于队列任务已经全部完成，也不应依赖输出的固定顺序。

③ 线程池处理Callable任务

样例代码（简单测试一下，Callable实现在上面写过，具体使用方式与Runnable一致）：

import java.util.concurrent.*;

public class threadPoolDemo2 {
    public static void main(String[] args) throws Exception {
        // 1.创建线程池对象
        /**
         *     public ThreadPoolExecutor(int corePoolSize,
         *                               int maximumPoolSize,
         *                               long keepAliveTime,
         *                               TimeUnit unit,
         *                               BlockingQueue<Runnable> workQueue,
         *                               ThreadFactory threadFactory,
         *                               RejectedExecutionHandler handler) {
         */
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 6,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        // 2.把任务给线程池处理
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

线程池运行样例：
四次 submit 分别提交参数为一百、二百、三百和四百的 MyCallable，每个任务按前面的 call() 实现累加从一到该上限的整数，并把说明字符串作为结果。主线程按 f1、f2、f3、f4 的顺序调用 get()，所以结果的读取顺序由这几行代码决定，并不表示任务按同样顺序完成；若对应任务尚未结束，get() 会等待，任务失败则通过 Future 暴露异常。

④ （重要！） Executors工具类实现线程池

Executors获得线程池的常用方法：

方法名称	说明
public static ExecutorService newCachedThreadPool()	线程数随着任务增加而增加，若线程任务执行完毕且空闲一段时间会被回收
public static ExecutorService newFixedThreadPool()	创建固定数量的线程池。若某个线程因为异常而结束，那么线程池会补充一个新线程代替它
public static ExecutorService newSingleThreadExecutor()	创建只有一个线程对象的线程池对象，如果该线程因为异常而结束，那么线程池会补充一个新线程
public static ScheduledExecutorService newScheduledThreadPool(int PoolSize)	创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务

注意：Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象
注意：大型并发环境使用Executors如果不注意可能会出现系统风险，例如阿里开发手册不建议使用Executors创建线程池对象，而是建议使用ThreadPoolExecutor自己创建

方法名称	存在问题
public static ExecutorService newCachedThreadPool()	允许请求的任务队列长度为Integer.MAX_VALUE，可能出现OOM错误(OutOfMemoryError)
public static ExecutorService newFixedThreadPool()	同上
public static ExecutorService newSingleThreadExecutor()	创建的线程数量上限为Integer.MAX_VALUE，线程数随着任务1:1增长，可能出现OOM错误(OutOfMemoryError)
public static ScheduledExecutorService newScheduledThreadPool(int PoolSize)	同上

6.补充知识

① 定时器

定时器是一种控制任务延时调用，或者周期调用的技术
作用：闹钟，定时邮件发送

**定时器的两种实现方式如下**

Timer

构造器	说明
public Timer()	创建Timer定时器对象

方法	说明
public void schedule(TimerTask task, long delay, long period）	开启一个定时器，按照计划处理TimerTask任务，delay是延时，period是周期

注意：TimerTask是Runnable的实现类

存在的问题：
Timer是单线程，处理多个任务有序执行，存在演示与设置定时器的时间有出入
可能因为某个任务的异常使得Timer线程死掉，从而影响后续任务的执行

样例代码如下：

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TimerDemo1 {
    public static void main(String[] args) {
        // 1.创建Timer定时器
        Timer timer = new Timer();  //本身就是一个单线程

        // 2.调用方法，给定定时任务
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行任务A~~~" + new Date());
                try {
                    Thread.sleep(5000); //休眠5s
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, 0, 2000); //三秒后执行，每隔两秒执行一次

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行任务B~~~" + new Date());
            }
        }, 0, 2000);

        // 注意，本来A应该7s一次（2s间隔 + 5s睡眠），B应该2s一次
        // 实际情况与上述不符合，只存在一个线程，
        // B任务受到了A任务的影响
        // 其次，如果中间某个线程异常，其余线程都死亡
    }
}

运行样例如下:
两个任务都提交给同一个 Timer，而 Timer 只有一条执行任务的线程。任务 A 内部休眠五秒时，这条线程仍被占用，任务 B 即使已到计划时间也只能等待；设置两秒周期并不保证任务能准点开始，也不能简单把实际周期恒定相加成七秒。若任务抛出未捕获的运行时异常并终止 Timer 线程，其余待调度任务也会受到影响，因此应把串行占用与定时参数分别理解。

ScheduledExecutorService

ScheduledExecutorService弥补了Timer的缺陷

Executors的方法	说明
public static ScheduledExecutorService newScheduledThreadPool(int PoolSize	得到线程池对象

ScheduledExecutorService的方法	说明
public Scheduled<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)	周期调度方法

优点：基于线程池，某个任务的执行情况不会影响其他任务的执行

样例代码如下：

import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TimerDemo2 {
    public static void main(String[] args) {
        // 1.创建ScheduledExecutorService线程池对象
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);

        // 2.开启定时任务
        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行任务A~~~");
                //把该线程堵塞
                try {
                    Thread.sleep(100000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, 0, 2, TimeUnit.SECONDS);

        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行任务B~~~");
                System.out.println(10 / 0); //使该线程异常
            }
        }, 0, 3, TimeUnit.SECONDS);


        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行任务C~~~");
            }
        }, 0, 3, TimeUnit.SECONDS);
    }
}

运行样例如下：
本例创建三条工作线程，分别周期调度任务 A、B、C。A 长时间休眠会占用一条工作线程，但同一周期任务不会因此并发重入；B 的除零异常会终止 B 这次周期任务后续的调度，而不是让整个线程池和 C 一起停止。只要仍有可用工作线程，C 可以继续被调度，但线程池资源不足时其他任务仍会延迟，因此“互不影响”应理解为任务异常被隔离，而非无条件准点执行。

异常不会影响
也不受其他任务的影响

② 并发与并行

并发与并行：
正在运行的程序（软件）就是一个独立的进程，线程是属于进程的，多个线程其实是并发与并行同时进行的。

并发的理解：
CPU同时处理线程的数量有限。
CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

并行的理解：
在同一个时刻上，同时有多个线程在被CPU处理并执行。

③ （重点！！！）线程的生命周期

线程的状态:
也就是线程从生到死的过程，以及中间经历的各种状态及状态转换。理解线程的状态有利于提升并发编程的理解能力。

Java线程的状态：
Java总共定义了6种状态
6种状态都定义在Thread类的内部枚举类中。

线程6种状态的转换如下图

原理示意：NEW 调用 start() 后进入 RUNNABLE，后者同时包括等待调度与执行中的情况。竞争对象监视器失败进入 BLOCKED，等待其他线程动作可进入 WAITING，带时限的等待进入 TIMED_WAITING。wait() 释放监视器，醒来后还要重新竞争锁；sleep() 则不释放已经持有的锁，超时也不意味着马上得到执行机会。

注意以下几点：
sleep()是睡眠，过程中不会释放锁对象，醒来后直接进入可运行状态
wait()是等待，过程中会释放锁对象，但是时间到了或者被notity时会重新获得锁对象，进入可运行状态

**总结：**

线程状态	描述
NEW（新建）	线程刚被创建，但是并未启动。
Runnable（可运行）	线程已经调用了start()等待CPU调度
Blocked（锁阻塞）	线程在执行的时候未竞争到锁对象，则该线程进入Blocked状态
Waiting（无限等待）	一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够唤醒
Time Waiting（计时等待）	同waiting状态，有几个方法有超时参数，调用他们将进入Timed waiting状态。带有超时参数的常用方法有Thread.sleep和Object.wait
Teminated（被终止）	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。