初始化提交

javaEE/day08/MySQL多表查询与事务的操作-笔记.md

@@ -0,0 +1,770 @@
+# MySQL多表查询与事务
+
+### 学习目标
+1. 能够理解三大范式
+2. 能够使用内连接进行多表查询
+3. 能够使用左外连接和右外连接进行多表查询
+4. 能够使用子查询进行多表查询
+5. 能够理解多表查询的规律
+6. 能够理解事务的概念
+7. 能够说出事务的原理
+8. 能够在MySQL中使用事务
+9. 能够理解脏读,不可重复读,幻读的概念及解决办法
+
+## 第一章 数据库的三大范式
+
+#### 目标
+
+能够说数据库中有哪三大范式？每个范式的含义是什么？
+
+#### 讲解
+
+##### 什么是范式
+**范式是指**:设计数据库表的规则(Normal Form)
+​	好的数据库设计对数据的存储性能和后期的程序开发，都会产生重要的影响。建立科学的，规范的数据库就需要满足一些规则来优化数据的设计和存储
+
+##### 范式的基本分类
+​	目前关系数据库有五种范式：第一范式（1NF）、第二范式（2NF）、第三范式（3NF）、巴斯-科德范式（BCNF）、第四范式(4NF）和第五范式（5NF，又称完美范式）。满足最低要求的范式是第一范式（1NF）。在第一范式的基础上进一步满足更多规范要求的称为第二范式（2NF），其余范式以次类推。**一般说来，数据库只需满足第三范式(3NF）就行了。**
+
+##### 第一范式
+​	即数据库表的每一列都是不可分割的原子数据项，而不能是集合、数组、记录等非原子数据项。即实体中的某个属性有多个值时，必须拆分为不同的属性。在符合第一范式（1NF）表中每个列的值只能是表的一个属性或一个属性的一部分。简而言之，第一范式每一列不可再拆分，称为原子性。
+**第一范式**：表中每一列不能再拆分
+![](img/范式01.png)
+
+>总结：如果不遵守第一范式，查询出数据还需要进一步处理（查询不方便）。遵守第一范式，需要什么字段的数据就查询什么数据（方便查询）。
+
+##### 第二范式
+​	第二范式（2NF）要求数据库表中的每个实例或记录必须可以被唯一地区分。选取一个能区分每个实体的属性或属性组，作为实体的唯一标识。例如在员工表中的身份证号码即可实现每个员工的区分，该身份证号码即为候选键，任何一个候选键都可以被选作主键。在找不到候选键时，可额外增加属性以实现区分。
+​	第二范式（2NF）要求实体的属性完全依赖于主关键字。所谓完全依赖是指不能存在仅依赖主关键字一部分的属性。如果存在，那么这个属性和主关键字的这一部分应该分离出来形成一个新的实体，新实体与原实体之间是一对多的关系。为实现区分通常需要为表加上一个列，以存储各个实例的唯一标识。简而言之，第二范式就是在第一范式的基础上属性完全依赖于主键。
+
+**第二范式**：
+
+1. 一张表只描述一件事情
+2. 表中的每一个字段都依赖于主键
+   ![](img/范式03.png)
+>总结：如果不准守第二范式，数据冗余，相同数据无法区分。遵守第二范式减少数据冗余，通过主键区分相同数据。
+
+##### 第三范式
+
+​	在2NF基础上，任何非主属性不依赖于其它非主属性（在2NF基础上消除传递依赖）
+第三范式（3NF）是第二范式（2NF）的一个子集，即满足第三范式（3NF）必须满足第二范式（2NF）。简而言之，第三范式（3NF）要求一个关系中不包含已在其它关系已包含的非主关键字信息。
+
+**第三范式**：从表的外键必须使用主表的主键
+![](img/范式04.png)
+
+>总结：如果不准守第三范式，可能会有相同数据无法区分，修改数据的时候多张表都需要修改（不方便修改）。遵守第三范式通过id可以区分相同数据，修改数据的时候只需要修改一张表（方便修改）。
+
+#### 小结
+
+第一范式要求? 
+​	表中的字段不能再拆分（字段原子性）
+
+第二范式要求? 
+​	1.一张表描述一件事情
+​	2.每个表都提供主键
+
+第三范式要求?
+​	从表的外键必须使用主表的主键
+
+## 第二章 多表查询介绍
+
+#### 目标
+
+了解什么是多表查询，及多表查询的两种方式
+
+#### 讲解
+
+##### 什么是多表查询
+
+**同时查询多张表获取到需要的数据**
+比如：我们想查询到开发部有多少人，需要将部门表和员工表同时进行查询
+![](img/%E8%A1%A8%E8%BF%9E%E6%8E%A5%E6%9F%A5%E8%AF%A201.png)
+
+##### 多表查询的分类
+
+![1550291804592](img/1550291804592.png)
+
+#### 小结
+
+什么是多表查询？通过查询多张表获取我们想要的数据
+
+### 笛卡尔积现象
+
+#### 目标
+
+能够说出什么是笛卡尔积，以及如何消除笛卡尔积
+
+#### 讲解
+##### 准备数据
+
+```sql
+CREATE DATABASE day15;
+USE day15;
+
+-- 创建部门表
+CREATE TABLE dept (
+  id INT PRIMARY KEY AUTO_INCREMENT,
+  NAME VARCHAR(20)
+);
+
+INSERT INTO dept (NAME) VALUES ('开发部'),('市场部'),('财务部');
+
+-- 创建员工表
+CREATE TABLE emp (
+  id INT PRIMARY KEY AUTO_INCREMENT,
+  NAME VARCHAR(10),
+  gender CHAR(1),   -- 性别
+  salary DOUBLE,   -- 工资
+  join_date DATE,  -- 入职日期
+  dept_id INT
+);
+
+INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('孙悟空','男',7200,'2013-02-24',1);
+INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('猪八戒','男',3600,'2010-12-02',2);
+INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('唐僧','男',9000,'2008-08-08',2);
+INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('白骨精','女',5000,'2015-10-07',3);
+INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('蜘蛛精','女',4500,'2011-03-14',1);
+```
+
+##### 什么是笛卡尔积现象
+
+需求：查询每个部门有哪些人
+
+具体操作：
+
+```sql
+SELECT * FROM dept, emp;
+```
+
+![](img/%E8%A1%A8%E8%BF%9E%E6%8E%A5%E6%9F%A5%E8%AF%A203.png)
+
+以上数据其实是左表的每条数据和右表的每条数据组合。左表有3条，右表有5条，最终组合后3*5=15条数据。
+
+**左表的每条数据和右表的每条数据组合，这种效果称为笛卡尔乘积**
+![](img/%E8%A1%A8%E8%BF%9E%E6%8E%A5%E6%9F%A5%E8%AF%A204.png)
+
+##### 如何清除笛卡尔积现象的影响
+
+我们发现不是所有的数据组合都是有用的，只有员工表.dept_id = 部门表.id 的数据才是有用的。所以需要通过条件过滤掉没用的数据。
+![](img/%E8%A1%A8%E8%BF%9E%E6%8E%A5%E6%9F%A5%E8%AF%A205.png)
+
+```sql
+SELECT * FROM dept, emp WHERE emp.`dept_id`=dept.`id`; 
+```
+
+![](img/%E8%A1%A8%E8%BF%9E%E6%8E%A5%E6%9F%A5%E8%AF%A206.png)
+
+#### 小结
+
+1. 能够说出什么是笛卡尔积?
+   左表的每条记录和右表的每条记录会组合起来
+2. 如何消除笛卡尔积
+   只查询满足要求的数据，通常都是外键等于主键
+
+### 内连接
+
+#### 目标
+
+能够掌握内连接的使用
+
+#### 讲解
+
+##### 什么是内连接
+
+用左边表的记录去匹配右边表的记录，如果符合条件的则显示
+
+##### 隐式内连接
+
+隐式内连接：看不到`JOIN`关键字，条件使用`WHERE`指定
+
+```sql
+SELECT 字段 FROM 左表, 右表 WHERE 条件;
+```
+
+##### 显示内连接
+
+显示内连接：使用`INNER JOIN ... ON`语句, 可以省略`INNER`
+
+```sql
+SELECT 字段 FROM 左表 INNER JOIN 右表 ON 条件；
+SELECT 字段 FROM 左表 JOIN 右表 ON 条件；
+```
+
+具体操作：
+
+- 查询唐僧的信息，显示员工id，姓名，性别，工资和所在的部门名称，我们发现需要联合2张表同时才能查询出需要的数据，我们使用内连接
+
+![](img/%E8%A1%A8%E8%BF%9E%E6%8E%A5%E6%9F%A5%E8%AF%A215.png)
+
+1. 确定查询哪些表
+
+```sql
+SELECT * FROM dept INNER JOIN emp;
+```
+
+![](img/%E8%A1%A8%E8%BF%9E%E6%8E%A5%E6%9F%A5%E8%AF%A207.png)
+
+2. 确定表连接条件，员工表.dept_id = 部门表.id 的数据才是有效的
+
+```sql
+SELECT * FROM dept INNER JOIN emp ON emp.`dept_id`=dept.`id`;
+```
+
+![](img/%E8%A1%A8%E8%BF%9E%E6%8E%A5%E6%9F%A5%E8%AF%A208.png)
+
+3. 确定查询条件，我们查询的是唐僧的信息，部门表.name='唐僧'
+
+```sql
+SELECT * FROM dept INNER JOIN emp ON emp.`dept_id`=dept.`id` AND emp.`NAME`='唐僧';
+```
+
+![](img/%E8%A1%A8%E8%BF%9E%E6%8E%A5%E6%9F%A5%E8%AF%A209.png)
+
+4. 确定查询字段，查询唐僧的信息，显示员工id，姓名，性别，工资和所在的部门名称
+
+```sql
+SELECT emp.`id`, emp.`NAME`, emp.`gender`, emp.`salary`, dept.`NAME` FROM dept INNER JOIN emp ON emp.`dept_id`=dept.`id` AND emp.`NAME`='唐僧';
+```
+
+![](img/%E8%A1%A8%E8%BF%9E%E6%8E%A5%E6%9F%A5%E8%AF%A210.png)
+
+5. 我们发现写表名有点长，可以给表取别名，显示的字段名也使用别名
+
+```sql
+SELECT e.`id` 员工编号, e.`NAME` 员工姓名, e.`gender` 性别, e.`salary` 工资, d.`NAME` 部门名称 FROM dept d INNER JOIN emp e ON e.`dept_id`=d.`id` AND e.`NAME`='唐僧';
+```
+
+![](img/%E8%A1%A8%E8%BF%9E%E6%8E%A5%E6%9F%A5%E8%AF%A211.png)
+
+#### 小结
+
+1. 什么是隐式内连接和显示内连接？
+   隐式内连接：看不到JOIN：SELECT 字段 FROM 左表, 右表 WHERE 条件；
+   显示内连接：看得到JOIN：SELECT 字段 FROM 左表 INNER JOIN 右表 ON 条件；
+2. 内连接查询步骤？
+   1.确定查询几张表
+   2.确定表连接条件
+   3.根据需要在操作
+
+### 左外连接
+
+#### 目标
+
+能够掌握左外连接查询
+
+#### 讲解
+
+左外连接：使用`LEFT OUTER JOIN ... ON`，`OUTER`可以省略
+
+```sql
+SELECT 字段名 FROM 左表 LEFT OUTTER JOIN 右表 ON 条件;
+```
+
+**左外连接**可以理解为：在内连接的基础上保证左表的数据全部显示，右表中没有对应的记录，使用NULL填充。
+
+具体操作：
+
+- 在部门表中增加一个销售部
+
+```sql
+INSERT INTO dept (NAME) VALUES ('销售部');
+```
+
+![](img/%E8%A1%A8%E8%BF%9E%E6%8E%A5%E6%9F%A5%E8%AF%A212.png)
+
+- 使用内连接查询
+
+```sql
+SELECT * FROM dept INNER JOIN emp ON emp.`dept_id`=dept.`id`;
+```
+
+![](img/%E8%A1%A8%E8%BF%9E%E6%8E%A5%E6%9F%A5%E8%AF%A213.png)
+
+- 使用左外连接查询
+
+```sql
+SELECT * FROM dept LEFT OUTER JOIN emp ON emp.`dept_id`=dept.`id`;
+```
+
+![](img/%E8%A1%A8%E8%BF%9E%E6%8E%A5%E6%9F%A5%E8%AF%A214.png)
+
+#### 小结
+
+1. 掌握左外连接查询格式？
+
+   ```
+   SELECT 字段 FROM 左表 LEFT OUTER JOIN 右表 ON 条件
+   ```
+
+2. 左外连接查询特点？
+   在满足要求的基础上保证左表的数据全部显示
+   在内连接的基础上保证左表的数据全部显示
+
+### 右外连接
+
+#### 目标
+
+能够掌握右外连接查询
+
+#### 讲解
+
+右外连接：使用`RIGHT OUTER JOIN ... ON`，`OUTER`可以省略
+
+```sql
+
+```
+
+**右外连接**可以理解为：在内连接的基础上保证右表的数据全部显示，左表中没有对应的记录，使用NULL填充。
+
+具体操作：
+
+- 在员工表中增加一个员工
+```sql
+INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('沙僧','男',6666,'2013-02-24',NULL);
+```
+  ![](img/%E8%A1%A8%E8%BF%9E%E6%8E%A5%E6%9F%A5%E8%AF%A217.png)
+- 使用内连接查询
+```sql
+SELECT * FROM dept INNER JOIN emp ON emp.`dept_id`=dept.`id`;
+```
+  ![](img/%E8%A1%A8%E8%BF%9E%E6%8E%A5%E6%9F%A5%E8%AF%A213.png)
+- 使用右外连接查询
+```sql
+SELECT * FROM dept RIGHT OUTER JOIN emp ON emp.`dept_id`=dept.`id`;
+```
+  ![](img/%E8%A1%A8%E8%BF%9E%E6%8E%A5%E6%9F%A5%E8%AF%A216.png)
+
+#### 小结
+
+1. 掌握右外连接查询格式？
+
+   ```
+   SELECT 字段 FROM 左表 RIGHT OUTER JOIN 右表 ON 条件;
+   ```
+
+2. 右外连接查询特点？
+   在满足要求的基础上,保证右表的数据全部显示.
+
+### 子查询
+
+#### 目标
+
+能够掌握子查询的概念
+
+能够理解子查询的三种情况
+
+#### 讲解
+
+##### 什么是子查询
+
+**一条查询语句结果作为另一条查询语法一部分。**
+
+```sql
+SELECT 查询字段 FROM 表 WHERE 条件;
+```
+
+```sql
+SELECT * FROM employee WHERE salary=(SELECT MAX(salary) FROM employee);
+```
+
+![](img/%E5%AD%90%E6%9F%A5%E8%AF%A201.png)
+子查询需要放在（）中
+
+##### 子查询结果的三种情况
+
+1. 子查询的结果是单行单列的时候
+   ![](img/%E5%AD%90%E6%9F%A5%E8%AF%A202.png)
+2. 子查询的结果是多行单列的时候
+   ![](img/%E5%AD%90%E6%9F%A5%E8%AF%A203.png)
+3. 子查询的结果是多行多列
+   ![](img/%E5%AD%90%E6%9F%A5%E8%AF%A204.png)
+
+#### 小结
+
+1. 什么是子查询？
+   一个查询的结果作为另一个查询语句的一部分
+2. 子查询结果的三种情况？
+   单行单列
+   多行单列
+   多行多列
+
+### 子查询的结果是单行单列的时候
+
+#### 目标
+
+能够掌握子查询的结果是单行单列的查询
+
+#### 讲解
+
+子查询结果是`单列`，在`WHERE`后面作为`条件`
+`SELECT 查询字段 FROM 表 WHERE 字段=（子查询）;`
+
+1. **查询工资最高的员工是谁？** 
+
+   1. 查询最高工资是多少
+
+   ```sql
+   SELECT MAX(salary) FROM emp;
+   ```
+
+     ![](img/%E5%AD%90%E6%9F%A5%E8%AF%A205.png)
+
+   1. 根据最高工资到员工表查询到对应的员工信息
+
+   ```sql
+     SELECT * FROM emp WHERE salary=(SELECT MAX(salary) FROM emp);
+   ```
+
+     ![](img/%E5%AD%90%E6%9F%A5%E8%AF%A206.png)
+
+2. **查询工资小于平均工资的员工有哪些？**
+
+   1. 查询平均工资是多少
+
+   ```sql
+   SELECT AVG(salary) FROM emp;
+   ```
+
+     ![](img/%E5%AD%90%E6%9F%A5%E8%AF%A207.png)
+
+   1. 到员工表查询小于平均的员工信息
+
+   ```sql
+   SELECT * FROM emp WHERE salary < (SELECT AVG(salary) FROM emp);
+   ```
+
+     ![](img/%E5%AD%90%E6%9F%A5%E8%AF%A208.png)
+
+#### 小结
+
+子查询的结果是单行单列时父查询如何处理？
+SELECT 查询字段 FROM 表 WHERE 字段=（子查询）;
+
+通常作为父查询的条件
+
+### 子查询结果是多行单列的时候
+
+#### 目标
+
+能够掌握子查询的结果是多行单列的查询
+
+#### 讲解
+
+子查询结果是单列多行，结果集类似于一个数组，在`WHERE`后面作为`条件`，父查询使用`IN`运算符
+
+```sql
+SELECT 查询字段 FROM 表 WHERE 字段 IN （子查询）;
+```
+
+1. **查询工资大于5000的员工，来自于哪些部门的名字**  
+
+   1. 先查询大于5000的员工所在的部门id
+
+   ```sql
+   SELECT dept_id FROM emp WHERE salary > 5000;
+   ```
+
+     ![](img/%E5%AD%90%E6%9F%A5%E8%AF%A209.png)
+
+   1. 再查询在这些部门id中部门的名字
+
+   ```sql
+   SELECT dept.name FROM dept WHERE dept.id IN (SELECT dept_id FROM emp WHERE salary > 5000);
+   ```
+
+     ![](img/%E5%AD%90%E6%9F%A5%E8%AF%A210.png)
+
+2. **查询开发部与财务部所有的员工信息**
+
+   1. 先查询开发部与财务部的id
+
+   ```sql
+   SELECT id FROM dept WHERE NAME IN('开发部','财务部');
+   ```
+
+   ![](img/%E5%AD%90%E6%9F%A5%E8%AF%A211.png)
+
+   1. 再查询在这些部门id中有哪些员工
+
+   ```sql
+   SELECT * FROM emp WHERE dept_id IN (SELECT id FROM dept WHERE NAME IN('开发部','财务部'));
+   ```
+
+   ![](img/%E5%AD%90%E6%9F%A5%E8%AF%A212.png)
+
+#### 小结
+
+子查询的结果是多行单列时父查询如何处理？
+放在父查询的条件位置,使用in
+
+### 子查询的结果是多行多列
+
+#### 目标
+
+能够掌握子查询的结果是多行多列的查询
+
+#### 讲解
+
+子查询结果是`多列`，在`FROM`后面作为`表`
+
+```sql
+SELECT 查询字段 FROM （子查询） 表别名 WHERE 条件;
+```
+
+子查询作为表需要取别名，否则这张表没用名称无法访问表中的字段
+
+- **查询出2011年以后入职的员工信息，包括部门名称**
+
+  1. 在员工表中查询2011-1-1以后入职的员工
+
+  ```sql
+  SELECT * FROM emp WHERE join_date > '2011-1-1';
+  ```
+
+  ![](img/%E5%AD%90%E6%9F%A5%E8%AF%A214.png)
+
+  1. 查询所有的部门信息，与上面的虚拟表中的信息组合，找出所有部门id等于dept_id
+
+  ```sql
+  SELECT * FROM dept d, (SELECT * FROM emp WHERE join_date > '2011-1-1') e WHERE e.dept_id = d.id;
+  ```
+
+  ![](img/%E5%AD%90%E6%9F%A5%E8%AF%A213.png)
+
+使用表连接：
+
+```sql
+SELECT d.*, e.* FROM dept d INNER JOIN emp e ON d.id = e.dept_id WHERE e.join_date > '2011-1-1';
+```
+
+#### 小结
+三种子查询情况：单行单列，多行单列，多行多列
+单行单列：作为父查询的条件
+多行单列：作为父查询的条件,通常使用 IN
+多行多列：作为父查询的一张表(虚拟表)
+
+## 第三章 事务的概念
+
+#### 目标
+
+1. 能够理解事务的概念
+2. 了解事务的四大特性
+
+#### 讲解
+
+##### 什么是事务
+
+​	在实际的业务开发中，有些业务操作要多次访问数据库。一个业务要发送多条SQL语句给数据库执行。需要将多次访问数据库的操作视为一个整体来执行，要么所有的SQL语句全部执行成功。如果其中有一条SQL语句失败，就进行事务的回滚，所有的SQL语句全部执行失败。
+
+##### 事务的应用场景说明
+
+
+例如: 张三给李四转账，张三账号减钱，李四账号加钱
+
+```sql
+-- 创建数据表
+CREATE TABLE account (
+	id INT PRIMARY KEY AUTO_INCREMENT,
+	NAME VARCHAR(10),
+	balance DOUBLE
+);
+
+-- 添加数据
+INSERT INTO account (NAME, balance) VALUES ('张三', 1000), ('李四', 1000);
+```
+
+模拟张三给李四转500元钱，一个转账的业务操作最少要执行下面的2条语句：
+1. 张三账号-500
+2. 李四账号+500
+```sql
+-- 1. 张三账号-500
+UPDATE account SET balance = balance - 500 WHERE id=1;
+-- 2. 李四账号+500
+UPDATE account SET balance = balance + 500 WHERE id=2;
+```
+​	假设当张三账号上-500元,服务器崩溃了。李四的账号并没有+500元，数据就出现问题了。我们需要保证其中一条SQL语句出现问题，整个转账就算失败。只有两条SQL都成功了转账才算成功。这个时候就需要用到事务。
+
+
+##### 事务的四大特性(ACID)
+| 事务特性              | 含义                                                         |
+| --------------------- | ------------------------------------------------------------ |
+| 原子性（Atomicity）   | 事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。 |
+| 一致性（Consistency） | 事务前后数据的完整性必须保持一致                             |
+| 隔离性（Isolation）   | 是指多个用户并发访问数据库时，一个用户的事务不能被其它用户的事务所干扰，多个并发事务之间数据要相互隔离，不能相互影响。 |
+| 持久性（Durability）  | 指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响 |
+#### 小结
+什么是事务？多条SQL组合再一起完成某个功能.
+
+事务四个特性？
+原子性
+一致性
+隔离性
+持久性
+
+### 手动提交事务
+
+#### 目标
+
+能够使用手动的方式提交事务
+
+#### 讲解
+
+MYSQL中可以有两种方式进行事务的操作：
+
+1. 手动提交事务
+2. 自动提交事务(默认的)
+
+ 事务有关的SQL语句：
+| SQL语句            | 描述     |
+| ------------------ | -------- |
+| start transaction; | 开启事务 |
+| commit;            | 提交事务 |
+| rollback;          | 回滚事务 |
+
+##### 手动提交事务使用步骤
+
+​    第1种情况：开启事务 -> 执行SQL语句 -> 成功 -> 提交事务
+​    第2种情况：开启事务 -> 执行SQL语句 -> 失败 -> 回滚事务
+   ![](img/事务01.png)
+
+**案例演示1**：模拟张三给李四转500元钱（成功）
+目前数据库数据如下：
+![](img/事务03.png)
+
+1. 使用DOS控制台进入MySQL
+2. 执行以下SQL语句： `1.开启事务`， `2.张三账号-500`， `3.李四账号+500`
+   ```sql
+   START TRANSACTION;
+   UPDATE account SET balance = balance - 500 WHERE id=1;
+   UPDATE account SET balance = balance + 500 WHERE id=2;
+   ```
+   ![](img/事务02.png)
+3. 使用SQLYog查看数据库：发现数据并没有改变
+   ![](img/事务03.png)
+4. 在控制台执行`commit`提交任务：
+   ![](img/事务04.png)
+5. 使用SQLYog查看数据库：发现数据改变
+   ![](img/事务05.png)
+
+---
+**案例演示2**：模拟张三给李四转500元钱（失败）
+目前数据库数据如下：
+![](img/事务05.png)
+
+1. 在控制台执行以下SQL语句：`1.开启事务`， `2.张三账号-500`
+   ```sql
+   START TRANSACTION;
+   UPDATE account SET balance = balance - 500 WHERE id=1;
+   ```
+   ![](img/事务06.png)
+2. 使用SQLYog查看数据库：发现数据并没有改变
+   ![](img/事务07.png)
+3. 在控制台执行`rollback`回滚事务：
+   ![](img/事务08.png)
+4. 使用SQLYog查看数据库：发现数据没有改变
+   ![](img/事务09.png)
+
+#### 小结
+
+1. 如何开启事务: start transaction;
+2. 如何提交事务: commit;
+3. 如何回滚事务: rollback;
+
+### 自动提交事务
+
+#### 目标
+
+了解自动提交事务
+
+能够关闭自动提交事务
+
+#### 讲解
+
+​	MySQL的每一条DML(增删改)语句都是一个单独的事务，每条语句都会自动开启一个事务，执行完毕自动提交事务，MySQL默认开始自动提交事务。
+![](img/事务10.png)
+
+1. 将金额重置为1000
+   ![](img/事务11.png)
+
+2. 执行以下SQL语句
+   ```sql
+   UPDATE account SET balance = balance - 500 WHERE id=1;
+   ```
+
+3. 使用SQLYog查看数据库：发现数据已经改变
+   ![](img/事务12.png)
+
+
+   使用SQL语句查看MySQL是否开启自动提交事务
+
+   ```sql
+show variables like '%commit%';
+-- 或
+SELECT @@autocommit;
+   ```
+   通过修改MySQL全局变量"autocommit"，取消自动提交事务
+   ![](img/事务13.png)
+   0:OFF（关闭自动提交）
+   1:ON（开启自动提交）
+
+4. 取消自动提交事务，设置自动提交的参数为OFF，执行SQL语句：`set autocommit = 0;`
+   ![](img/事务14.png)
+
+5. 在控制台执行以下SQL语句：张三-500
+   ```sql
+   UPDATE account SET balance = balance - 500 WHERE id=1;
+   ```
+   ![](img/事务15.png)
+
+6. 使用SQLYog查看数据库，发现数据并没有改变
+   ![](img/事务16.png)
+
+7. 在控制台执行`commit`提交任务
+   ![](img/事务17.png)
+
+8. 使用SQLYog查看数据库，发现数据改变
+   ![](img/事务18.png)
+
+#### 小结
+
+1. 查询事务提交状态：
+   show variables like '%commit%';
+   select @@autocommit;
+2. 关闭事务自动提交：
+   set autocommit = 0;
+
+
+
+## 总结
+
+1. 能够理解三大范式
+   1NF: 表中的字段不能再拆分
+   2NF:一个表做一件事情,表中添加主键,所有字段依赖主键
+   3NF:多张表之间使用其他表的主键
+
+2. 能够使用内连接进行多表查询
+   隐式: SELECT 字段 FROM 左表, 右表 WHERE 条件;
+
+   显示: SELECT 字段 FROM 左表 INNER JOIN 右表 ON 条件;
+
+3. 能够使用左外连接和右外连接进行多表查询
+   左外连接: SELECT 字段 FROM 左表 LEFT OUTER JOIN 右表 ON 条件;
+   右外连接: SELECT 字段 FROM 左表 RIGHT OUTER JOIN 右表 ON 条件;
+
+4. 能够使用子查询进行多表查询
+   SELECT 字段 FROM 表名 WHERE 字段=(SELECT MAX(age) FROM 表名);
+
+5. 能够理解多表查询的规律
+   1.明确查询哪些表
+   2.明确表之间的连接条件,外键=主键
+   3.根据需求
+
+6. 能够理解事务的概念
+   多条SQL语句组成一个功能,要么一起成功,要么一起失败.
+
+8. 能够在MySQL中使用事务
+   开启事务: start transaction;
+   提交事务: commit;
+   回滚事务: rollback;
+   查看是否自动提交事务: show variables like '%commit%';
+   关闭事务自动提交: set autocommit = 0;

javaEE/day08/Mybatis入门.md

@@ -0,0 +1,704 @@
+# Mybatis入门
+
+
+
+
+
+
+
+## 前言
+
+在前面我们学习MySQL数据库时，都是利用图形化客户端工具(如：idea、datagrip)，来操作数据库的。
+
+> 在客户端工具中，编写增删改查的SQL语句，发给MySQL数据库管理系统，由数据库管理系统执行SQL语句并返回执行结果。
+>
+> 增删改操作：返回受影响行数
+>
+> 查询操作：返回结果集(查询的结果)
+
+我们做为后端程序开发人员，通常会使用Java程序来完成对数据库的操作。Java程序操作数据库，现在主流的方式是：Mybatis。
+
+什么是MyBatis?
+
+- MyBatis是一款优秀的 **持久层** **框架**，用于简化JDBC的开发。
+
+- MyBatis本是 Apache的一个开源项目iBatis，2010年这个项目由apache迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。
+
+- 官网：https://mybatis.org/mybatis-3/zh/index.html 
+
+在上面我们提到了两个词：一个是持久层，另一个是框架。
+
+- 持久层：指的是就是数据访问层(dao)，是用来操作数据库的。
+
+![image-20220901114951631](assets/image-20220901114951631.png) 
+
+- 框架：是一个半成品软件，是一套可重用的、通用的、软件基础代码模型。在框架的基础上进行软件开发更加高效、规范、通用、可拓展。
+
+
+
+Mybatis课程安排：
+
+- Mybatis入门
+
+- Mybatis基础增删改查
+
+- Mybatis动态SQL
+
+接下来，我们就通过一个入门程序，让大家快速感受一下通过Mybatis如何来操作数据库。
+
+
+
+
+
+
+
+## 1. 快速入门
+
+需求：使用Mybatis查询所有用户数据。
+
+
+
+### 1.1 入门程序分析
+
+以前我们是在图形化客户端工具中编写SQL查询代码，发送给数据库执行，数据库执行后返回操作结果。
+
+![image-20221209155704203](assets/image-20221209155704203.png) 
+
+
+
+图形化工具会把数据库执行的查询结果，使用表格的形式展现出来
+
+![image-20220901121116813](assets/image-20220901121116813.png) 
+
+
+
+现在使用Mybatis操作数据库，就是在Mybatis中编写SQL查询代码，发送给数据库执行，数据库执行后返回结果。
+
+![image-20221209155904370](assets/image-20221209155904370.png)
+
+
+
+ Mybatis会把数据库执行的查询结果，使用实体类封装起来（一行记录对应一个实体类对象）
+
+![image-20221209161623051](assets/image-20221209161623051.png)
+
+
+
+Mybatis操作数据库的步骤：
+
+1. 准备工作(创建springboot工程、数据库表user、实体类User)
+
+2. 引入Mybatis的相关依赖，配置Mybatis(数据库连接信息)
+
+3. 编写SQL语句(注解/XML)
+
+
+
+
+
+### 1.2 入门程序实现
+
+#### 1.2.1 准备工作
+
+##### 1.2.1.1 创建springboot工程
+
+创建springboot工程，并导入 mybatis的起步依赖、mysql的驱动包。
+
+![image-20221209162827242](assets/image-20221209162827242.png)
+
+![image-20221209163123443](assets/image-20221209163123443.png)
+
+> 项目工程创建完成后，自动在pom.xml文件中，导入Mybatis依赖和MySQL驱动依赖
+
+~~~xml
+<!-- 仅供参考：只粘贴了pom.xml中部分内容 -->
+<dependencies>
+        <!-- mybatis起步依赖 -->
+        <dependency>
+            <groupId>org.mybatis.spring.boot</groupId>
+            <artifactId>mybatis-spring-boot-starter</artifactId>
+            <version>2.3.0</version>
+        </dependency>
+
+        <!-- mysql驱动包依赖 -->
+        <dependency>
+            <groupId>com.mysql</groupId>
+            <artifactId>mysql-connector-j</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        
+        <!-- spring单元测试 (集成了junit) -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+</dependencies>
+~~~
+
+
+
+
+
+
+
+##### 1.2.1.2 数据准备
+
+创建用户表user，并创建对应的实体类User。
+
+- 用户表：
+
+```sql
+-- 用户表
+create table user(
+    id int unsigned primary key auto_increment comment 'ID',
+    name varchar(100) comment '姓名',
+    age tinyint unsigned comment '年龄',
+    gender tinyint unsigned comment '性别, 1:男, 2:女',
+    phone varchar(11) comment '手机号'
+) comment '用户表';
+
+-- 测试数据
+insert into user(id, name, age, gender, phone) VALUES (null,'白眉鹰王',55,'1','18800000000');
+insert into user(id, name, age, gender, phone) VALUES (null,'金毛狮王',45,'1','18800000001');
+insert into user(id, name, age, gender, phone) VALUES (null,'青翼蝠王',38,'1','18800000002');
+insert into user(id, name, age, gender, phone) VALUES (null,'紫衫龙王',42,'2','18800000003');
+insert into user(id, name, age, gender, phone) VALUES (null,'光明左使',37,'1','18800000004');
+insert into user(id, name, age, gender, phone) VALUES (null,'光明右使',48,'1','18800000005');
+```
+
+![image-20220901121116813](assets/image-20220901121116813.png) 
+
+- 实体类
+
+  - 实体类的属性名与表中的字段名一一对应。
+
+```java
+public class User {
+    private Integer id;   //id（主键）
+    private String name;  //姓名
+    private Short age;    //年龄
+    private Short gender; //性别
+    private String phone; //手机号
+    
+    //省略GET, SET方法
+}
+```
+
+![image-20221209170354143](assets/image-20221209170354143.png)
+
+
+
+
+
+#### 1.2.2 配置Mybatis
+
+> 在之前使用图形化客户端工具，连接MySQL数据库时，需要配置：
+>
+> ![image-20221209172527630](assets/image-20221209172527630.png)
+>
+> 连接数据库的四大参数：
+>
+> - MySQL驱动类 
+> - 登录名
+> - 密码
+> - 数据库连接字符串
+
+基于上述分析，在Mybatis中要连接数据库，同样也需要以上4个参数配置。
+
+在springboot项目中，可以编写application.properties文件，配置数据库连接信息。我们要连接数据库，就需要配置数据库连接的基本信息，包括：driver-class-name、url 、username，password。
+
+> 在入门程序中，大家可以直接这么配置，后面会介绍什么是驱动。
+
+
+
+application.properties:
+
+```properties
+#驱动类名称
+spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
+#数据库连接的url
+spring.datasource.url=jdbc:mysql://localhost:3306/mybatis
+#连接数据库的用户名
+spring.datasource.username=root
+#连接数据库的密码
+spring.datasource.password=1234
+```
+
+> 上述的配置，可以直接复制过去，不要敲错了。 全部都是 spring.datasource.xxxx 开头。
+
+
+
+
+
+#### 1.2.3 编写SQL语句
+
+在创建出来的springboot工程中，在引导类所在包下，在创建一个包 mapper。在mapper包下创建一个接口 UserMapper ，这是一个持久层接口（Mybatis的持久层接口规范一般都叫 XxxMapper）。
+
+![image-20221209175843651](assets/image-20221209175843651.png)
+
+UserMapper：
+
+~~~java
+import com.inmind.pojo.User;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Select;
+import java.util.List;
+
+@Mapper
+public interface UserMapper {
+    
+    //查询所有用户数据
+    @Select("select id, name, age, gender, phone from user")
+    public List<User> list();
+    
+}
+~~~
+
+> @Mapper注解：表示是mybatis中的Mapper接口
+>
+> - 程序运行时：框架会自动生成接口的实现类对象(代理对象)，并给交Spring的IOC容器管理
+>
+>  @Select注解：代表的就是select查询，用于书写select查询语句
+
+
+
+#### 1.2.4 单元测试
+
+在创建出来的SpringBoot工程中，在src下的test目录下，已经自动帮我们创建好了测试类 ，并且在测试类上已经添加了注解 @SpringBootTest，代表该测试类已经与SpringBoot整合。 
+
+该测试类在运行时，会自动通过引导类加载Spring的环境（IOC容器）。我们要测试那个bean对象，就可以直接通过@Autowired注解直接将其注入进行，然后就可以测试了。 
+
+测试类代码如下： 
+
+```java
+@SpringBootTest
+public class MybatisQuickstartApplicationTests {
+	
+    @Autowired
+    private UserMapper userMapper;
+	
+    @Test
+    public void testList(){
+        List<User> userList = userMapper.list();
+        for (User user : userList) {
+            System.out.println(user);
+        }
+    }
+
+}
+```
+
+> 运行结果：
+>
+> ~~~
+> User{id=1, name='白眉鹰王', age=55, gender=1, phone='18800000000'}
+> User{id=2, name='金毛狮王', age=45, gender=1, phone='18800000001'}
+> User{id=3, name='青翼蝠王', age=38, gender=1, phone='18800000002'}
+> User{id=4, name='紫衫龙王', age=42, gender=2, phone='18800000003'}
+> User{id=5, name='光明左使', age=37, gender=1, phone='18800000004'}
+> User{id=6, name='光明右使', age=48, gender=1, phone='18800000005'}
+> ~~~
+
+
+
+### 1.3 解决SQL警告与提示
+
+默认我们在UserMapper接口上加的@Select注解中编写SQL语句是没有提示的。 如果想让idea给我们提示对应的SQL语句，我们需要在IDEA中配置与MySQL数据库的链接。 
+
+默认我们在UserMapper接口上的@Select注解中编写SQL语句是没有提示的。如果想让idea给出提示，可以做如下配置：
+
+![image-20221210143348119](assets/image-20221210143348119.png)
+
+配置完成之后，发现SQL语句中的关键字有提示了，但还存在不识别表名(列名)的情况：
+
+![image-20221210143934318](assets/image-20221210143934318.png)
+
+> 产生原因：Idea和数据库没有建立连接，不识别表信息
+>
+> 解决方案：在Idea中配置MySQL数据库连接
+
+![image-20221210144139792](assets/image-20221210144139792.png) 
+
+> 在配置的时候指定连接那个数据库，如上图所示连接的就是mybatis数据库。
+
+
+
+
+
+
+
+
+
+## 2. JDBC介绍(了解)
+
+### 2.1 介绍
+
+通过Mybatis的快速入门，我们明白了，通过Mybatis可以很方便的进行数据库的访问操作。但是大家要明白，其实java语言操作数据库呢，只能通过一种方式：使用sun公司提供的 JDBC 规范。
+
+> Mybatis框架，就是对原始的JDBC程序的封装。 
+
+那到底什么是JDBC呢，接下来，我们就来介绍一下。
+
+JDBC： ( Java DataBase Connectivity )，就是使用Java语言操作关系型数据库的一套API。
+
+![image-20221210144811961](assets/image-20221210144811961.png) 
+
+
+
+> 本质：
+>
+> - sun公司官方定义的一套操作所有关系型数据库的规范，即接口。
+>
+> - 各个数据库厂商去实现这套接口，提供数据库驱动jar包。
+>
+> - 我们可以使用这套接口(JDBC)编程，真正执行的代码是驱动jar包中的实现类。
+
+
+
+### 2.2 代码
+
+下面我们看看原始的JDBC程序是如何操作数据库的。操作步骤如下：
+
+1. 注册驱动
+2. 获取连接对象
+3. 执行SQL语句，返回执行结果
+4. 处理执行结果
+5. 释放资源
+
+> 在pom.xml文件中已引入MySQL驱动依赖，我们直接编写JDBC代码即可
+
+JDBC具体代码实现：
+
+```java
+import com.inmind.pojo.User;
+import org.junit.jupiter.api.Test;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+
+public class JdbcTest {
+    @Test
+    public void testJdbc() throws Exception {
+        //1. 注册驱动
+        Class.forName("com.mysql.cj.jdbc.Driver");
+
+        //2. 获取数据库连接
+        String url="jdbc:mysql://127.0.0.1:3306/mybatis";
+        String username = "root";
+        String password = "1234";
+        Connection connection = DriverManager.getConnection(url, username, password);
+
+        //3. 执行SQL
+        Statement statement = connection.createStatement(); //操作SQL的对象
+        String sql="select id,name,age,gender,phone from user";
+        ResultSet rs = statement.executeQuery(sql);//SQL查询结果会封装在ResultSet对象中
+
+        List<User> userList = new ArrayList<>();//集合对象（用于存储User对象）
+        //4. 处理SQL执行结果
+        while (rs.next()){
+            //取出一行记录中id、name、age、gender、phone下的数据
+            int id = rs.getInt("id");
+            String name = rs.getString("name");
+            short age = rs.getShort("age");
+            short gender = rs.getShort("gender");
+            String phone = rs.getString("phone");
+            //把一行记录中的数据，封装到User对象中
+            User user = new User(id,name,age,gender,phone);
+            userList.add(user);//User对象添加到集合
+        }
+        //5. 释放资源
+        statement.close();
+        connection.close();
+        rs.close();
+
+        //遍历集合
+        for (User user : userList) {
+            System.out.println(user);
+        }
+    }
+}
+```
+
+> DriverManager(类)：数据库驱动管理类。
+>
+> - 作用：
+>
+>   1. 注册驱动
+>
+>   2. 创建java代码和数据库之间的连接，即获取Connection对象
+>
+> Connection(接口)：建立数据库连接的对象
+>
+> - 作用：用于建立java程序和数据库之间的连接
+>
+> Statement(接口)： 数据库操作对象(执行SQL语句的对象)。
+>
+> - 作用：用于向数据库发送sql语句
+>
+> ResultSet(接口)：结果集对象（一张虚拟表）
+>
+> - 作用：sql查询语句的执行结果会封装在ResultSet中
+
+通过上述代码，我们看到直接基于JDBC程序来操作数据库，代码实现非常繁琐，所以在项目开发中，我们很少使用。  在项目开发中，通常会使用Mybatis这类的高级技术来操作数据库，从而简化数据库操作、提高开发效率。
+
+
+
+### 2.3 问题分析
+
+原始的JDBC程序，存在以下几点问题：
+
+1. 数据库链接的四要素(驱动、链接、用户名、密码)全部硬编码在java代码中
+2. 查询结果的解析及封装非常繁琐
+3. 每一次查询数据库都需要获取连接,操作完毕后释放连接, 资源浪费, 性能降低
+
+![image-20221210153407998](assets/image-20221210153407998.png)
+
+
+
+### 2.4 技术对比
+
+分析了JDBC的缺点之后，我们再来看一下在mybatis中，是如何解决这些问题的：
+
+1. 数据库连接四要素(驱动、链接、用户名、密码)，都配置在springboot默认的配置文件 application.properties中
+
+2. 查询结果的解析及封装，由mybatis自动完成映射封装，我们无需关注
+
+3. 在mybatis中使用了数据库连接池技术，从而避免了频繁的创建连接、销毁连接而带来的资源浪费。
+
+![image-20221210154324151](assets/image-20221210154324151.png)
+
+> 使用SpringBoot+Mybatis的方式操作数据库，能够提升开发效率、降低资源浪费
+
+而对于Mybatis来说，我们在开发持久层程序操作数据库时，需要重点关注以下两个方面：
+
+1. application.properties
+
+   ~~~properties
+   #驱动类名称
+   spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
+   #数据库连接的url
+   spring.datasource.url=jdbc:mysql://localhost:3306/mybatis
+   #连接数据库的用户名
+   spring.datasource.username=root
+   #连接数据库的密码
+   spring.datasource.password=1234
+   ~~~
+
+2. Mapper接口（编写SQL语句）
+
+   ~~~java
+   @Mapper
+   public interface UserMapper {
+       @Select("select id, name, age, gender, phone from user")
+       public List<User> list();
+   }
+   ~~~
+
+   
+
+ 
+
+
+
+## 3. 数据库连接池
+
+在前面我们所讲解的mybatis中，使用了数据库连接池技术，避免频繁的创建连接、销毁连接而带来的资源浪费。
+
+下面我们就具体的了解下数据库连接池。
+
+### 3.1 介绍
+
+![image-20221210160341852](assets/image-20221210160341852.png)
+
+> 没有使用数据库连接池：
+>
+> - 客户端执行SQL语句：要先创建一个新的连接对象，然后执行SQL语句，SQL语句执行后又需要关闭连接对象从而释放资源，每次执行SQL时都需要创建连接、销毁链接，这种频繁的重复创建销毁的过程是比较耗费计算机的性能。
+
+![image-20221210161016314](assets/image-20221210161016314.png)
+
+数据库连接池是个容器，负责分配、管理数据库连接(Connection)
+
+- 程序在启动时，会在数据库连接池(容器)中，创建一定数量的Connection对象
+
+允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个
+
+- 客户端在执行SQL时，先从连接池中获取一个Connection对象，然后在执行SQL语句，SQL语句执行完之后，释放Connection时就会把Connection对象归还给连接池（Connection对象可以复用）
+
+释放空闲时间超过最大空闲时间的连接，来避免因为没有释放连接而引起的数据库连接遗漏
+
+- 客户端获取到Connection对象了，但是Connection对象并没有去访问数据库(处于空闲)，数据库连接池发现Connection对象的空闲时间 > 连接池中预设的最大空闲时间，此时数据库连接池就会自动释放掉这个连接对象
+
+数据库连接池的好处：
+
+1. 资源重用
+2. 提升系统响应速度
+3. 避免数据库连接遗漏
+
+
+
+
+
+### 3.2 产品
+
+要怎么样实现数据库连接池呢？
+
+- 官方(sun)提供了数据库连接池标准（javax.sql.DataSource接口）
+
+  - 功能：获取连接 
+
+    ~~~java
+    public Connection getConnection() throws SQLException;
+    ~~~
+
+  - 第三方组织必须按照DataSource接口实现
+
+常见的数据库连接池：
+
+* C3P0
+* DBCP
+* Druid
+* Hikari (springboot默认)
+
+现在使用更多的是：Hikari、Druid  （性能更优越）
+
+- Hikari（追光者） [默认的连接池] 
+
+![image-20220901144923251](assets/image-20220901144923251.png) 
+
+* Druid（德鲁伊）
+
+  * Druid连接池是阿里巴巴开源的数据库连接池项目 
+
+  * 功能强大，性能优秀，是Java语言最好的数据库连接池之一
+
+​		
+
+如果我们想把默认的数据库连接池切换为Druid数据库连接池，只需要完成以下两步操作即可：
+
+> 参考官方地址：https://github.com/alibaba/druid/tree/master/druid-spring-boot-starter
+
+1. 在pom.xml文件中引入依赖
+
+```xml
+<dependency>
+    <!-- Druid连接池依赖 -->
+    <groupId>com.alibaba</groupId>
+    <artifactId>druid-spring-boot-starter</artifactId>
+    <version>1.2.8</version>
+</dependency>
+```
+
+2. 在application.properties中引入数据库连接配置
+
+方式1：
+
+~~~properties
+spring.datasource.druid.driver-class-name=com.mysql.cj.jdbc.Driver
+spring.datasource.druid.url=jdbc:mysql://localhost:3306/mybatis
+spring.datasource.druid.username=root
+spring.datasource.druid.password=1234
+~~~
+
+方式2：
+
+~~~properties
+spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
+spring.datasource.url=jdbc:mysql://localhost:3306/mybatis
+spring.datasource.username=root
+spring.datasource.password=1234
+~~~
+
+
+
+
+
+
+
+
+
+## 4. lombok
+
+### 4.1 介绍
+
+Lombok是一个实用的Java类库，可以通过简单的注解来简化和消除一些必须有但显得很臃肿的Java代码。
+
+![image-20221210164641266](assets/image-20221210164641266.png)
+
+> 通过注解的形式自动生成构造器、getter/setter、equals、hashcode、toString等方法，并可以自动化生成日志变量，简化java开发、提高效率。
+
+| **注解**            | **作用**                                                     |
+| ------------------- | ------------------------------------------------------------ |
+| @Getter/@Setter     | 为所有的属性提供get/set方法                                  |
+| @ToString           | 会给类自动生成易阅读的  toString 方法                        |
+| @EqualsAndHashCode  | 根据类所拥有的非静态字段自动重写 equals 方法和  hashCode 方法 |
+| @Data               | 提供了更综合的生成代码功能（@Getter  + @Setter + @ToString + @EqualsAndHashCode） |
+| @NoArgsConstructor  | 为实体类生成无参的构造器方法                                 |
+| @AllArgsConstructor | 为实体类生成除了static修饰的字段之外带有各参数的构造器方法。 |
+
+
+
+### 4.2 使用
+
+第1步：在pom.xml文件中引入依赖
+
+```xml
+<!-- 在springboot的父工程中，已经集成了lombok并指定了版本号，故当前引入依赖时不需要指定version -->
+<dependency>
+    <groupId>org.projectlombok</groupId>
+    <artifactId>lombok</artifactId>
+</dependency>
+```
+
+第2步：在实体类上添加注解
+
+```java
+import lombok.Data;
+
+@Data
+public class User {
+    private Integer id;
+    private String name;
+    private Short age;
+    private Short gender;
+    private String phone;
+}
+```
+
+> 在实体类上添加了@Data注解，那么这个类在编译时期，就会生成getter/setter、equals、hashcode、toString等方法。
+>
+> ![image-20221210170733921](assets/image-20221210170733921.png)
+
+说明：@Data注解中不包含全参构造方法，通常在实体类上，还会添加上：全参构造、无参构造
+
+~~~java
+import lombok.Data;
+
+@Data //getter方法、setter方法、toString方法、hashCode方法、equals方法
+@NoArgsConstructor //无参构造
+@AllArgsConstructor//全参构造
+public class User {
+    private Integer id;
+    private String name;
+    private Short age;
+    private Short gender;
+    private String phone;
+}
+~~~
+
+
+
+Lombok的注意事项：
+
+- Lombok会在编译时，会自动生成对应的java代码
+- 在使用lombok时，还需要安装一个lombok的插件（新版本的IDEA中自带）
+
+![image-20221210165506359](assets/image-20221210165506359.png)
+
+
+
+
+