2. 数据库技术 MySQL

第二阶段模块一 MySQL数据库

任务一 MySQL基础&SQL入门

1. 数据库的基本概念

什么是数据库

1. 数据库(DataBase) 就是存储和管理数据的仓库
2. 其本质是一个文件系统, 还是以文件的方式,将数据保存在电脑上

为什么使用数据库

数据存储方式的比较

存储方式	优点	缺点
内存	速度快	不能够永久保存,数据是临时状态的
文件	数据是可以永久保存的	使用IO流操作文件, 不方便
数据库	1.数据可以永久保存 2.方便存储和管理数据 3.使用统一的方式操作数据库(SQL)	占用资源,有些数据库需要付费(比如Oracle数据库)

通过上面的比较,我们可以看出,使用数据库存储数据, 用户可以非常方便对数据库中的数据进行增加, 删除, 修改及查询操作。

常见的数据库软件排行榜

数据库是抽象的概念，数据库软件是数据库的具体的实现

2020年数据库排行

1. Oracle
2. MySQL

开发中常见的数据库

数据库名	介绍
MySql数据库	开源免费的数据库因为免费开源、运作简单的特点，常作为中小型的项目的数据库首选。MySQL1996年开始运作，目前已经被Oracle公司收购了. MySQL6.x开始收费
Oracle数据库	收费的大型数据库，Oracle公司的核心产品。 安全性高
DB2	IBM公司的数据库产品,收费的超大型数据库。 常在银行系统中使用
SQL Server	MicroSoft 微软公司收费的中型的数据库。 C#、.net等语言常使用。 但该数据库只能运行在windows机器上，扩展性、稳定性、安全性、性能都表现平平。

为什么选择MySQL ?

1. 功能强大,足以应付web应用开发
2. 开源, 免费

2. MySQL的安装及配置

安装MySQL

• 详见 MySQL安装文档 MySQL57
• 为root用户 添加密码 确认密码 ****

Enter password: *****
mysql> show databases; —显示 数据库信息.

卸载MySQL

• 详见 MySQL卸载文档

MySQL环境变量配置

• 详见 MySQL环境变量配置文档
  为了在命令行当中在任意的XX下面都可以访问MySQL数据库(数据库启动状态下)
  > 설정 > 시스템 > 정보 > 시스템 정보 > 고급 시스템 정보 > 환경 변수
  > 시스템 변수 > 새로만들기 > 변수 이름 : MYSQL_HOME > 변수 값 : C:\Program Files\MySQL\MySQL Server 5.7 > 확인
  > 시스템 변수 > Path > 편집 > 새로 맞들기 > %MYSQL_HOME%\bin > 확인 > 확인
  确认设置成功：cmd > mysql -uroot -p****

MySQL的启动与关闭

方式一 : window服务启动 MySQL

1. 右键此电脑 --> 管理
   
2. 选择服务–> 找到MysQL服务
   
3. 右键选择 --> 启动或停止

方式二: DOS 命令方式启动

1. 首先以管理员身份 打开命令行窗口
   검색 > cmd > 명령 프롬트프(관리자 권한으로 실행)
   收搜 > cmd > 命令提示符（以管理者身份运行）
2. 启动MySql

net start mysql57

3. 关闭MySql

net stop mysql57

命令行登录数据库

• MySQL是一个需要账户名密码登录的数据库，登陆后使用，它提供了一个默认的root账号，使用安装时设置的密码即可登录。

命令	说明
mysql -u 用户名 -p 密码	使用指定用户名和密码登录当前计算机中的MySQL数据库
mysql -h 主机IP -u 用户名 -p	密码 -h 指定IP 方式,进行 登录

命令演示:

mysql -uroot -p123456
mysql -h127.0.0.1 -uroot -p123456

退出命令

exit 或者 quit

SqlYog的使用

1. 简介
   SQLyog是业界著名的Webyog公司出品的一款简洁高效、功能强大的图形化MySQL数据库管理工具。使用 SQLyog 可以快速直观地让您从世界的任何角落通过网络来维护远端的 MySQL 数据库

2. 具体安装教程 请查看
   SQLyog安装教程

MySql的目录结构

1. MySQL安装目录
   MySql的默认安装目录在 C:\Program Files\MySQL\MySQL Server 5.7

目录	目录内容
bin	放置一些可执行文件 mysql.exe
docs	文档
include	包含(头)文件
lib	依赖库
share	用于存放字符集、语言等信息。

2. MySQL配置文件 与 数据库及 数据表所在目录
   

• my.ini 文件 是 mysql 的配置文件，一般不建议去修改
• data<目录> Mysql管理的数据库文件所在的目录
  
• 几个概念
  数据库： 文件夹
  数据表： 文件
  数据： 文件中的记录

数据库管理系统

1. 什么是数据库管理系统 ?
    数据库管理系统（DataBase Management System，DBMS）：指一种操作和管理维护数据库的大型软件。
    MySQL就是一个 数据库管理系统软件, 安装了Mysql的电脑,我们叫它数据库服务器.
2. 数据库管理系统的作用
    用于建立、使用和维护数据库，对数据库进行统一的管理。
3. 数据库管理系统、数据库 和表之间的关系
    MySQL中管理着很多数据库，在实际开发环境中 一个数据库一般对应了一个的应用，数据库当中保存着多张表，每一张表对应着不同的业务，表中保存着对应业务的数据。
   

数据库表

• 数据库中以表为组织单位存储数据

• 表类似我们Java中的类,每个字段都有对应的数据类型

• 那么我们使用熟悉的Java程序来与关系型数据对比,就会发现以下关系:

类 -----> 表
类中属性 ----> 表中字段
对象 ---> 数据记录

3. SQL(重点)

SQL的概念

1） 什么是SQL ？

• 结构化查询语言(Structured Query Language)简称SQL，是一种特殊目的的编程语言，是一种数据库查询和程序设计语言，用于存取数据以及查询、更新和管理关系数据库系统。

2） SQL 的作用

• 是所有关系型数据库的统一查询规范，不同的关系型数据库都支持SQL
• 所有的关系型数据库都可以使用SQL
• 不同数据库之间的SQL 有一些区别 方言

SQL通用语法

1. SQL语句可以单行 或者 多行书写，以分号 结尾 ; （Sqlyog中可以不用写分号）
2. 可以使用空格和缩进来增加语句的可读性。
3. MySql中使用SQL不区分大小写，一般关键字大写，数据库名 表名列名 小写。
4. 注释方式

注释语法	说明
-- 空格	单行注释 --后要有空格 (java //)
/* */	多行注释
#	MySql特有的单行注释

# show databases; 单行注释
-- show databases; 单行注释
/*
	多行注释
	show databases;
*/

SQL的分类

分类	说明
数据定义语言	简称DDL(Data Definition Language)，用来定义数据库对象：数据库，表，列等。
数据操作语言	简称DML(Data Manipulation Language)，用来对数据库中表的记录(数据)进行更新。 (增删改)
数据查询语言	简称DQL(Data Query Language)，用来查询数据库中表的记录。
数据控制语言	简称DCL(Data Control Language)，用来定义数据库的访问权限和安全级别，及创建用户。(了解)

• 注： 我们重点学习 DML 与 DQL！
  

DDL操作 数据库

• 对数据库操作的分类：CRUD
  C: create 创建
  R: retrieve 查询
  U: update 修改
  D: delete(drop) 删除
  使用数据库

1. 创建数据库

命令	说明
create database 数据库名；	创建指定名称的数据库。（容易导致乱码）
create database 数据库名 character set 字符集；	创建指定名称的数据库，并且指定字符集（一般都指定utf-8）

• 代码示例

/*
方式1 直接指定数据库名进行创建
默认数据库字符集为：latin1 （容易导致乱码）
*/
CREATE DATABASE db1;
/*
方式2 指定数据库名称，指定数据库的字符集
一般都指定为 utf8,与Java中的编码保持一致
*/
CREATE DATABASE db1_1 CHARACTER SET utf8;

2. 查看/选择数据库

命令	说明
use 数据库	切换数据库
select database();	查看当前正在使用的数据库
show databases;	查看Mysql中 都有哪些数据库
show create database 数据库名；	查看一个数据库的定义信息

• 代码示例

-- 切换数据库 从db1 切换到 db1_1
USE db1_1;
-- 查看当前正在使用的数据库
SELECT DATABASE();
-- 查看Mysql中有哪些数据库
SHOW DATABASES;
-- 查看一个数据库的定义信息
SHOW CREATE DATABASE db1_1;

• 默认数据库
  information_schema ：信息数据库 保存的是其他数据库的信息
  mysql ：MySQL核心数据库 保存的是用户和权限
  performance_schema ：保存性能相关数据 监控MySQL的性能
  sys ：记录了DBA所需要的一些信息 更方便的让DBA快捷了解数据库的运行情况 (DBA：数据库管理员，对数据库进行一些调优)

3. 修改数据库

• 修改数据库字符集

命令	说明
alter database 数据库名 character set 字符集；	数据库的字符集修改操作

-- 将数据库db1 的字符集 修改为 utf8
ALTER DATABASE db1 CHARACTER SET utf8;
-- 查看当前数据库的基本信息，发现编码已更改
SHOW CREATE DATABASE db1;

4. 删除数据库

命令	说明
drop database 数据库名	从MySql中永久的删除某个数据库

• 代码示例

-- 删除某个数据库
DROP DATABASE db1_1;

DDL 操作 数据表

1. MySQL常见的数据类型

• 常用的数据类型：

类型	描述
int	整型
double	浮点型
varchar	字符串型
date	日期类型，给是为 yyyy-MM-dd ,只有年月日，没有时分秒
datetime	年月日时分秒，yyyy-MM-dd HH:mm:ss
char	字符串型（java字符）

• 注意：MySQL中的 char类型与 varchar类型，都对应了 Java中的字符串类型，区别在于：
  • char类型是固定长度的： 根据定义的字符串长度分配足够的空间。
  • varchar类型是可变长度的： 只使用字符串长度所需的空间
• 比如：保存字符串 “abc”
  • x char(10) 占用10个字节
  • y varchar(10) 占用3个字节
• 适用场景：
  • char类型适合存储 固定长度的字符串，比如 密码 ，性别一类
  • varchar类型适合存储 在一定范围内，有长度变化的字符串
• 详细的数据类型（了解即可）

2. 创建表

• 语法格式：

CREATE TABLE 表名(
	字段名称1 字段类型（长度），
	字段名称2 字段类型 注意 最后一列不要加逗号
)；

• 需求1： 创建商品分类表

表名：category
表中字段：
	分类ID ：cid ,为整型
	分类名称：cname，为字符串类型，指定长度20

- 切换到数据库 db1
USE db1;

- 创建表
CREATE TABLE category(
	cid INT,
	cname VARCHAR(20)
);

• 需求2： 创建测试表

表名： test1
表中字段：
	测试ID ： tid ,为整型
	测试时间： tdate , 为年月日的日期类型

- 创建测试表
CREATE TABLE test1(
	tid INT, 
	tdate DATE 
); 

• 需求3： 快速创建一个表结构相同的表（复制表结构）

- 语法格式:
create table 新表明 like 旧表名

- 代码示例
CREATE TABLE test2 LIKE test1; 	-- 创建一个表结构与 test1 相同的 test2表
DESC test2; 					-- 查看表结构

3. 查看表

命令	说明
show tables;	查看当前数据库中的所有表名
desc 表名；	查看数据表的结构

- 代码示例
SHOW TABLES; 				-- 查看当前数据库中的所有表名
DESC category; 				-- 显示当前数据表的结构
SHOW CREATE TABLE category; -- 查看创建表的SQL语句

4. 删除表

命令	说明
drop table 表名；	删除表（从数据库中永久删除某一张表）
drop table if exists 表名；	判断表是否存在， 存在的话就删除,不存在就不执行删除

- 代码示例
DROP TABLE test1;			-- 直接删除 test1 表
DROP TABLE IF EXISTS test2; -- 先判断 再删除test2表

5. 修改表

1） 修改表名

- 语法格式
rename table 旧表名 to 新表名

- 将category表 改为 category1
RENAME TABLE category TO category1;

2） 修改表的字符集

- 语法格式
alter table 表名 character set 字符集

- 将category表的字符集 修改为gbk
alter table category character set gbk;

3）向表中添加列， 关键字 ADD

- 语法格式：
alert table 表名 add 字段名称 字段类型

- 为分类表添加一个新的字段为 分类描述 cdesc varchar(20)
ALTER TABLE category ADD cdesc VARCHAR(20);

4）修改表中列的 数据类型或长度 ， 关键字 MODIFY

- 语法格式：
alter table 表名 modify 字段名称 字段类型

- 对分类表的描述字段进行修改，类型varchar(50)
ALTER TABLE category MODIFY cdesc VARCHAR(50);

5）修改列名称 , 关键字 CHANGE

- 语法格式
alter table 表名 change 旧列名 新列名 类型(长度);

- 对分类表中的 desc字段进行更换, 更换为 description varchar(30)
ALTER TABLE category CHANGE cdesc description VARCHAR(30);

6）删除列 ，关键字 DROP

- 语法格式
alter table 表名 drop 列名;

- 删除分类表中description这列
ALTER TABLE category DROP description;

DML 操作表中数据

SQL中的DML 用于对表中的数据进行增删改操作

1. 插入数据

- 语法格式：
insert into 表名 （字段名1，字段名2...） values(字段值1，字段值2...);

1）代码准备，创建一个学生表：
表名：student
表中字段：
	学员ID, sid int
	姓名， sname varchar(20)
	年龄， age int
	性别， sex char(1)
	地址， address varchar(40)
	
# 创建学生表
CREATE TABLE student(
	sid INT,
	sname VARCHAR(20),
	age INT,
	sex CHAR(1),
	address VARCHAR(40)
);

2）向 学生表中添加数据，3种方式
- 方式1： 插入全部字段， 将所有字段名都写出来
INSERT INTO student (sid,sname,age,sex,address) VALUES(1,'孙悟空',20,'男','花果山');
- 方式2： 插入全部字段，不写字段名
INSERT INTO student VALUES(2,'孙悟饭',10,'男','地球');
- 方式3：插入指定字段的值
INSERT INTO category (cname) VALUES('白骨精');

• 注意：
  1）值与字段必须要对应，个数相同&数据类型相同
  2）值的数据大小，必须在字段指定的长度范围内
  3）varchar char date类型的值必须使用单引号，或者双引号 包裹。建议使用单引号
  4）如果要插入空值，可以忽略不写，或者插入null
  5）如果插入指定字段的值，必须要上写列名

2. 更改数据

- 语法格式1：不带条件的修改
update 表名 set 列名 = 值
- 语法格式2：带条件的修改
update 表名 set 列名 = 值 [where 条件表达式：字段名 = 值 ]

1) 不带条件修改，将所有的性别改为女（慎用！！）
UPDATE student SET sex = '女';
2) 带条件的修改，将sid 为3的学生，性别改为男
UPDATE student SET sex = '男' WHERE sid = 3;
3) 一次修改多个列， 将sid为 2 的学员，年龄改为 20，地址改为 北京
UPDATE student SET age = 20,address = '北京' WHERE sid = 2;

3. 删除数据

- 语法格式1：删除所有数据
delete from 表名 
- 语法格式2： 指定条件 删除数据 
delete from 表名 [where 字段名 = 值]

1. 删除 sid 为 1 的数据 
DELETE FROM student WHERE sid = 1; 
2. 删除所有数据 
DELETE FROM student;	-- 不推荐. 有多少条记录 就执行多少次删除操作. 效率低
truncate table student;	-- 推荐. 先删除整张表, 然后再重新创建一张一模一样的表. 效率高

• 如果要删除表中的所有数据,有两种做法
  1.delete from 表名; 不推荐. 有多少条记录 就执行多少次删除操作. 效率低
  2.truncate table 表名: 推荐. 先删除整张表, 然后再重新创建一张一模一样的表. 效率高

DQL 查询表中数据

1. 准备数据

#创建员工表
表名 emp
表中字段：
	eid 员工id，int
	ename 姓名，varchar
	sex 性别，char
	salary 薪资，double
	hire_date 入职时间，date
	dept_name 部门名称，varchar

#创建员工表
CREATE TABLE emp(
	eid INT,
	ename VARCHAR(20),
	sex CHAR(1),
	salary DOUBLE,
	hire_date DATE,
	dept_name VARCHAR(20)
);

#添加数据
INSERT INTO emp VALUES(1,'孙悟空','男',7200,'2013-02-04','教学部');
INSERT INTO emp VALUES(2,'猪八戒','男',3600,'2010-12-02','教学部');
INSERT INTO emp VALUES(3,'唐僧','男',9000,'2008-08-08','教学部');
INSERT INTO emp VALUES(4,'白骨精','女',5000,'2015-10-07','市场部');
INSERT INTO emp VALUES(5,'蜘蛛精','女',5000,'2011-03-14','市场部');
INSERT INTO emp VALUES(6,'玉兔精','女',200,'2000-03-14','市场部');
INSERT INTO emp VALUES(7,'林黛玉','女',10000,'2019-10-07','财务部');
INSERT INTO emp VALUES(8,'黄蓉','女',3500,'2011-09-14','财务部');
INSERT INTO emp VALUES(9,'吴承恩','男',20000,'2000-03-14',NULL);
INSERT INTO emp VALUES(10,'孙悟饭','男', 10,'2020-03-14','财务部');
INSERT INTO emp VALUES(11,'兔八哥','女', 300,'2010-03-14','财务部');

2. 简单查询

• 查询不会对数据库中的数据进行修改.只是一种显示数据的方式 SELECT

- 语法格式
select 列名 from 表名

- 需求1： 查询emp中的 所有数据 
SELECT * FROM emp; 					-- 使用 * 表示所有列 

- 需求2： 查询emp表中的所有记录，仅显示id和name字段 
SELECT eid,ename FROM emp; 

- 需求3： 将所有的员工信息查询出来，并将列名改为中文别名查询，使用关键字 as 
SELECT
	eid AS '编号',					-- 使用 AS关键字,为列起别名
	ename AS '姓名' ,
	sex AS '性别',
	salary AS '薪资',
	hire_date '入职时间', 			-- AS 可以省略
	dept_name '部门名称'
FROM emp; 

- 需求4：查询一共有几个部门 使用去重关键字 distinct 
SELECT DISTINCT dept_name FROM emp; -- 使用distinct 关键字,去掉重复部门信息

- 需求5: 将所有员工的工资 +1000 元进行显示 运算查询 (查询结果参与运算) 
SELECT ename , salary + 1000 FROM emp;

3. 条件查询

• 如果查询语句中没有设置条件,就会查询所有的行信息,在实际应用中,一定要指定查询条件,对记录进行过滤

• 运算符

1. 比较运算符

运算符	说明
> < <= >= = <> !=	大于、小于、大于(小于)等于、不等于
BETWEEN …AND…	显示在某一区间的值 例如: 2000-10000之间： Between 2000 and 10000 包括5000 10000
IN(集合)	集合表示多个值,使用逗号分隔,例如: name in (悟空，八戒) in中的每个数据都会作为一次条件,只要满足条件就会显示
LIKE ‘%张%’	模糊查询
IS NULL	查询某一列为NULL的值, 注: 不能写 = NULL

2. 逻辑运算符

运算符	说明
And &&	多个条件同时成立
Or
Not	不成立，取反。

• 模糊查询 通配符

通配符	说明
%	表示匹配任意多个字符串,
_	表示匹配 一个字符

- 语法格式
select 列名 from 表名 where 条件表达式
* 先取出表中的每条数据,满足条件的数据就返回,不满足的就过滤掉

- 需求1:
# 查询员工姓名为黄蓉的员工信息
# 查询薪水价格为5000的员工信息
# 查询薪水价格不是5000的所有员工信息
# 查询薪水价格大于6000元的所有员工信息
# 查询薪水价格在5000到10000之间所有员工信息
# 查询薪水价格是3600或7200或者20000的所有员工信息
- 代码实现
# 查询员工姓名为黄蓉的员工信息
-- 1.查哪张表 2.查那些字段 3.查询条件
SELECT * FROM emp WHERE ename = '黄蓉';
# 查询薪水价格为5000的员工信息
SELECT * FROM emp WHERE salary = 5000;
# 查询薪水价格不是5000的所有员工信息
SELECT * FROM emp WHERE salary != 5000;
SELECT * FROM emp WHERE salary <> 5000;
# 查询薪水价格大于6000元的所有员工信息
SELECT * FROM emp WHERE salary > 6000;
# 查询薪水价格在5000到10000之间所有员工信息
SELECT * FROM emp WHERE salary BETWEEN 5000 AND 10000;
# 查询薪水价格是3600或7200或者20000的所有员工信息
-- 方式1: or
SELECT * FROM emp WHERE salary = 3600 OR salary = 7200 OR salary = 20000;
-- 方式2: in() 匹配括号中指定的参数
SELECT * FROM emp WHERE salary IN(3600,7200,20000);

- 需求2:
# 查询含有'精'字的所有员工信息
# 查询以'孙'开头的所有员工信息
# 查询第二个字为'兔'的所有员工信息
# 查询没有部门的员工信息
# 查询有部门的员工信息
- 代码实现
# 查询含有'精'字的所有员工信息
SELECT * FROM emp WHERE ename LIKE '%精%';
# 查询以'孙'开头的所有员工信息
SELECT * FROM emp WHERE ename LIKE '孙%';
# 查询第二个字为'兔'的所有员工信息
SELECT * FROM emp WHERE ename LIKE '_兔%';
# 查询没有部门的员工信息
-- SELECT * FROM emp WHERE dept_name = NULL;
SELECT * FROM emp WHERE dept_name IS NULL;
# 查询有部门的员工信息
SELECT * FROM emp WHERE dept_name IS NOT NULL;

任务二 MySql单表&约束&事务

1. DQL操作单表

创建数据库,复制表

• 创建一个新的数据库 db2
  CREATE DATABASE db2 CHARACTER SET utf8;
• 将db1数据库中的 emp表 复制到当前 db2数据库
  

排序

• ORDER BY
• 通过 ORDER BY 子句,可以将查询出的结果进行排序(排序只是显示效果,不会影响真实数据)

语法结构
SELECT 字段名 FROM 表名 [WHERE 字段 = 值] ORDER BY 字段名 [ASC / DESC]

ASC 表示升序排序(默认)
DESC 表示降序排序

- 排序方式
1 单列排序
只按照某一个字段进行排序, 就是单列排序
需求: 使用 salary 字段,对emp 表数据进行排序 (升序/降序)
-- 默认升序排序 ASC
SELECT * FROM emp ORDER BY salary;
-- 降序排序
SELECT * FROM emp ORDER BY salary DESC;

2 组合排序
同时对多个字段进行排序, 如果第一个字段相同 就按照第二个字段进行排序,以此类推
需求: 在薪水排序的基础上,再使用id进行排序, 如果薪水相同就以id 做降序排序
-- 组合排序
SELECT * FROM emp ORDER BY salary DESC, eid DESC;

聚合函数

• count() sum() max() min() avg()
• 之前我们做的查询都是横向查询，它们都是根据条件一行一行的进行判断，而使用聚合函数查询是纵向查询，它是对某一列的值进行计算，然后返回一个单一的值(另外聚合函数会忽略null空值。)；
• 我们来学习5个聚合函数

聚合函数	作用
count(字段)	统计指定列不为NULL的记录行数
sum(字段)	计算指定列的数值和
max(字段)	计算指定列的最大值
min(字段)	计算指定列的最小值
avg(字段)	计算指定列的平均值

语法结构
SELECT 聚合函数(字段名) FROM 表名;

需求1:
#1 查询员工的总数
#2 查看员工总薪水、最高薪水、最小薪水、薪水的平均值
#3 查询薪水大于4000员工的个数
#4 查询部门为'教学部'的所有员工的个数
#5 查询部门为'市场部'所有员工的平均薪水

SQL实现
#1 查询员工的总数
-- 统计表中的记录条数 使用 count()
SELECT COUNT(eid) FROM emp; -- 使用某一个字段
SELECT COUNT(*) FROM emp; -- 使用 *
SELECT COUNT(1) FROM emp; -- 使用 1,与 * 效果一样
-- 下面这条SQL 得到的总条数不准确,因为count函数忽略了空值
-- 所以使用时注意不要使用带有null的列进行统计
SELECT COUNT(dept_name) FROM emp;

#2 查看员工总薪水、最高薪水、最小薪水、薪水的平均值
-- sum函数求和, max函数求最大, min函数求最小, avg函数求平均值
SELECT
	SUM(salary) AS '总薪水',
	MAX(salary) AS '最高薪水',
	MIN(salary) AS '最低薪水',
	AVG(salary) AS '平均薪水'
FROM emp;

#3 查询薪水大于4000员工的个数
SELECT COUNT(*) FROM emp WHERE salary > 4000;

#4 查询部门为'教学部'的所有员工的个数
SELECT COUNT(*) FROM emp WHERE dept_name = '教学部';

#5 查询部门为'市场部'所有员工的平均薪水
SELECT AVG(salary) AS '市场部平均薪资'
FROM emp
WHERE dept_name = '市场部';

分组

• GROUP BY
• 分组查询指的是使用 GROUP BY 语句,对查询的信息进行分组,相同数据作为一组
• 分析: GROUP BY 分组过程
  

语法格式
SELECT 分组字段/聚合函数 FROM 表名 GROUP BY 分组字段 [HAVING 条件];

需求1: 通过性别字段 进行分组
-- 按照性别进行分组操作
SELECT * FROM emp GROUP BY sex; -- 注意 这样写没有意义
注意:分组时可以查询要分组的字段, 或者使用聚合函数进行统计操作.
* 查询其他字段没有意义
需求: 通过性别字段 进行分组,求各组的平均薪资
SELECT sex, AVG(salary) FROM emp GROUP BY sex;

需求2:
#1.查询所有部门信息
#2.查询每个部门的平均薪资
#3.查询每个部门的平均薪资, 部门名称不能为null

SQL实现
#1. 查询有几个部门
SELECT dept_name AS '部门名称' FROM emp GROUP BY dept_name;
SELECT DISTINCT dept_name FROM emp ;?????? 区别
#2.查询每个部门的平均薪资
SELECT
dept_name AS '部门名称',
AVG(salary) AS '平均薪资'
FROM emp GROUP BY dept_name;
#3.查询每个部门的平均薪资, 部门名称不能为null
SELECT
dept_name AS '部门名称',
AVG(salary) AS '平均薪资'
FROM emp WHERE dept_name IS NOT NULL GROUP BY dept_name;

需求3:
# 查询平均薪资大于6000的部门.
分析:
1) 需要在分组后,对数据进行过滤,使用 关键字 hiving
2) 分组操作中的having子语句，是用于在分组后对数据进行过滤的，作用类似于where条件。
SQL实现:
# 查询平均薪资大于6000的部门
-- 需要在分组后再次进行过滤,使用 having
SELECT dept_name ,
	   AVG(salary)
FROM emp WHERE dept_name IS NOT NULL GROUP BY dept_name HAVING AVG(salary) > 6000 ;

• where 与 having的区别

过滤方式	特点
where	where 进行分组前的过滤 where 后面不能写 聚合函数
having	having 是分组后的过滤 having 后面可以写 聚合函数

limit关键字

• limit 关键字的作用
  1 limit是限制的意思, 用于限制返回的查询结果的行数 (可以通过limit指定查询多少行数据)
  2 limit 语法是 MySql的方言,用来完成分页
• 参数说明
  limit offset , length; 关键字可以接受一个 或者两个 为0 或者正整数的参数
  offset 起始行数, 从0开始记数, 如果省略 则默认为 0.
  length 返回的行数

语法结构
SELECT 字段1,字段2... FROM 表名 LIMIT offset , length;

需求1:
# 查询emp表中的前 5条数据
# 查询emp表中 从第4条开始,查询6条
SQL实现
# 查询emp表中的前 5条数据
-- 参数1 起始值,默认是0 , 参数2 要查询的条数
SELECT * FROM emp LIMIT 5;
SELECT * FROM emp LIMIT 0 , 5;
# 查询emp表中 从第4条开始,查询6条
-- 起始值默认是从0开始的.
SELECT * FROM emp LIMIT 3 , 6;

需求2: 
分页操作 每页显示3条数据
SQL实现
-- 分页操作 每页显示3条数据
SELECT * FROM emp LIMIT 0,3; -- 第1页
SELECT * FROM emp LIMIT 3,3; -- 第2页 2-1=1 1*3=3
SELECT * FROM emp LIMIT 6,3; -- 第三页

- 分页公式 起始索引 = (当前页 - 1) * 每页条数
- limit是MySql中的方言

2. SQL约束

• 对数据进行一定的限制，来保证数据的完整性 有效性 正确性
  主键约束：PRIMARY KEY
  唯一约束：UNIQUE
  非空约束：NOT MULL
  外键约束：FOREIGN KEY
  默认值：DEFAULT

主键约束

• PRIMARY KEY
• 特点：不可重复 唯一 非空
• 作用：用来表示数据库中的每一条记录

1. 添加主键约束

语法格式（创建表时）
字段名 字段类型 primary key

1) 需求: 创建一个带主键的表
# 方式1 创建一个带主键的表
CREATE TABLE emp2(
	-- 设置主键 唯一 非空
	eid INT PRIMARY KEY,
	ename VARCHAR(20),
	sex CHAR(1)
);
DESC emp2;
-- 删除表
DROP TABLE emp2;
-- 方式2 创建一个带主键的表
CREATE TABLE emp2(
	eid INT ,
	ename VARCHAR(20),
	sex CHAR(1),
	-- 指定主键为 eid字段
	PRIMARY KEY(eid)
);

-- 方式3 创建一个带主键的表
CREATE TABLE emp2(
eid INT ,
ename VARCHAR(20),
sex CHAR(1)
)
-- 创建的时候不指定主键,然后通过 DDL语句进行设置
ALTER TABLE emp2 ADD PRIMARY KEY(eid);

DESC 查看表结构
-- 查看表的详细信息
DESC emp2;

2) 测试主键的唯一性 非空性
# 正常插入一条数据
INSERT INTO emp2 VALUES(1,'宋江','男');
# 插入一条数据,主键为空
-- Column 'eid' cannot be null 主键不能为空
INSERT INTO emp2 VALUES(NULL,'李逵','男');
# 插入一条数据,主键为 1
-- Duplicate entry '1' for key 'PRIMARY' 主键不能重复
INSERT INTO emp2 VALUES(1,'孙二娘','女');

- 哪些字段可以作为主键 ?
1. 通常针对业务去设计主键,每张表都设计一个主键id
2. 主键是给数据库和程序使用的,跟最终的客户无关,所以主键没有意义没有关系,只要能够保证不重复
就好,比如 身份证就可以作为主键.

2. 删除主键约束

删除 表中的主键约束 (了解)
-- 使用DDL语句 删除表中的主键
ALTER TABLE emp2 DROP PRIMARY KEY;
DESC emp2;

3. 主键的自增

注: 主键如果让我们自己添加很有可能重复,我们通常希望在每次插入新记录时,数据库自动生成主键字段
的值.
关键字:
AUTO_INCREMENT 表示自动增长(字段类型必须是整数类型)

1) 创建主键自增的表
-- 创建主键自增的表
CREATE TABLE emp2(
-- 关键字 AUTO_INCREMENT,主键类型必须是整数类型
eid INT PRIMARY KEY AUTO_INCREMENT,
ename VARCHAR(20),
sex CHAR(1)
);

2) 添加数据 观察主键的自增
INSERT INTO emp2(ename,sex) VALUES('张三','男');
INSERT INTO emp2(ename,sex) VALUES('李四','男');
INSERT INTO emp2 VALUES(NULL,'翠花','女');
INSERT INTO emp2 VALUES(NULL,'艳秋','女');

4. 修改主键自增的起始值

默认地 AUTO_INCREMENT 的开始值是 1，如果希望修改起始值,请使用下面的方式
-- 创建主键自增的表,自定义自增其实值
CREATE TABLE emp2(
eid INT PRIMARY KEY AUTO_INCREMENT,
ename VARCHAR(20),
sex CHAR(1)
)AUTO_INCREMENT=100;
-- 插入数据,观察主键的起始值
INSERT INTO emp2(ename,sex) VALUES('张百万','男');
INSERT INTO emp2(ename,sex) VALUES('艳秋','女');

5. DELETE和TRUNCATE对自增长的影响
   删除表中所有数据有两种方式

清空表数据的方式	特点
DELETE	只是删除表中所有数据,对自增没有影响
TRUNCATE	truncate 是将整个表删除掉,然后创建一个新的表自增的主键,重新从 1开始

测试1: delete 删除表中所有数据
-- 目前最后的主键值是 101
SELECT * FROM emp2;
-- delete 删除表中数据,对自增没有影响
DELETE FROM emp2;
-- 插入数据 查看主键
INSERT INTO emp2(ename,sex) VALUES('张百万','男');
INSERT INTO emp2(ename,sex) VALUES('艳秋','女');

测试2: truncate删除 表中数据
-- 使用 truncate 删除表中所有数据,
TRUNCATE TABLE emp2;
-- 插入数据 查看主键
INSERT INTO emp2(ename,sex) VALUES('张百万','男');
INSERT INTO emp2(ename,sex) VALUES('艳秋','女');

非空约束

• NOT NULL
• 非空约束的特点: 某一列不予许为空

语法格式
字段名 字段类型 not null

需求1: 为 ename 字段添加非空约束
# 非空约束
CREATE TABLE emp2(
	eid INT PRIMARY KEY AUTO_INCREMENT,
	-- 添加非空约束, ename字段不能为空
	ename VARCHAR(20) NOT NULL,
	sex CHAR(1)
);

唯一约束

• UNIQUE
• 唯一约束的特点: 表中的某一列的值不能重复( 对null不做唯一的判断 )

语法格式
字段名 字段类型 unique

1) 添加唯一约束
#创建emp3表 为ename 字段添加唯一约束
CREATE TABLE emp3(
	eid INT PRIMARY KEY AUTO_INCREMENT,
	ename VARCHAR(20) UNIQUE,
	sex CHAR(1)
);

2) 测试唯一约束
-- 测试唯一约束 添加一条数据
INSERT INTO emp3 (ename,sex) VALUES('张百万','男');
-- 添加一条 ename重复的 数据
-- Duplicate entry '张百万' for key 'ename' ename不能重复
INSERT INTO emp3 (ename,sex) VALUES('张百万','女');

• 主键约束与唯一约束的区别:
  1 主键约束 唯一且不能够为空 唯一+非空
  2 唯一约束,唯一 但是可以为空 唯一+可空
  3 一个表中只能有一个主键 , 但是可以有多个唯一约束

外键约束

• FOREIGN KEY
• FOREIGN KEY 表示外键约束，将在多表中学习。

默认值

• DEFAULT
• 默认值约束 用来指定某列的默认值

语法格式
字段名 字段类型 DEFAULT 默认值

1) 创建emp4表, 性别字段默认 女
-- 创建带有默认值的表
CREATE TABLE emp4(
	eid INT PRIMARY KEY AUTO_INCREMENT,
	-- 为ename 字段添加默认值
	ename VARCHAR(20),
	sex CHAR(1) DEFAULT '女'
);

2) 测试 添加数据使用默认值
-- 添加数据 使用默认值
INSERT INTO emp4(ename,sex) VALUES(DEFAULT,'男');
INSERT INTO emp4(sex) VALUES('女');
-- 不使用默认值
INSERT INTO emp4(ename,sex) VALUES('艳秋','女');

3.数据库事务

什么是事务

• 事务
  事务是一个整体,由一条或者多条SQL 语句组成,这些SQL语句要么都执行成功,要么都执行失败, 只要有一条SQL出现异常,整个操作就会回滚,整个业务执行失败
  比如: 银行的转账业务,张三给李四转账500元 , 至少要操作两次数据库, 张三 -500, 李四 + 500,这中间任何一步出现问题,整个操作就必须全部回滚, 这样才能保证用户和银行都没有损失.
• 回滚
  即在事务运行的过程中发生了某种故障，事务不能继续执行，系统将事务中对数据库的所有已完成的操作全部撤销，滚回到事务开始时的状态。（在提交之前执行）

模拟转账操作

1) 创建 账户表
	-- 创建账户表
	CREATE TABLE account(
	-- 主键
	id INT PRIMARY KEY AUTO_INCREMENT,
	-- 姓名
	NAME VARCHAR(10),
	-- 余额
	money DOUBLE
);
-- 添加两个用户
INSERT INTO account (NAME, money) VALUES ('tom', 1000), ('jack', 1000);

2) 模拟tom 给 jack 转 500 元钱，一个转账的业务操作最少要执行下面的 2 条语句：
-- tom账户 -500元
UPDATE account SET money = money - 500 WHERE NAME = 'tom';
-- jack账户 + 500元
UPDATE account SET money = money + 500 WHERE NAME = 'jack';

注:
假设当tom 账号上 -500 元,服务器崩溃了。jack 的账号并没有+500 元，数据就出现问题了。
我们要保证整个事务执行的完整性,要么都成功, 要么都失败. 这个时候我们就要学习如何操作事务.

MySql事务操作

• MYSQL 中可以有两种方式进行事务的操作：
  1 手动提交事务 start transaction; … commit;
  2 自动提交事务 set @@autocommit=off/on;

1 手动提交事务
1.1 语法格式

功能	语句
开启事务	start transaction; 或者 BEGIN; 这个语句显式地标记一个事务的起始点。
提交事务	commit; 表示提交事务，即提交事务的所有操作，具体地说，就是将事务中所有对数据库的更新都写到磁盘上的物理数据库中，事务正常结束。
回滚事务	rollback; 表示撤销事务，即在事务运行的过程中发生了某种故障，事务不能继续执行，系统将事务中对数据库的所有已完成的操作全部撤销，回滚到事务开始时的状态

1.2 手动提交事务流程
执行成功的情况： 开启事务 -> 执行多条 SQL 语句 -> 成功提交事务
执行失败的情况： 开启事务 -> 执行多条 SQL 语句 -> 事务的回滚

1.3 成功案例 演示
模拟张三给李四转 500 元钱

1 命令行登录数据库
2 使用db2数据库
USE db2;

3.1 开启事务
start transaction;
3.2 tom账户 -500
update account set money = money - 500 where name = 'tom'
3.3 jack账户 +500
update account set money = money + 500 where name = 'jack';

4 此时我们使用 sqlYog查看表,发现数据并没有改变

5 在控制台执行 commit 提交事务
commit;

6  再次使用sqlYog查看, 发现数据在事务提交之后,发生改变

1.4 事务回滚演示
如果事务中，有某条sql语句执行时报错了，我们没有手动的commit，那整个事务会自动回滚

1) 命令行 开启事务
start transaction;
2) 插入两条数据
INSERT INTO account VALUES(NULL,'张百万',3000);
INSERT INTO account VALUES(NULL,'有财',3500);
3) 不去提交事务 直接关闭窗口,发生回滚操作,数据没有改变
注:如果事务中 SQL 语句没有问题，commit 提交事务，会对数据库数据的数据进行改变。 如果事务中 SQL 语句有问题，rollback 回滚事务，会回退到开启事务时的状态。

2 自动提交事务
MySQL 默认每一条 DML(增删改)语句都是一个单独的事务，每条语句都会自动开启一个事务，语句执行完毕 自动提交事务，MySQL 默认开始自动提交事务
（MySQL默认是自动提交事务）
2.1 自动提交事务演示
2.1 1) 将tom账户金额 +500元

2.1 2) 使用 SQLYog 查看数据库：发现数据已经改变

2.2 取消自动提交

MySQL默认是自动提交事务,设置为手动提交.

1)登录mysql，查看autocommit状态。
-- on ：自动提交
-- off : 手动提交
SHOW VARIABLES LIKE 'autocommit';

2）把 autocommit 改成 off;
SET @@autocommit=off;

3) 再次修改,需要提交之后才生效
将jack 账户金额 -500元
-- 选择数据库
use db2;
-- 修改数据
update account set money = money - 500 where name = 'jack';
-- 手动提交
commit;

事务的四大特性 ACID

• 原子性，一致性，隔离性，持久性

特性	含义
原子性	每个事务都是一个整体，不可再拆分， 事务中所有的 SQL 语句要么都执行成功， 要么都失败。
一致性	事务在执行前数据库的状态与执行后数据库的状态保持一致。 如：转账前2个人的 总金额是 2000，转账后 2 个人总金额也是 2000.
隔离性	事务与事务之间不应该相互影响，执行时保持隔离的状态.???
持久性	一旦事务执行成功，对数据库的修改是持久的。就算关机，数据也是要保存下来的.

Mysql 事务隔离级别(了解)

• 数据并发访问
   一个数据库可能拥有多个访问客户端,这些客户端都可以并发方式访问数据库. 数据库的相同数据可能被多个事务同时访问,如果不采取隔离措施,就会导致各种问题, 破坏数据的完整性

• 并发访问会产生的问题
   事务在操作时的理想状态： 所有的事务之间保持隔离，互不影响。因为并发操作，多个用户同时访问同一个 数据。可能引发并发访问的问题，可以通过设置不同的隔离级别来解决对应的问题。

并发访问的问题	说明
脏([zāng])读	一个事务读取到了另一个事务中尚未提交的数据
不可重复读	一个事务中两次读取的数据内容不一致, 要求的是在一个事务中多次读取时数据是一致的. 这是进行 update 操作时引发的问题
幻读	一个事务中,某一次的 select 操作得到的结果所表征的数据状态, 无法支撑后续的业务操作. 查询得到的数据状态不准确,导致幻读. 如：表中没有id=2的数据，insert id=2的数据，报错有id=2的数据

• 四种隔离级别
  1 通过设置隔离级别,可以防止上面的三种并发问题.
  2 MySQL数据库有四种隔离级别 上面的级别最低，下面的级别最高。
   (注：隔离级别从小到大安全性越来越高，但效率越来越低，
   根据不同的情况选择不同的隔离级别)
   ✔ 会出现问题
   ✘ 不会出现问题

级别	名字	隔离级别	脏读	不可重复读	幻读	数据库的默认隔离级别
1	读未提交	read uncommitted	✔	✔	✔
2	读已提交	read committed	✘	✔	✔	Oracle和SQLServer
3	可重复读	repeatable read	✘	✘	✔	MySql(默认)
4	串行化	serializable	✘	✘	✘

• 隔离级别相关命令

1) 查看事务隔离级别
select @@tx_isolation;

2) 设置事务隔离级别，需要退出 MySQL 再重新登录才能看到隔离级别的变化
set global transaction isolation level 级别名称;
read uncommitted 读未提交
read committed 读已提交
repeatable read 可重复读
serializable 串行化
例如: 修改隔离级别为 读未提交
set global transaction isolation level read uncommitted;
重新查询还是REPEATABLE-READ默认级别，需要从新开之后查看，会看到修改后的级别
select @@tx_isolation;

隔离性问题演示

• 脏读演示
  脏读: 一个事务读取到了另一个事务中尚未提交的数据

1. 打开窗口登录 MySQL，设置全局的隔离级别为最低
	1) 登录是MySQL
	2) 使用db2 数据库
		use db2;
	3) 设置隔离级别为最低 读未提交
		set global transaction isolation level read uncommitted;
2. 关闭窗口,开一个新的窗口A ,再次查询隔离级别
	1) 开启新的 窗口A
	2) 查询隔离级别
		select @@tx_isolation;
3. 再开启一个新的窗口 B
	1) 登录数据库
	2) 选择数据库
		use db2;
	3) 开启事务
		start transaction;
	4) 查询
		select * from account;
4. A窗口执行
	1) 选择数据库
		use db2;
	2) 开启事务
		start transaction;
	3) 执行修改操作
		-- tom账户 -500元
		UPDATE account SET money = money - 500 WHERE NAME = 'tom';
		-- jack账户 + 500元
		UPDATE account SET money = money + 500 WHERE NAME = 'jack';
5. B 窗口查询数据
	1) 查询账户信息
		select * from account;

6. A窗口转账异常,进行回滚
	rollback;
7. B 窗口再次查询 账户
	select * from account;

• 解决脏读问题
   脏读非常危险的，比如张三向李四购买商品，张三开启事务，向李四账号转入 500 块，然后打电话给李四说钱 已经转了。李四一查询钱到账了，发货给张三。张三收到货后回滚事务，李四的再查看钱没了。
   解决方案 : 将全局的隔离级别进行提升为: read committed

1. 在 A 窗口设置全局的隔离级别为 read committed
	set global transaction isolation level read committed;
2. 重新开启A窗口, 查看设置是否成功.
3. 开启B 窗口, A 和 B 窗口选择数据库后, 都开启事务
	use db2 
	start transaction;
4. A 窗口 只是更新两个人的账户, 不提交事务
	-- tom账户 -500元
	UPDATE account SET money = money - 500 WHERE NAME = 'tom';
	-- jack账户 + 500元
	UPDATE account SET money = money + 500 WHERE NAME = 'jack';
5. B 窗口进行查询,没有查询到未提交的数据
	mysqlselect * from account;

6. A窗口commit提交数据
	commit;
7. B 窗口查看数据
	select * from account;

• 不可重复读演示
  不可重复读: 同一个事务中,进行查询操作,但是每次读取的数据内容是不一样的

1. 恢复数据 (把数据改回初始状态)
	id name money
	1  tom  1000
	2  jack 1000
2. 打开两个 窗口A 和 窗口B,选择数据库后 开启事务
	use db2;
	start transaction;
3. B 窗口开启事务后, 先进行一次数据查询
	select * from account;
	1  tom  1000
	2  jack 1000
4. 在 A 窗口开启事务后，将用户tom的账户 + 500 ,然后提交事务
	-- 修改数据
	update account set money = money + 500 where name = 'tom';
	-- 提交事务
	commit;
5. B 窗口再次查询数据
	select * from account;
	1  tom  1500
	2  jack 1000

6. 两次查询输出的结果不同，到底哪次是对的？
	不知道以哪次为准。 很多人认为这种情况就对了，无须困惑， 当然是后面的为准。
	我们可以考虑这样一种情况:
		比如银行程序需要将查询结果分别输出到电脑屏幕和发短信给客 户，结果在一个事务
		中针对不同的输出目的地进行的两次查询不一致，导致文件和屏幕中的结果不一致，银
		行工作 人员就不知道以哪个为准了

• 解决不可重复读问题
  将全局的隔离级别进行提升为： repeatable read

1. 恢复数据
	UPDATE account SET money = 1000
2. 打开A 窗口, 设置隔离级别为：repeatable read
	-- 查看事务隔离级别
	select @@tx_isolation;
	-- 设置事务隔离级别为 repeatable read
	set global transaction isolation level repeatable read;

3. 重新开启 A,B 窗口 选择数据库 ,同时开启事务
	use db2;
	start transaction;
4. B 窗口事务 先进行第一次查询
	select * from account;
	1  tom  1000
	2  jack 1000
5. A 窗口更新数据, 然后提交事务
	-- 修改数据
	update account set money = money + 500 where name = 'tom';
	-- 提交事务
	commit;
6. B 窗口 再次查询
	select * from account;
	1  tom  1000
	2  jack 1000

* 同一个事务中为了保证多次查询数据一致，必须使用 repeatable read 隔离级别

• 幻读演示
  幻读: select 某记录是否存在，不存在，准备插入此记录，但执行 insert 时发现此记录已存在，无法插入，此时就发生了幻读。

1. 打开 A B 窗口, 选择数据库 开启事务
	use db2;
	start transaction;
2. A 窗口 先执行一次查询操作
	-- 假设要再添加一条id为3的 数据,在添加之前先判断是否存在
	select * from account where id = 3;
	-> 查询结果不存在，可以插入
	-> Empty set（0.00 sec）
3. B 窗口 插入一条数据 提交事务
	INSERT INTO account VALUES(3,'lucy',1000);
	commit;
4. A 窗口执行 插入操作, 发现报错. 出现幻读
	INSERT INTO account VALUES(3,'lucy',1000);
	-> 错误 主键重复
	-> ERROR 1062 (23000) : Duplicate entry '3' for key 'PRIMARY'
	见鬼了，我刚才读到的结果应该可以支持我这样操作才对啊，为什么现在不可以

• 解决幻读问题
   将事务隔离级别设置到最高 SERIALIZABLE ，以挡住幻读的发生
  如果一个事务，使用了SERIALIZABLE——可串行化隔离级别时，在这个事务没有被提交之前 , 其他的线程，只能等到当前操作完成之后，才能进行操作，这样会非常耗时，而且，影响数据库的性能，数据库不会使用这种隔离级别

1. 恢复数据
	DELETE FROM account WHERE id = 3;
2. 打开A 窗口 将数据隔离级别提升到最高
	set global transaction isolation level SERIALIZABLE;
3. 打开 A B 窗口, 选择数据库 开启事务
	use db2;
	start transaction;
4. A 窗口 先执行一次查询操作
	SELECT * FROM account WHERE id = 3;
5. B 窗口插入一条数据
	INSERT INTO account VALUES(3,'lucy',1000);
	-> 这个操作无法进行，光标一直在闪烁
6. A 窗口执行 插入操作, 提交事务 数据插入成功.
	INSERT INTO account VALUES(3,'lucy',1000);
	commit;
	-> A窗口数据插入成功，没有出现幻读
7. B 窗口在 A窗口提交事务之后, 再执行,但是主键冲突出现错误
	-> ERROR 1062 (23000) : Duplicate entry '3' for key 'PRIMARY'
	
* serializable 串行化可以彻底解决幻读,但是 事务只能排队执行,严重影响效率,
  数据库不会使用这种隔离级别

任务三 MySQL多表&外键&数据库设计

1. 多表

多表简述

• 实际开发中，一个项目通常需要很多张表才能完成。
• 例如一个商城项目的数据库,需要有很多张表：用户表、分类表、商品表、订单表…

单表的缺点

• 数据准备

1) 创建一个数据库 db3
	CREATE DATABASE db3 CHARACTER SET utf8;
2) 数据库中 创建一个员工表 emp ,
   - 包含如下列 eid, ename, age, dep_name, dep_location
   - eid 为主键并 自动增长, 添加 5 条数据
	-- 创建emp表 主键自增
	CREATE TABLE emp(
		eid INT PRIMARY KEY AUTO_INCREMENT,
		ename VARCHAR(20),
		age INT ,
		dep_name VARCHAR(20),
		dep_location VARCHAR(20)
	);
	-- 添加数据
	INSERT INTO emp (ename, age, dep_name, dep_location) VALUES ('张百万', 20, '研发部', '广州');
	INSERT INTO emp (ename, age, dep_name, dep_location) VALUES ('赵四', 21, '研发部', '广州');
	INSERT INTO emp (ename, age, dep_name, dep_location) VALUES ('广坤', 20, '研发部', '广州');
	INSERT INTO emp (ename, age, dep_name, dep_location) VALUES ('小斌', 20, '销售部', '深圳');
	INSERT INTO emp (ename, age, dep_name, dep_location) VALUES ('艳秋', 22, '销售部', '深圳');
	INSERT INTO emp (ename, age, dep_name, dep_location) VALUES ('大玲子', 18, '销售部', '深圳');

• 单表的问题
  冗[rǒng]余, 同一个字段中出现大量的重复数据

eid	ename	age	dep_name	dep_location
1	张百万	20	研发部	广州
2	赵四	21	研发部	广州
3	广坤	20	研发部	广州
4	小斌	20	销售部	深圳
5	艳秋	22	销售部	深圳
6	大玲子	18	销售部	深圳

解决方案

• 设计为两张表

1. 多表方式设计
	department 部门表 : id, dep_name, dep_location
	employee 员工表: eid, ename, age, dep_id
2. 删除emp表, 重新创建两张表
	-- 创建部门表
	-- 一方,主表
	CREATE TABLE department(
		id INT PRIMARY KEY AUTO_INCREMENT,
		dep_name VARCHAR(30),
		dep_location VARCHAR(30)
	);
	-- 创建员工表
	-- 多方 ,从表
	CREATE TABLE employee(
		eid INT PRIMARY KEY AUTO_INCREMENT,
		ename VARCHAR(20),
		age INT,
		dept_id INT
	);
3. 添加部门表 数据
	-- 添加2个部门
	INSERT INTO department VALUES(NULL, '研发部','广州'),(NULL, '销售部', '深圳');
	SELECT * FROM department;
4. 添加员工表 数据
	-- 添加员工,dep_id表示员工所在的部门
	INSERT INTO employee (ename, age, dept_id) VALUES ('张百万', 20, 1);
	INSERT INTO employee (ename, age, dept_id) VALUES ('赵四', 21, 1);
	INSERT INTO employee (ename, age, dept_id) VALUES ('广坤', 20, 1);
	INSERT INTO employee (ename, age, dept_id) VALUES ('小斌', 20, 2);
	INSERT INTO employee (ename, age, dept_id) VALUES ('艳秋', 22, 2);
	INSERT INTO employee (ename, age, dept_id) VALUES ('大玲子', 18, 2);

	SELECT * FROM employee;

• 表关系分析
  1) 员工表中有一个字段dept_id 与部门表中的主键对应,员工表的这个字段就叫做 外键
  2) 拥有外键的员工表 被称为 从表 , 与外键对应的主键所在的表叫做 主表

• 多表设计上的问题
  1) 当我们在 员工表的 dept_id 里面输入不存在的部门id ,数据依然可以添加 显然这是不合理的.
  2) 实际上我们应该保证,员工表所添加的 dept_id , 必须在部门表中存在.
  3) 解决方案 : 使用外键约束,约束 dept_id ,必须是 部门表中存在的id

外键约束

• 外键约束
  作用：外键约束可以让两张表之间产生一个对应的关系，从而保证了主从表引用的完整性
• 什么是外键
  1) 外键指的是在从表中与主表的主键对应的那个字段,比如员工表的 dept_id,就是外键
  2) 使用外键约束可以让两张表之间产生一个对应关系,从而保证主从表的引用的完整性
  3) 多表关系中的主表和从表
   主表: 主键id所在的表, 约束别人的表
   从表: 外键所在的表多, 被约束的表

• 创建外键约束
  添加外键约束,就会产生强制性的外键数据检查, 从而保证了数据的完整性和一致性

语法格式:
1. 新建表时添加外键
	[CONSTRAINT] [外键约束名称] FOREIGN KEY(外键字段名) REFERENCES 主表名(主键字段名)
2.  已有表添加外键
	ALTER TABLE 从表 ADD [CONSTRAINT] [外键约束名称] FOREIGN KEY (外键字段名) REFERENCES主表(主 键字段名);
	1) 重新创建employee表, 添加外键约束
		-- 先删除 employee表
		DROP TABLE employee;
		-- 重新创建 employee表,添加外键约束
		CREATE TABLE employee(
			eid INT PRIMARY KEY AUTO_INCREMENT,
			ename VARCHAR(20),
			age INT,
			dept_id INT,
			-- 添加外键约束
			CONSTRAINT emp_dept_fk FOREIGN KEY(dept_id) REFERENCES department(id)
		);
	2) 插入数据
		-- 正常添加数据 (从表外键 对应主表主键)
		INSERT INTO employee (ename, age, dept_id) VALUES ('张百万', 20, 1);
		INSERT INTO employee (ename, age, dept_id) VALUES ('赵四', 21, 1);
		INSERT INTO employee (ename, age, dept_id) VALUES ('广坤', 20, 1);
		INSERT INTO employee (ename, age, dept_id) VALUES ('小斌', 20, 2);
		INSERT INTO employee (ename, age, dept_id) VALUES ('艳秋', 22, 2);
		INSERT INTO employee (ename, age, dept_id) VALUES ('大玲子', 18, 2);
		-- 插入一条有问题的数据 (部门id不存在)
		-- 添加外键约束之后 就会产生一个强制的外键约束检查，保证数据的完整性和一致性
		-- Cannot add or update a child row: a foreign key constraint fails
		INSERT INTO employee (ename, age, dept_id) VALUES ('错误', 18, 3);

• 删除外键约束

语法格式: alter table 从表 drop foreign key 外键约束名称

1) 删除 外键约束
	-- 删除employee 表中的外键约束,外键约束名 emp_dept_fk
	ALTER TABLE employee DROP FOREIGN KEY emp_dept_fk;

2) 再将外键 添加回来
语法格式: ALTER TABLE 从表 ADD [CONSTRAINT] [外键约束名称] FOREIGN KEY (外键字段名) REFERENCES 主表(主键字段名);
	-- 可以省略外键名称, 系统会自动生成一个
	ALTER TABLE employee ADD FOREIGN KEY (dept_id) REFERENCES department (id);

• 外键约束的注意事项

1) 从表外键类型必须与主表主键类型一致 否则创建失败.
	1215
	Cannot add foreign key constraint
2) 添加数据时, 应该先添加主表中的数据.
	-- 添加一个新的部门
	INSERT INTO department(dep_name,dep_location) VALUES('市场部','北京');
	-- 添加一个属于市场部的员工
	INSERT INTO employee(ename,age,dept_id) VALUES('老胡',24,3);
3) 删除数据时,应该先删除从表中的数据.
	-- 删除数据时 应该先删除从表中的数据
	-- 报错 Cannot delete or update a parent row: a foreign key constraint fails
	-- 报错原因 不能删除主表的这条数据,因为在从表中有对这条数据的引用
	DELETE FROM department WHERE id = 3;
	-- 先删除从表的关联数据
	DELETE FROM employee WHERE dept_id = 3;
	-- 再删除主表的数据
	DELETE FROM department WHERE id = 3;

• 级联删除操作(了解)

如果想实现删除主表数据的同时,也删除掉从表数据,可以使用级联删除操作
级联删除 ON DELETE CASCADE

1) 删除 employee表,重新创建,添加级联删除
	-- 重新创建添加级联操作
	CREATE TABLE employee(
		eid INT PRIMARY KEY AUTO_INCREMENT,
		ename VARCHAR(20),
		age INT,
		dept_id INT,
		CONSTRAINT emp_dept_fk FOREIGN KEY(dept_id) REFERENCES department(id)
		-- 添加级联删除
		ON DELETE CASCADE
	);
	-- 添加数据
	INSERT INTO employee (ename, age, dept_id) VALUES ('张百万', 20, 1);
	INSERT INTO employee (ename, age, dept_id) VALUES ('赵四', 21, 1);
	INSERT INTO employee (ename, age, dept_id) VALUES ('广坤', 20, 1);
	INSERT INTO employee (ename, age, dept_id) VALUES ('小斌', 20, 2);
	INSERT INTO employee (ename, age, dept_id) VALUES ('艳秋', 22, 2);
	INSERT INTO employee (ename, age, dept_id) VALUES ('大玲子', 18, 2);
	-- 删除部门编号为2 的记录
	DELETE FROM department WHERE id = 2;

2. 多表关系设计

 实际开发中，一个项目通常需要很多张表才能完成。例如：一个商城项目就需要分类表(category)、商品表(products)、订单表(orders)等多张表。且这些表的数据之间存在一定的关系，接下来我们一起学习一下多表关系设计方面的知识

表与表之间的三种关系
一对多关系: 最常见的关系, 学生对班级,员工对部门
多对多关系: 学生与课程, 用户与角色
一对一关系: 使用较少,因为一对一关系可以合成为一张表

一对多关系(常见)

• 一对多关系（1:n）
  例如：班级和学生，部门和员工，客户和订单，分类和商品
• 一对多建表原则
  在从表(多方)创建一个字段,字段作为外键指向主表(一方)的主键
  （n —> 1 从 —> 主）

多对多关系(常见)

• 多对多（m:n）
  例如：老师和学生，学生和课程，用户和角色
• n 多对多关系建表原则
  需要创建第三张表，中间表中至少两个字段，这两个字段分别作为外键指向各自一方的 主键。（n —> 1 从 —> 主）

一对一关系(了解)

• 一对一（1:1）
  在实际的开发中应用不多.因为一对一可以创建成一张表。
• 一对一建表原则
  外键唯一 主表的主键和从表的外键（唯一），形成主外键关系，外键唯一 UNIQUE（1 —> 1 从 —> 主）

设计 省&市表

1. 分析: 省和市之间的关系是 一对多关系,一个省包含多个市

2. SQL是实现

#创建省表 (主表,注意: 一定要添加主键约束)
CREATE TABLE province(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(20),
	description VARCHAR(20)
);
#创建市表 (从表,注意: 外键类型一定要与主表主键一致)
CREATE TABLE city(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(20),
	description VARCHAR(20),
	pid INT,
	-- 添加外键约束
	CONSTRAINT pro_city_fk FOREIGN KEY (pid) REFERENCES province(id)
);

3. 查看表关系

设计 演员与角色表

1. 分析: 演员与角色 是多对多关系, 一个演员可以饰演多个角色, 一个角色同样可以被不同的演员扮演
   

2. SQL 实现

#创建演员表
CREATE TABLE actor(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(20)
);
#创建角色表
CREATE TABLE role(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(20)
);
#创建中间表
CREATE TABLE actor_role(
	-- 中间表自己的主键
	id INT PRIMARY KEY AUTO_INCREMENT,
	-- 指向actor 表的外键
	aid INT,
	-- 指向role 表的外键
	rid INT
);

3. 添加外键约束

-- 为中间表的aid字段,添加外键约束 指向演员表的主键
ALTER TABLE actor_role ADD FOREIGN KEY(aid) REFERENCES actor(id);
-- 为中间表的rid字段, 添加外键约束 指向角色表的主键
ALTER TABLE actor_role ADD FOREIGN KEY(rid) REFERENCES role(id);

4. 查看表关系

3. 多表查询

什么是多表查询

• DQL: 查询多张表,获取到需要的数据
• 比如 我们要查询家电分类下 都有哪些商品,那么我们就需要查询分类与商品这两张表

数据准备

1. 创建db3_2 数据库

	-- 创建 db3_2 数据库,指定编码
	CREATE DATABASE db3_2 CHARACTER SET utf8;

2. 创建分类表与商品表

	#分类表 (一方 主表)
	CREATE TABLE category (
		cid VARCHAR(32) PRIMARY KEY ,
		cname VARCHAR(50)
	);
	#商品表 (多方 从表)
	CREATE TABLE products(
		pid VARCHAR(32) PRIMARY KEY ,
		pname VARCHAR(50),
		price INT,
		flag VARCHAR(2), #是否上架标记为：1表示上架、0表示下架
		category_id VARCHAR(32),
		-- 添加外键约束
		FOREIGN KEY (category_id) REFERENCES category (cid)
	);

3. 插入数据

#分类数据
INSERT INTO category(cid,cname) VALUES('c001','家电');
INSERT INTO category(cid,cname) VALUES('c002','鞋服');
INSERT INTO category(cid,cname) VALUES('c003','化妆品');
INSERT INTO category(cid,cname) VALUES('c004','汽车');

#商品数据
INSERT INTO products(pid, pname,price,flag,category_id) VALUES('p001','小米电视机',5000,'1','c001');
INSERT INTO products(pid, pname,price,flag,category_id) VALUES('p002','格力空调',3000,'1','c001');
INSERT INTO products(pid, pname,price,flag,category_id) VALUES('p003','美的冰箱',4500,'1','c001');
INSERT INTO products (pid, pname,price,flag,category_id) VALUES('p004','篮球鞋',800,'1','c002');
INSERT INTO products (pid, pname,price,flag,category_id) VALUES('p005','运动裤',200,'1','c002');
INSERT INTO products (pid, pname,price,flag,category_id) VALUES('p006','T恤',300,'1','c002');
INSERT INTO products (pid, pname,price,flag,category_id) VALUES('p007','冲锋衣',2000,'1','c002');
INSERT INTO products (pid, pname,price,flag,category_id) VALUES('p008','神仙水',800,'1','c003');
INSERT INTO products (pid, pname,price,flag,category_id) VALUES('p009','大宝',200,'1','c003');

笛卡尔积

• 交叉连接查询,因为会产生笛卡尔积,所以 基本不会使用
  （A集合中有几个元素，B集合中有几个元素，取出两个集合所有组合的情况）

1. 语法格式:

	SELECT 字段名 FROM 表1, 表2;

2. 使用交叉连接查询 商品表与分类表

	SELECT * FROM category , products;

3. 观察查询结果,产生了笛卡尔积 (得到的结果是无法使用的)

4. 笛卡尔积

多表查询的分类

• 内连接查询
  内连接的特点: 通过指定的条件去匹配两张表中的数据, 匹配上就显示,匹配不上就不显示
  比如通过: 从表的外键 = 主表的主键 方式去匹配

1. 隐式内连接
from子句 后面直接写 多个表名 使用where指定连接条件的 这种连接方式是 隐式内连接.
使用where条件过滤无用的数据

语法格式：SELECT 字段名 FROM 左表, 右表 WHERE 连接条件;

1) 查询所有商品信息和对应的分类信息
	# 隐式内连接
	SELECT * FROM products,category WHERE category_id = cid

2) 查询商品表的商品名称 和 价格,以及商品的分类信息
可以通过给表起别名的方式, 方便我们的查询(有提示)
	SELECT
		p.`pname`,
		p.`price`,
		c.`cname`
	FROM products p , category c WHERE p.`category_id` = c.`cid`;

3) 查询 格力空调是属于哪一分类下的商品
	#查询 格力空调是属于哪一分类下的商品
	SELECT p.`pname`,c.`cname` FROM products p , category c
	WHERE p.`category_id` = c.`cid` AND p.`pid` = 'p002';

2. 显式内连接
使用 inner join ...on 这种方式, 就是显式内连接
语法格式
	SELECT 字段名 FROM 左表 [INNER] JOIN 右表 ON 条件
	-- inner 可以省略
	
1) 查询所有商品信息和对应的分类信息
	# 显式内连接查询
	SELECT * FROM products p INNER JOIN category c ON p.category_id = c.cid;
2) 查询鞋服分类下,价格大于500的商品名称和价格
	# 查询鞋服分类下,价格大于500的商品名称和价格
	-- 我们需要确定的几件事
	-- 1.查询几张表 products & category
	-- 2.表的连接条件 从表.外键 = 主表的主键
	-- 3.查询的条件 cname = '鞋服' and price > 500
	-- 4.要查询的字段 pname price
	SELECT
		p.pname,
		p.price
	FROM products p INNER JOIN category c ON p.category_id = c.cid
	WHERE p.price > 500 AND cname = '鞋服';

• 外连接查询

1. 左外连接
左外连接 , 使用 LEFT OUTER JOIN , OUTER 可以省略
左外连接的特点:
	1) 以左表为基准, 匹配右边表中的数据,如果匹配的上,就展示匹配到的数据
	2) 如果匹配不到, 左表中的数据正常展示, 右边的展示为null.
1) 语法格式
	SELECT 字段名 FROM 左表 LEFT [OUTER] JOIN 右表 ON 条件
	-- 左外连接查询
	SELECT * FROM category c LEFT JOIN products p ON c.`cid`= p.`category_id`;

2) 左外连接, 查询每个分类下的商品个数
	# 查询每个分类下的商品个数
	/*
	1.连接条件: 主表.主键 = 从表.外键
	2.查询条件: 每个分类 需要分组
	3.要查询的字段: 分类名称, 分类下商品个数
	*/
	SELECT
		c.`cname` AS '分类名称',
		COUNT(p.`pid`) AS '商品个数'
	FROM category c LEFT JOIN products p ON c.`cid` = p.`category_id`
	GROUP BY c.`cname`;

2. 右外连接
右外连接 , 使用 RIGHT OUTER JOIN , OUTER 可以省略
右外连接的特点
	1) 以右表为基准，匹配左边表中的数据，如果能匹配到，展示匹配到的数据
	2) 如果匹配不到，右表中的数据正常展示, 左边展示为null
1) 语法格式
	SELECT 字段名 FROM 左表 RIGHT [OUTER ]JOIN 右表 ON 条件
	-- 右外连接查询
	SELECT * FROM products p RIGHT JOIN category c ON p.`category_id` = c.`cid`;

• 各种连接方式的总结
  内连接: inner join , 只获取两张表中 交集部分的数据.
  左外连接: left join , 以左表为基准 ,查询左表的所有数据, 以及与右表有交集的部分
  右外连接: right join , 以右表为基准,查询右表的所有的数据,以及与左表有交集的部分

4. 子查询 (SubQuery)

什么是子查询

• 子查询概念
  一条select 查询语句的结果, 作为另一条 select 语句的一部分
• 子查询的特点
  子查询必须放在小括号中
  子查询一般作为父查询的查询条件使用
• 子查询常见分类
  where型 子查询: 将子查询的结果, 作为父查询的比较条件
  from型 子查询 : 将子查询的结果, 作为 一张表,提供给父层查询使用
  exists型 子查询: 子查询的结果是单列多行, 类似一个数组, 父层查询使用 IN 函数 ,包含子查询的结果

子查询的结果作为查询条件

语法格式 : SELECT 查询字段 FROM 表 WHERE 字段=（子查询）;

1. 通过子查询的方式, 查询价格最高的商品信息
# 通过子查询的方式, 查询价格最高的商品信息
-- 1.先查询出最高价格
SELECT MAX(price) FROM products;
-- 2.将最高价格作为条件,获取商品信息
SELECT * FROM products WHERE price = (SELECT MAX(price) FROM products);

2. 查询化妆品分类下的 商品名称 商品价格
#查询化妆品分类下的 商品名称 商品价格
-- 先查出化妆品分类的 id
SELECT cid FROM category WHERE cname = '化妆品';
-- 根据分类id ,去商品表中查询对应的商品信息
SELECT
	p.`pname`,
	p.`price`
FROM products p
WHERE p.`category_id` = (SELECT cid FROM category WHERE cname = '化妆品');

3. 查询小于平均价格的商品信息
-- 1.查询平均价格
SELECT AVG(price) FROM products; -- 1866
-- 2.查询小于平均价格的商品
SELECT * FROM products
WHERE price < (SELECT AVG(price) FROM products);

子查询的结果作为一张表

语法格式 : SELECT 查询字段 FROM （子查询）表别名 WHERE 条件;

1. 查询商品中,价格大于500的商品信息,包括 商品名称 商品价格 商品所属分类名称
-- 1. 先查询分类表的数据
SELECT * FROM category;
-- 2.将上面的查询语句 作为一张表使用
SELECT
	p.`pname`,
	p.`price`,
	c.cname
FROM products p
-- 子查询作为一张表使用时 要起别名 才能访问表中字段
INNER JOIN (SELECT * FROM category) c
ON p.`category_id` = c.cid WHERE p.`price` > 500;

注意： 当子查询作为一张表的时候，需要起别名，否则无法访问表中的字段。

子查询结果是单列多行

• 子查询的结果类似一个数组, 父层查询使用 IN 函数 ,包含子查询的结果

语法格式 : SELECT 查询字段 FROM 表 WHERE 字段 IN （子查询）;

1. 查询价格小于两千的商品,来自于哪些分类(名称)
# 查询价格小于两千的商品,来自于哪些分类(名称)
-- 先查询价格小于2000 的商品的,分类ID
SELECT DISTINCT category_id FROM products WHERE price < 2000;
-- 在根据分类的id信息,查询分类名称
-- 报错: Subquery returns more than 1 row
-- 子查询的结果 大于一行
SELECT * FROM category
WHERE cid = (SELECT DISTINCT category_id FROM products WHERE price < 2000);

• 使用in函数, in( c002, c003 )

-- 子查询获取的是单列多行数据
SELECT * FROM category
WHERE cid IN (SELECT DISTINCT category_id FROM products WHERE price < 2000);

1. 查询家电类 与 鞋服类下面的全部商品信息
# 查询家电类 与 鞋服类下面的全部商品信息
-- 先查询出家电与鞋服类的 分类ID
SELECT cid FROM category WHERE cname IN ('家电','鞋服');
-- 根据cid 查询分类下的商品信息
SELECT * FROM products
WHERE category_id IN (SELECT cid FROM category WHERE cname IN ('家电','鞋服'));

子查询总结

1. 子查询如果查出的是一个字段(单列), 那就在where后面作为条件使用.
2. 子查询如果查询出的是多个字段(多列), 就当做一张表使用(要起别名).

5. 数据库设计

数据库三范式(空间最省)

 概念: 三范式就是设计数据库的规则
 为了建立冗余较小、结构合理的数据库，设计数据库时必须遵循一定的规则。在关系型数据库中这种规则就称为范式。范式是符合某一种设计要求的总结。要想设计一个结构合理的关系型数据库，必须满足一定的范式
 满足最低要求的范式是第一范式（1NF）。在第一范式的基础上进一步满足更多规范要求的称为第二范式（2NF） ， 其余范式以此类推。一般说来，数据库只需满足第三范式(3NF）就行了

• 第一范式 1NF
   概念: 原子性, 做到列不可拆分, 第一范式是最基本的范式。数据库表里面字段都是单一属性的，不可再分, 如果数据表中每个字段都是不可再分的最小数据单元，则满足第一范式。
   示例: 地址信息表中, contry这一列,还可以继续拆分,不符合第一范式

• 第二范式 2NF
   概念: 在第一范式的基础上更进一步，目标是确保表中的每列都和主键相关。一张表只能描述一件事。
   示例: 学员信息表中其实在描述两个事物 , 一个是学员的信息,一个是课程信息。如果放在一张表中,会导致数据的冗余,如果删除学员信息, 成绩的信息也被删除了。

• 第三范式 3NF
   概念: 消除传递依赖, 表的信息，如果能够被推导出来，就不应该单独的设计一个字段来存放
   示例: 通过number 与 price字段就可以计算出总金额,不要在表中再做记录(空间最省)

数据库反三范式

• 概念
  反范式化指的是通过增加冗余或重复的数据来提高数据库的读性能，浪费存储空间，节省查询时间 (以空间换时间)

• 什么是冗余字段 ?
  设计数据库时，某一个字段属于一张表，但它同时出现在另一个或多个表，且完全等同于它在其本来所属表的意义表示，那么这个字段就是一个冗余字段

• 反三范式示例
   两张表，用户表、订单表，用户表中有字段name，而订单表中也存在字段name
  使用场景
   当需要查询“订单表”所有数据并且只需要“用户表”的name字段时, 没有冗余字段 就需要去join连接用户表,假设表中数据量非常的大, 那么会这次连接查询就会非常大的消耗系统的性能.
   这时候冗余的字段就可以派上用场了, 有冗余字段我们查一张表就可以了.

• 总结
  创建一个关系型数据库设计，我们有两种选择
  1，尽量遵循范式理论的规约，尽可能少的冗余字段，让数据库设计看起来精致、优雅、让人心醉。
  2，合理的加入冗余字段这个润滑剂，减少join，让数据库执行性能更高更快。

任务四 MySQL索引&视图&存储过程

1. MySQL 索引

什么是索引

• 在数据库表中，对字段建立索引可以大大提高查询速度。通过善用这些索引，可以令MySQL的查询和运行更加高效。
• 如果合理的设计且使用索引的MySQL是一辆兰博基尼的话，那么没有设计和使用索引的MySQL就是一个人力三轮车。拿汉语字典的目录页（索引）打比方，我们可以按拼音、笔画、偏旁部首等排序的目录（索引）快速查找到需要的字

常见索引分类

索引名称	说明
主键索引 (primary key)	主键是一种唯一性索引,每个表只能有一个主键, 用于标识数据表中的每一条记录（自带一个索引）
唯一索引 (unique)	唯一索引指的是 索引列的所有值都只能出现一次, 必须唯一.
普通索引 (index)	最常见的索引,作用就是 加快对数据的访问速度

• MySql将一个表的索引都保存在同一个索引文件中, 如果对中数据进行增删改操作,MySql都会自动的更新索引.

1. 主键索引 (PRIMARY KEY)

• 特点: 主键是一种唯一性索引,每个表只能有一个主键,用于标识数据表中的某一条记录。
  一个表可以没有主键，但最多只能有一个主键，并且主键值不能包含NULL。

1) 创建db4数据库
	CREATE DATABASE db4 CHARACTER SET utf8;
2) 创建 demo01表
	CREATE TABLE demo01(
		did INT,
		dname VARCHAR(20),
		hobby VARCHAR(30)
	);
3) 语法格式
	- 创建表的时候直接添加主键索引 (最常用)
		CREATE TABLE 表名(
			-- 添加主键 (主键是唯一性索引,不能为null,不能重复,)
			字段名 类型 PRIMARY KEY,
		);
	- 修改表结构 添加主键索引
		ALTER TABLE 表名 ADD PRIMARY KEY ( 列名 )
4) 为demo1 表添加主键索引
	ALTER TABLE demo01 ADD PRIMARY KEY (did);

2. 唯一索引(UNIQUE)

• 特点: 索引列的所有值都只能出现一次, 必须唯一.
  唯一索引可以保证数据记录的唯一性。事实上，在许多场合，人们创建唯一索引的目的往往不是为了提高访问速度，而只是为了避免数据出现重复。

1) 语法格式
	- 创建表的时候直接添加主键索引
		CREATE TABLE 表名(
			列名 类型(长度),
			-- 添加唯一索引
			UNIQUE [索引名称] (列名)
		);
	- 使用create语句创建: 在已有的表上创建索引
		create unique index 索引名 on 表名(列名(长度))
	- 修改表结构添加索引
		ALTER TABLE 表名 ADD UNIQUE ( 列名 )
2) 为 hobby字段添加唯一索引
	create unique index ind_hobby on demo01(hobby)
3) 向表中插入数据
	INSERT INTO demo01 VALUES(1,'张三','DBJ');
	# 报错Duplicate entry 'DBJ' for key 'hobby'
	# 唯一索引保证了数据的唯一性,索引的效率也提升了
	INSERT INTO demo01 VALUES(2,'李四','DBJ');

3. 普通索引 (INDEX)

• 普通索引（由关键字KEY或INDEX定义的索引）的唯一任务是加快对数据的访问速度。因此，应该只为那些最经常出现在查询条件（WHERE column=）或排序条件（ORDERBY column）中的数据列创建索引。

1) 语法格式
	- 使用create index 语句创建: 在已有的表上创建索引
		create index 索引名 on 表名(列名[长度])
	- 修改表结构添加索引
		ALTER TABLE 表名 ADD INDEX 索引名 (列名)
2) 给 dname字段添加索引
	# 给dname字段添加索引
	alter table demo01 add index dname_indx(dname);

4. 删除索引

• 由于索引会占用一定的磁盘空间，因此，为了避免影响数据库的性能，应该及时删除不再使用的索引

1) 语法格式
	ALTER TABLE table_name DROP INDEX index_name;
2) 删除  demo01 表中名为  dname_indx 的普通索引。
	ALTER TABLE demo01 DROP INDEX dname_indx;

索引性能测试

1. 导入数据表

1. 选中 db4数据库 右键 导入SQL脚本
2. 找到软件文件夹下的 测试索引.sql文件, 点击执行
3. 查询 test_index 表中的总记录数

2. 测试

1) 在没有添加索引的情况下, 使用 dname 字段进行查询
	#未添加索引,进行分组查询
	SELECT * FROM test_index GROUP BY dname;
2) 耗时
	执行：33。774sec
3) 为 dname字段 添加索引
	#添加索引
	ALTER TABLE test_index ADD INDEX dname_indx(dname);
4) 执行分组查询
	SELECT * FROM test_index GROUP BY dname;
	执行：0.001sec

索引的优缺点总结

• 添加索引首先应考虑在 where 及 order by 涉及的列上建立索引。
• 索引的优点
  1. 大大的提高查询速度
  2. 可以显著的减少查询中分组和排序的时间。
• 索引的缺点
  1. 创建索引和维护索引需要时间，而且数据量越大时间越长
  2. 当对表中的数据进行增加，修改，删除的时候，索引也要同时进行维护，降低了数据的维护速度
  3. 索引文件需要占据磁盘空间

2. MySQL 视图

什么是视图

1. 视图是一种虚拟表。
2. 视图建立在已有表的基础上, 视图赖以建立的这些表称为基表。
3. 向视图提供数据内容的语句为 SELECT 语句, 可以将视图理解为存储起来的 SELECT 语句.
4. 视图向用户提供基表数据的另一种表现形式
5. 即视图是由查询结果形成的一张虚拟的表。

视图的作用

• 权限控制时可以使用
  1. 比如,某几个列可以运行用户查询,其他列不允许,可以开通视图 查询特定的列, 起到权限控制的作用
• 简化复杂的多表查询
  1. 视图 本身就是一条查询SQL,我们可以将一次复杂的查询 构建成一张视图, 用户只要查询视图就可以获取想要得到的信息(不需要再编写复杂的SQL)
  2. 视图主要就是为了简化多表的查询
  3. 如果某个查询结果十分频繁，并且查询语法比较复杂。那么这个时候，就可以根据这条查询语句创建一张视图，方便查询

视图的使用

1. 创建视图

1) 语法格式
	create view 视图名 [column_list] as select语句;
		view: 表示视图
		column_list: 可选参数，表示属性清单，指定视图中各个属性的名称，默认情况下，与SELECT语句中查询的属性相同
		as : 表示视图要执行的操作
		select语句: 向视图提供数据内容
2) 创建一张视图
	#1. 先编写查询语句
	#查询所有商品 和 商品的对应分类信息
	SELECT * FROM products p LEFT JOIN category c ON p.`category_id` = c.`cid`;
	#2.基于上面的查询语句,创建一张视图
	CREATE VIEW products_category_view
	AS SELECT * FROM products p LEFT JOIN category c ON p.`category_id` = c.`cid`;
3) 查询视图 ,当做一张只读的表操作就可以
	SELECT * FROM products_category_view;

2. 通过视图进行查询

1) 需求: 查询各个分类下的商品平均价格
	#通过 多表查询
	SELECT
		cname AS '分类名称',
		AVG(p.`price`) AS '平均价格'
	FROM products p LEFT JOIN category c ON p.`category_id` = c.`cid`
	GROUP BY c.`cname`;
	# 通过视图查询 可以省略连表的操作
	SELECT
		cname AS '分类名称',
		AVG(price) AS '平均价格'
	FROM products_category_view GROUP BY cname;
2) 需求: 查询鞋服分类下最贵的商品的全部信息
	#通过连表查询
	#1.先求出鞋服分类下的最高商品价格
	SELECT
		MAX(price) AS maxPrice
	FROM
	products p LEFT JOIN category c ON p.`category_id` = c.`cid`
	WHERE c.`cname` = '鞋服'
	#2.将上面的查询 作为条件使用
	SELECT * FROM products p LEFT JOIN category c ON p.`category_id` = c.`cid`
	WHERE c.`cname` = '鞋服' AND p.`price` =
	(SELECT
		MAX(price) AS maxPrice
	FROM
	products p LEFT JOIN category c ON p.`category_id` = c.`cid`
	WHERE c.`cname` = '鞋服');
	#通过视图查询
	SELECT * FROM products_category_view pcv
	WHERE pcv.`cname` = '鞋服'
	AND pcv.`price` = (SELECT MAX(price) FROM products_category_view WHERE cname ='鞋服')

视图与表的区别

• 视图是建立在表的基础上，表存储数据库中的数据，而视图只是做一个数据的展示
• 通过视图不能改变表中数据（一般情况下视图中的数据都是表中的列 经过计算得到的结果,不允许更新）
• 删除视图，表不受影响，而删除表，视图不再起作用

3. MySQL 存储过程(了解)

什么是存储过程

• MySQL 5.0 版本开始支持存储过程。
• 存储过程（Stored Procedure）是一种在数据库中存储复杂程序，以便外部程序调用的一种数据库对象。存储过程是为了完成特定功能的SQL语句集，经编译创建并保存在数据库中，用户可通过指定存储过程的名字并给定参数(需要时)来调用执行。
• 简单理解: 存储过程其实就是一堆 SQL 语句的合并。中间加入了一些逻辑控制。

存储过程的优缺点

• 优点:
  1. 存储过程一旦调试完成后，就可以稳定运行，（前提是，业务需求要相对稳定，没有变化）
  2. 存储过程减少业务系统与数据库的交互，降低耦合，数据库交互更加快捷（应用服务器，与数据库服务器不在同一个地区）
• 缺点:
  1. 在互联网行业中，大量使用MySQL，MySQL的存储过程与Oracle的相比较弱，所以较少使用，并且互联网行业需求变化较快也是原因之一
  2. 尽量在简单的逻辑中使用，存储过程移植十分困难，数据库集群环境，保证各个库之间存储过程变更一致也十分困难。
  3. 阿里的代码规范里也提出了禁止使用存储过程，存储过程维护起来的确麻烦；

存储过程的创建方式

1. 方式1

1) 数据准备 	创建商品表 与 订单表
	# 商品表
	CREATE TABLE goods(
		gid INT,
		NAME VARCHAR(20),
		num INT -- 库存
	);
	#订单表
	CREATE TABLE orders(
		oid INT,
		gid INT,
		price INT -- 订单价格
	);
	# 向商品表中添加3条数据
	INSERT INTO goods VALUES(1,'奶茶',20);
	INSERT INTO goods VALUES(2,'绿茶',100);
	INSERT INTO goods VALUES(3,'花茶',25);
2) 创建简单的存储过程

	语法格式
	DELIMITER $$ -- 声明语句结束符，可以自定义 一般使用$$
	CREATE PROCEDURE 过程名称() -- 声明存储过程
	BEGIN -- 开始编写存储过程
		-- 要执行的操作
	END $$ -- 存储过程结束

	需求: 编写存储过程, 查询所有商品数据
	DELIMITER $$
	CREATE PROCEDURE goods_proc()
	BEGIN
		select * from goods;
	END $$
3) 调用存储过程
	语法格式
	call 存储过程名
	-- 调用存储过程 查询goods表所有数据
	call goods_proc;

2. 方式2

1) IN 输入参数：表示调用者向存储过程传入值
	CREATE PROCEDURE 存储过程名称(IN 参数名 参数类型)
2) 创建接收参数的存储过程   
   需求: 接收一个商品id, 根据id删除数据
	DELIMITER $$
	CREATE PROCEDURE goods_proc02(IN goods_id INT)
	BEGIN
		DELETE FROM goods WHERE gid = goods_id ;
	END $$
3) 调用存储过程 传递参数
	# 删除 id为2的商品
	CALL goods_proc02(2);

3. 方式3

1) 变量赋值
	SET @变量名=值
2) OUT 输出参数：表示存储过程向调用者传出值
	OUT 变量名 数据类型
3) 创建存储过程
   需求: 向订单表 插入一条数据, 返回1,表示插入成功
	# 创建存储过程 接收参数插入数据, 并返回受影响的行数
	DELIMITER $$
	CREATE PROCEDURE orders_proc(IN o_oid INT , IN o_gid INT ,IN o_price INT, OUT out_num INT)
	BEGIN
		-- 执行插入操作
		INSERT INTO orders VALUES(o_oid,o_gid,o_price);
		-- 设置 num的值为 1
		SET @out_num = 1;
		-- 返回 out_num的值
		SELECT @out_num;
	END $$
4) 调用存储过程
	# 调用存储过程插入数据,获取返回值
	CALL orders_proc(1,2,30,@out_num);

4. MySQL触发器(了解)

什么是触发器

• 触发器（trigger）是MySQL提供给程序员和数据分析员来保证数据完整性的一种方法，它是与表事件相关的特殊的存储过程，它的执行不是由程序调用，也不是手工启动，而是由事件来触发，比如当对一个表进行操作（insert，delete， update）时就会激活它执行。——百度百科
• 简单理解: 当我们执行一条sql语句的时候，这条sql语句的执行会自动去触发执行其他的sql语句。

触发器创建的四个要素

1. 监视地点（table）
2. 监视事件（insert/update/delete）
3. 触发时间（before/after）
4. 触发事件（insert/update/delete）

创建触发器

1) 语法格式
	delimiter $ -- 将Mysql的结束符号从 ; 改为 $,避免执行出现错误
	CREATE TRIGGER Trigger_Name -- 触发器名，在一个数据库中触发器名是唯一的
	before/after（insert/update/delete） -- 触发的时机 和 监视的事件
	on table_Name -- 触发器所在的表
	for each row -- 固定写法 叫做行触发器, 每一行受影响，触发事件都执行
	begin
		-- begin和end之间写触发事件
	end
	$ -- 结束标记
2) 向商品中添加一条数据
	# 向商品中添加一条数据
	INSERT INTO goods VALUES(1,'book',40);
3) 需求: 在下订单的时候，对应的商品的库存量要相应的减少，卖出商品之后减少库存量。
   /*
	监视的表   orders
	监视的时间 insert 订单
	触发的时间 after
	触发的时间 update 库存
   */
   编写触发器
	-- 1.修改结束标识
	DELIMITER $
	-- 2.创建触发器
	CREATE TRIGGER t1
	-- 3.指定触发的时机,和要监听的表
	AFTER INSERT ON orders
	-- 4.行触发器 固定写法
	FOR EACH ROW
	-- 4.触发后具体要执行的事件
	BEGIN
		-- 订单+1 库存-1
		UPDATE goods SET num = num -1 WHERE gid = 1;
	END$
4) 查询 goods表中的数据
	当前库存40
5) 向订单表中添加一条数据
	INSERT INTO orders VALUES(1,1,25);
6) goods表中的数据随之 -1
	库存39

5. DCL(数据控制语言)

• MySql默认使用的都是 root 用户，超级管理员，拥有全部的权限。除了root用户以外，我们还可以通过DCL语言来定义一些权限较小的用户, 分配不同的权限来管理和维护数据库。

创建用户

参数	说明
用户名	创建的新用户,登录名称
主机名	指定该用户在哪个主机上可以登陆，本地用户可用 localhost 如果想让该用户可以 从任意远程主机登陆，可以使用通配符 %
密码	登录密码

0) 语法格式
	CREATE USER '用户名'@ '主机名' IDENTIFIED BY '密码';

1) 创建 admin1 用户，只能在 localhost 这个服务器登录 mysql 服务器，密码为 123456
	CREATE USER 'admin1'@ 'localhost' IDENTIFIED BY '123456';
	-- 创建的用户在名字为 mysql的 数据库中的 user表中
	SELECT * FROM user;
2) 创建 admin2 用户可以在任何电脑上登录 mysql 服务器，密码为 123456
	CREATE USER 'admin2'@ '%' IDENTIFIED BY '123456';
	-- % 表示 用户可以在任意电脑登录 mysql服务器.

用户授权

• 创建好的用户,需要进行授权

参数	说明
权限	授予用户的权限，如 CREATE、ALTER、SELECT、INSERT、UPDATE 等。 如果要授 予所有的权限则使用 ALL
ON	用来指定权限针对哪些库和表。
TO	表示将权限赋予某个用户。

0) 语法格式
	GRANT 权限 1, 权限 2... ON 数据库名.表名 TO '用户名'@ '主机名';
1) 给 admin1 用户分配对 db4 数据库中 products 表的 操作权限：查询
	GRANT SELECT ON db4.products TO 'admin1'@ 'localhost';
2) 给 admin2 用户分配所有权限，对所有数据库的所有表
	GRANT ALL ON *.* TO 'admin2'@ '%';
3) 使用admin1用户登录数据库 测试权限
4) 发现数据库列表中 只有db4, 表只有 products.
5) 执行查询操作
	-- 查询account表
	SELECT * FROM products;
6) 执行插入操作,发现不允许执行,没有权限
	-- 向 products 表中插入数据
	-- 不允许执行
	INSERT INTO products VALUES('p010','小鸟伏特加',1000,1,NULL);

查看权限

0) 语法格式
	SHOW GRANTS FOR '用户名'@ '主机名';
1) 查看root用户权限
	-- 查看root用户的权限
	SHOW GRANTS FOR 'root'@'localhost';
	-- GRANT ALL PRIVILEGES 是表示所有权限

6. 数据库备份&还原

• 备份的应用场景 在服务器进行数据传输、数据存储和数据交换，就有可能产生数据故障。比如发生意外停机或存储介质损坏。 这时，如果没有采取数据备份和数据恢复手段与措施，就会导致数据的丢失，造成的损失是无法弥补与估量的。

SQLYog 数据备份

1. 选中要备份的数据库,右键 备份导出 ---->选择 备份数据库
2. 指定文件位置,选择导出即可

SQLYog 数据恢复

1) 先删除 db2 数据库
	DROP DATABASE db2;
2) 导入 之前备份的 SQL 文件

命令行备份

进入到Mysql安装目录的 bin目录下, 打开DOS命令行.
1) 语法格式
	mysqldump -u 用户名 -p 密码 数据库 > 文件路径
2) 执行备份, 备份db2中的数据 到 H盘的 db2.sql 文件中
	mysqldump -uroot -p123456 db2 > H:/db2.sql

命令行恢复

1. 先删除 db2 数据库
2. 恢复数据 还原 db2 数据库中的数据
   注意：还原的时候需要先创建一个 db2数据库
   use db2
   source sql文件地址

模块一作业

• SQL题1

SQL实现

	-- 查询练习
	#1.查询所有的商品
	#2.查询商品名和商品价格
	#3.别名查询.使用的关键字是as（as可以省略的）.	
	#4.查询商品价格，对价格去除重复；
	#5.查询结果是表达式（运算查询）：将所有商品的价格+10元进行显示.
	#6.查询商品名称为“花花公子”的商品所有信息：
	#7.查询价格为800商品
	#8.查询价格不是800的所有商品
	#9.查询商品价格大于60元的所有商品信息
	#10.查询商品价格在200到1000之间所有商品 
	#11.查询商品价格是200或800的所有商品 
	#12.查询含有'霸'字的所有商品 
	#13.查询以'香'开头的所有商品 
	#14.查询第二个字为'想'的所有商品 
	#15.商品没有分类的商品 
	#16.查询有分类的商品

	-- 排序练习：
    #1.使用价格对商品信息排序(降序) 				-- 提示：使用order by语句 
    #2.在价格排序(降序)的基础上，以主键排序(降序) 	-- 提示：若价格相同，相同价格的数据以pid降序排序
    #3.显示商品的价格(去重复)，并排序(降序) 		-- 提示：DISTINCT 关键字去重 

	-- 聚合函数/分组函数练习：
    #1 查询商品的总条数(两种方式)		-- 提示：使用count()
    #2 查看price商品的总价格 		-- 提示：使用sum();
    #3 查看price的最大值和最小值 		-- 提示：使用max()  min()
	#4 查看price的平均值 			-- 提示：使用 AVG() 
    #5 查询价格大于200商品的总条数 	-- 提示：使用 COUNT(*)统计条数

	-- 分组练习：
    #1 统计各个分类商品的个数
    #2 统计各个分类商品的个数,且只显示个数大于1的信息

• SQL题2

SQL实现
按要求实现下面的查询功能 

1) 查询工资最高的员工是谁？
2) 查询工资小于平均工资的员工有哪些？
3) 查询大于5000的员工，来至于哪些部门，输出部门的名字
4) 查询开发部与财务部所有的员工信息，分别使用子查询和表连接实现
5) 查询2011年以后入职的员工信息和部门信息，分别使用子查询和表连接实现

• SQL题3

SQL实现
第一题
-- 1、查询平均成绩大于70分的同学的学号,姓名,和平均成绩
-- 1.1 分组查询每个学生的 学号,姓名,平均分
-- 1.2 增加条件：平均成绩大于70

第二题
-- 2. 查询所有同学的学号、姓名、选课数、总成绩
-- 2.1 需要查询两张表 student表和 student_course表
-- 2.2 需要使用 student_id 学号字段,进行分组
-- 2.3 需要使用到 count函数 sum函数

第三题
-- 3. 查询学过赵云老师课程的同学的学号、姓名
-- 3.1 查询赵云老师的id
-- 3.2 根据老师ID,在课程表中查询所教的课程编号
-- 3.3 将上面的子查询作为 where 后面的条件

第四题
-- 4. 查询选课 少于三门学科的学员			
-- 4.1 查询每个学生学了几门课 条件1：小于等于三门
-- 4.2 查询 学号和姓名， 将4.1 作为临时表

• SQL题4

数据库表设计
以下是我们拉钩教育平台数据库中的某几张表,为了降低难度,已经简化的表中字段 

1) 请设计三张表,要求如下
讲师表
		讲师ID 主键 int类型
		讲师姓名 VARCHAR类型
		讲师简介 VARCHAR类型
		讲师级别 char类型 高级讲师&首席讲师
		为讲师姓名添加索引
		
课程分类表
		课程分类ID 主键 int类型
		课程分类名称 VARCHAR类型 比如前端开发 后端开发 数据库DBA......
		课程分类描述 VARCHAR类型 
		创建时间 datetime类型
		更新时间 datetime类型
		
课程表
		课程ID 主键 int类型
		课程讲师ID 外键 用于描述课程的授课老师
		课程分类ID 外键 用于描述课程所属的分类 比如 Java课程就属于后端分类
		课程标题 VARCHAR类型 比如Java VUE PHP ......
		总课时 int类型 
		浏览数量 bigint类型
		课程状态 char 类型,  0 未发布(默认)  1 已发布
		为 课程标题字段添加索引
		为 teacher_id & subject_id,添加外键约束

- 查询需求
查询刘德华老师所教的课程属于哪个课程分类

第二阶段模块二 JDBC&XML

任务五 JDBC

1. JDBC 概述

客户端操作数据库的方式

1. 方式1: 使用第三方客户端来访问 MySQL：SQLyog
2. 方式2: 使用命令行
3. 我们今天要学习的是通过 Java程序 来访问 MySQL 数据库

什么是JDBC

• JDBC(Java Data Base Connectivity) 是 Java 访问数据库的标准规范.是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。是Java访问数据库的标准规范.

JDBC 原理

• JDBC是接口，驱动是接口的实现，没有驱动将无法完成数据库连接，从而不能操作数据库！每个数据库厂商都需要提供自己的驱动，用来连接自己公司的数据库，也就是说驱动一般都由数据库生成厂商提供。

• 总结:
  JDBC就是由sun公司定义的一套操作所有关系型数据库的规则(接口)，而数据库厂商需要实现这套接口,提供数据库驱动jar包, 我们可以使用这套接口编程,真正执行的代码是对应驱动包中的实现类。

2. JDBC 开发

数据准备

-- 创建 jdbc_user表
CREATE TABLE jdbc_user (
id INT PRIMARY KEY AUTO_INCREMENT ,
username VARCHAR(50),
PASSWORD VARCHAR(50),
birthday DATE
);
-- 添加数据
INSERT INTO jdbc_user (username, PASSWORD,birthday)
VALUES('admin1', '123','1991/12/24'),
('admin2','123','1995/12/24'),
('test1', '123','1998/12/24'),
('test2', '123','2000/12/24');

MySql驱动包

1. 将MySQL驱动包添加到jar包库文件夹中，Myjar文件夹,用于存放当前项目需要的所有jar包
   

2. 在 idea中 配置jar包库的位置
   

3. 创建一个新的项目jdbc_task01, 配置jar包库
   

API使用: 1.注册驱动

• JDBC规范定义驱动接口： java.sql.Driver
• MySql驱动包提供了实现类： com.mysql.jdbc.Driver

加载注册驱动的方式	描述
Class.forName(数据库驱动实现类)	加载和注册数据库驱动,数据库驱动由数据库厂商MySql提供 "com.mysql.jdbc.Driver"

1. 代码示例

public class JDBCDemo01 {
    
    
	public static void main(String[] args) throws ClassNotFoundException {
    
    
		//1.注册驱动
		// forName 方法执行将类进行初始化
		Class.forName("com.mysql.jdbc.Driver");
	}
}

2. 为什么这样可以注册驱动?
   我们知道 Class类的forName方法 ,可以将一个类初始化, 现在我们一起Driver类的 看一下源码

// Driver类是MySql提供的数据库驱动类, 实现了JDBC的Driver接口 java.sql.Driver
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    
    
	// 空参构造
	public Driver() throws SQLException {
    
    
	}
	//静态代码块,Class类的 forName()方法将Driver类 加载到内存, static代码块会自动执行
	static {
    
    
		try {
    
    
			/*
			DriverManager 驱动管理类
			registerDriver(new Driver) 注册驱动的方法
			注册数据库驱动
			*/
			DriverManager.registerDriver(new Driver());
		} catch (SQLException var1) {
    
    
			throw new RuntimeException("Can't register driver!");
		}
	}
}

• 注：
  从 JDBC3 开始，目前已经普遍使用的版本。可以不用注册驱动而直接使用。 Class.forName 这句话可以省略。

API使用: 2.获得连接

• Connection 接口，代表一个连接对象 ,具体的实现类由数据库的厂商实现
• 使用 DriverManager类的静态方法,getConnection可以获取数据库的连接

获取连接的静态方法	说明
Connection getConnection(String url, String user, String password)	通过连接字符串和用户名,密码来获取数据库连接对象

1. getConnection方法 3个 连接参数说明

连接参数	说明
user	登录用户名
password	登录密码
url	mySql URL的格式 jdbc:mysql://localhost:3306/db4

2. 对URL的详细说明
   jdbc:mysql://localhost:3306/db4?characterEncoding=UTF-8
   JDBC规定url的格式由三部分组成，每个部分中间使用冒号分隔。
   第一部分是协议 jdbc，这是固定的；
   第二部分是子协议，就是数据库名称，连接mysql数据库，第二部分当然是mysql了；
   第三部分是由数据库厂商规定的，我们需要了解每个数据库厂商的要求，mysql的第三部分分别由数据库服务器的IP地址（localhost）、端口号（3306），以及要使用的 数据库名称 组成。
   
3. 代码示例

public class JDBCDemo02 {
    
    
	public static void main(String[] args) throws Exception {
    
    
		//1.注册驱动
		Class.forName("com.mysql.jdbc.Driver");
		//2.获取连接 url,用户名, 密码
		String url = "jdbc:mysql://localhost:3306/db4";
		Connection con = DriverManager.getConnection(url, "root", "123456");
		//com.mysql.jdbc.JDBC4Connection@2e3fc542
		System.out.println(con);
	}
}

API 使用: 3.获取语句执行平台

• 通过Connection 的 createStatement方法 获取sql语句执行对象

Connection接口中的方法	说明
Statement createStatement()	创建 SQL语句执行对象

• Statement ： 代表一条语句对象，用于发送 SQL 语句给服务器，用于执行静态 SQL 语句并返回它所生成结果的对象。

Statement类 常用方法	说明
int executeUpdate(String sql);	（增删改）执行insert update delete语句.返回int类型,代表受影响的行数
ResultSet executeQuery(String sql);	（查）执行select语句, 返回ResultSet结果集对象 ResultSet 结果集对象

• 代码示例

public class JDBCDemo03 {
    
    
	public static void main(String[] args) throws Exception {
    
    
		//1.注册驱动
		Class.forName("com.mysql.jdbc.Driver");
		//2.获取连接 url,用户名, 密码
		String url = "jdbc:mysql://localhost:3306/db4";
		Connection con = DriverManager.getConnection(url, "root", "123456");
		//3.获取 Statement对象
		Statement statement = con.createStatement();
		//4.执行创建表操作
		String sql = "create table test01(id int, name varchar(20),age int);";
		//5.增删改操作 使用executeUpdate,增加一张表
		int i = statement.executeUpdate(sql);
		//6.返回值是受影响的函数
		System.out.println(i);
		//7.关闭流
		statement.close();
		con.close();
	}
}


**<font color="#BC8F8F">API 使用: 4.处理结果集</font>**

- 只有在进行查询操作的时候, 才会处理结果集
- 代码示例

```java
public class JDBCDemo04 {
    
    
	public static void main(String[] args) throws SQLException {
    
    
		//1.注册驱动 可以省略
		//2.获取连接
		String url = "jdbc:mysql://localhost:3306/db4";
		Connection con = DriverManager.getConnection(url, "root", "123456");
		//3.获取 Statement对象
		Statement statement = con.createStatement();
		String sql = "select * from jdbc_user";
		//执行查询操作,返回的是一个 ResultSet 结果对象
		ResultSet resultSet = statement.executeQuery(sql);
		//4.处理结果集 resultSet
	}
}

1 ResultSet接口

• 作用：封装数据库查询的结果集，对结果集进行遍历，取出每一条记录。

ResultSet接口方法	说明
boolean next()	1) 游标向下一行 2) 返回 boolean 类型，如果还有下一条记录，返回 true，否则返回 false
xxx getXxx( String or int)	1) 如果传递的参数是String表示，通过列名查询，参数是 String 类型。返回不同的类型 2)如果传递的参数是int表示， 通过列号查询，参数是整数，从 1 开始。返回不同的类型

• 代码示例

public class JDBCDemo04 {
    
    
	public static void main(String[] args) throws SQLException {
    
    
	//1.注册驱动 可以省略
		//2.获取连接
		String url = "jdbc:mysql://localhost:3306/db4";
		Connection con = DriverManager.getConnection(url, "root", "123456");
		//3.获取 Statement对象
		Statement statement = con.createStatement();
		String sql = "select * from jdbc_user";
		//执行查询操作,返回的是一个 ResultSet 结果对象
		ResultSet resultSet = statement.executeQuery(sql);
		//4.处理结果集
		// //next 方法判断是否还有下一条数据
		// boolean next = resultSet.next();
		// System.out.println(next);
		//
		// //getXXX 方法获取数据 两种方式
		// int id = resultSet.getInt("id");//列名
		// System.out.println(id);
		//
		// int anInt = resultSet.getInt(1);//列号
		// System.out.println(anInt);
		//使用while循环
		while(resultSet.next()){
    
    
			//获取id
			int id = resultSet.getInt("id");
			//获取姓名
			String username = resultSet.getString("username");
			//获取生日
			Date birthday = resultSet.getDate("birthday");
			System.out.println(id + " = " +username + " : " + birthday);
		}
		//关闭连接
		resultSet.close();
		statement.close();
		con.close();
	}
}

API 使用: 5.释放资源

1. 需要释放的对象：ResultSet 结果集，Statement 语句，Connection 连接
2. 释放原则：先开的后关，后开的先关。ResultSet ==> Statement ==> Connection
3. 放在哪个代码块中：finally 块

• 与IO流一样，使用后的东西都需要关闭！关闭的顺序是先开后关, 先得到的后关闭，后得到的先关闭
  
• 代码示例

public class JDBCDemo05 {
    
    
	public static void main(String[] args) {
    
    
		Connection connection = null;
		Statement statement = null;
		ResultSet resultSet = null;
		try {
    
    
			//1.注册驱动（省略）
			//2.获取连接
			String url = "jdbc:mysql://localhost:3306/db4";
			connection = DriverManager.getConnection(url, "root", "123456");
			//3.获取 Statement对象
			statement = connection.createStatement();
			String sql = "select * from jdbc_user";
			resultSet = statement.executeQuery(sql);
		} catch (SQLException e) {
    
    
			e.printStackTrace();
		} finally {
    
    
			/**
			* 开启顺序: connection ==> statement => resultSet
			* 关闭顺序: resultSet ==> statement ==> connection
			*/
			try {
    
    
				connection.close();
				resultSet.close();
				statement.close();
			} catch (SQLException e) {
    
    
				e.printStackTrace();
			}
		}
	}
}

步骤总结

1. 获取驱动(可以省略)
2. 获取连接
3. 获取Statement对象
4. 处理结果集(只在查询时处理)
5. 释放资源

3. JDBC实现增删改查

JDBC工具类

• 什么时候自己创建工具类？
  - 如果一个功能经常要用到，我们建议把这个功能做成一个工具类，可以在不同的地方重用。
  - “获得数据库连接”操作，将在以后的增删改查所有功能中都存在，可以封装工具类JDBCUtils。提供获取连接对象的方法，从而达到代码的重复利用。

• 工具类包含的内容
  1) 可以把几个字符串定义成常量：用户名，密码，URL，驱动类
  2) 得到数据库的连接：getConnection()
  3) 关闭所有打开的资源：

• 代码示例

/**
* JDBC 工具类
*/
public class JDBCUtils {
    
    
	//1. 定义字符串常量, 记录获取连接所需要的信息
	public static final String DRIVERNAME = "com.mysql.jdbc.Driver";
	public static final String URL = "jdbc:mysql://localhost:3306/db4?characterEncoding=UTF-8";
	public static final String USER = "root";
	public static final String PASSWORD = "123456";
	//2. 静态代码块, 随着类的加载而加载
	static{
    
    
		try {
    
    
			//注册驱动
			Class.forName(DRIVERNAME);
		} catch (ClassNotFoundException e) {
    
    
			e.printStackTrace();
		}
	}

	//3.获取连接的静态方法
	public static Connection getConnection(){
    
    
		try {
    
    
			//获取连接对象
			Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
			//返回连接对象
			return connection;
		} catch (SQLException e) {
    
    
			e.printStackTrace();
			return null;
		}
	}

	//关闭资源的方法
	public static void close(Connection con, Statement st){
    
    
		if(con != null && st != null){
    
    
			try {
    
    
				st.close();
				con.close();
			} catch (SQLException e) {
    
    
				e.printStackTrace();
			}
		}
	}
	public static void close(Connection con, Statement st, ResultSet rs){
    
    
		if(rs != null){
    
    
			try {
    
    
				rs.close();
			} catch (SQLException e) {
    
    
				e.printStackTrace();
			}
		}
		close(con,st);
	}
}

DML操作

1 插入记录

• 解决插入中文乱码问题.
  jdbc:mysql://localhost:3306/db4?characterEncoding=UTF-8 characterEncoding=UTF-8 指定字符的编码、解码格式。
• 代码示例

/**
* 插入数据
* @throws SQLException
*/
@Test
public void testInsert() throws SQLException {
    
    
	//1.通过工具类获取连接
	Connection connection = JDBCUtils.getConnection();
	//2.获取Statement
	Statement statement = connection.createStatement();
	//2.1 编写Sql
	String sql = "insert into jdbc_user values(null,'张百万','123','2020/1/1')";
	//2.2 执行Sql
	int i = statement.executeUpdate(sql);
	System.out.println(i);
	//3.关闭流
	JDBCUtils.close(connection,statement);
}

2 更新记录

• 根据ID 需改用户名称

/**
* 修改 id 为1 的用户名为 广坤
*/
@Test
public void testUpdate() throws SQLException {
    
    
	Connection connection = JDBCUtils.getConnection();
	Statement statement = connection.createStatement();
	String sql = "update jdbc_user set username = '广坤' where id = 1";
	statement.executeUpdate(sql);
	JDBCUtils.close(connection,statement);
}

3 删除记录

• 删除id为 3 和 4 的记录

/**
* 删除id 为 3 和 4的记录
* @throws SQLException
*/
@Test
public void testDelete() throws SQLException {
    
    
	Connection connection = JDBCUtils.getConnection();
	Statement statement = connection.createStatement();
	statement.executeUpdate("delete from jdbc_user where id in(3,4)");
	JDBCUtils.close(connection,statement);
}

DQL操作

1 查询姓名为张百万的一条记录

public class TestJDBC02 {
    
    
	public static void main(String[] args) throws SQLException {
    
    
		//1.获取连接对象
		Connection connection = JDBCUtils.getConnection();
		//2.获取Statement对象
		Statement statement = connection.createStatement();
		String sql = "SELECT * FROM jdbc_user WHERE username = '张百万';";
		ResultSet resultSet = statement.executeQuery(sql);
		//3.处理结果集
		while(resultSet.next()){
    
    
			//通过列名 获取字段信息
			int id = resultSet.getInt("id");
			String username = resultSet.getString("username");
			String password = resultSet.getString("password");
			String birthday = resultSet.getString("birthday");
			System.out.println(id+" "+username+" " + password +" " + birthday);
		}
		//4.释放资源
		JDBCUtils.close(connection,statement,resultSet);
	}
}

4. SQL注入问题

Sql注入演示

1. 向jdbc_user表中 插入两条数据

# 插入2条数据
INSERT INTO jdbc_user VALUES(NULL,'jack','123456','2020/2/24');
INSERT INTO jdbc_user VALUES(NULL,'tom','123456','2020/2/24');

2. SQL注入演示

# SQL注入演示
-- 填写一个错误的密码
SELECT * FROM jdbc_user WHERE username = 'tom' AND PASSWORD = '123' OR '1' = '1';

• 如果这是一个登陆操作,那么用户就登陆成功了.显然这不是我们想要看到的结果

SQL注入案例：用户登陆

• 需求
  用户在控制台上输入用户名和密码, 然后使用 Statement 字符串拼接的方式 实现用户的登录。
• 步骤

1. 得到用户从控制台上输入的用户名和密码来查询数据库
2. 写一个登录的方法
    a) 通过工具类得到连接
    b) 创建语句对象，使用拼接字符串的方式生成 SQL 语句
    c) 查询数据库，如果有记录则表示登录成功，否则登录失败
    d) 释放资源
   Sql注入方式: 123' or '1'='1

• 代码示例

public class TestLogin01 {
    
    
	/**
	* 用户登录案例
	* 使用 Statement字符串拼接的方式完成查询
	* @param args
	*/
	public static void main(String[] args) throws SQLException {
    
    
		//1.获取连接
		Connection connection = JDBCUtils.getConnection();
		//2.获取Statement
		Statement statement = connection.createStatement();
		//3.获取用户输入的用户名和密码
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入用户名: ");
		String name = sc.nextLine();
		System.out.println("请输入密码: ");
		String pass = sc.nextLine();
		System.out.println(pass);
		//4.拼接Sql,执行查询
		String sql = "select * from jdbc_user " + "where username = " + " '" + name +"' " +" and password = " +" '" + pass +"'";
		System.out.println(sql);
		ResultSet resultSet = statement.executeQuery(sql);
		//5.处理结果集,判断结果集是否为空
		if(resultSet.next()){
    
    
			System.out.println("登录成功! 欢迎您: " + name);
		}else {
    
    
			System.out.println("登录失败!");
		}
		//释放资源
		JDBCUtils.close(connection,statement,resultSet);
	}
}

问题分析

1. 什么是SQL注入?
   我们让用户输入的密码和 SQL 语句进行字符串拼接。用户输入的内容作为了 SQL 语句语法的一部分，改变了 原有
   SQL 真正的意义，以上问题称为 SQL 注入 .
2. 如何实现的注入
   根据用户输入的数据,拼接处的字符串

select * from jdbc_user where username = 'abc' and password = 'abc' or '1'='1'
name='abc' and password='abc' 为假 '1'='1' 真
相当于 select * from user where true=true; 查询了所有记录

3. 如何解决
   要解决 SQL 注入就不能让用户输入的密码和我们的 SQL 语句进 行简单的字符串拼接。

5. 预处理对象

PreparedStatement 接口介绍

• PreparedStatement 是 Statement 接口的子接口，继承于父接口中所有的方法。它是一个预编译的 SQL 语句对象.
• 预编译: 是指SQL 语句被预编译,并存储在 PreparedStatement 对象中。然后可以使用此对象多次高效地执行该语句。

PreparedStatement 特点

• 因为有预先编译的功能，提高 SQL 的执行效率。
• 可以有效的防止 SQL 注入的问题，安全性更高

获取PreparedStatement对象

• 通过Connection创建PreparedStatement对象

Connection 接口中的方法	说明
PreparedStatement prepareStatement(String sql)	指定预编译的 SQL 语句，SQL 语句中使用占位符 ? 创建一个语句对象

PreparedStatement接口常用方法

常用方法	说明
int executeUpdate();	执行insert update delete语句.
ResultSet executeQuery();	执行select语句. 返回结果集对象 Resulet

使用PreparedStatement的步骤

1. 编写 SQL 语句，未知内容使用?占位：
   "SELECT * FROM jdbc_user WHERE username=? AND password=?";
2. 获得 PreparedStatement 对象
3. 设置实际参数：setXxx( 占位符的位置, 真实的值)
4. 执行参数化 SQL 语句
5. 关闭资源

setXxx重载方法	说明
void setDouble(int parameterIndex, double x)	将指定参数设置为给定 Java double 值。
void setInt(int parameterIndex, int x)	将指定参数设置为给定 Java int 值。
void setString(int parameterIndex, String x)	将指定参数设置为给定 Java String 值。
void setObject(int parameterIndex, Object x)	使用给定对象设置指定参数的值。

使用PreparedStatement完成登录案例

• 使用 PreparedStatement 预处理对象,可以有效的避免SQL注入

• 步骤：
  1.获取数据库连接对象
  2.编写SQL 使用? 占位符方式
  3.获取预处理对象 (预编译对象会将Sql发送给数据库 进行预编译)
  4.提示用户输入用户名 & 密码
  5.设置实际参数：setXxx(占位符的位置, 真实的值)
  6.执行查询获取结果集
  7.判断是否查询到数据 8.关闭资源

public class TestLogin02 {
    
    
/**
* 使用预编译对象 PrepareStatement 完成登录案例
* @param args
* @throws SQLException
*/
	public static void main(String[] args) throws SQLException {
    
    
		//1.获取连接
		Connection connection = JDBCUtils.getConnection();
		//2.获取Statement
		Statement statement = connection.createStatement();
		//3.获取用户输入的用户名和密码
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入用户名: ");
		String name = sc.nextLine();
		System.out.println("请输入密码: ");
		String pass = sc.nextLine();
		System.out.println(pass);
		//4.获取 PrepareStatement 预编译对象
		//4.1 编写SQL 使用 ? 占位符方式
		String sql = "select * from jdbc_user where username = ? and password = ?";
		PreparedStatement ps = connection.prepareStatement(sql);
		//4.2 设置占位符参数
		ps.setString(1,name);
		ps.setString(2,pass);
		//5. 执行查询 处理结果集
		ResultSet resultSet = ps.executeQuery();
		if(resultSet.next()){
    
    
			System.out.println("登录成功! 欢迎您: " + name);
		}else{
    
    
			System.out.println("登录失败!");
		}
		//6.释放资源
		JDBCUtils.close(connection,statement,resultSet);
	}
}

PreparedStatement的执行原理

• 分别使用 Statement对象 和 PreparedStatement对象进行插入操作
• 代码示例

public class TestPS {
    
    
	public static void main(String[] args) throws SQLException {
    
    
		Connection con = JDBCUtils.getConnection();
		//获取 Sql语句执行对象
		Statement st = con.createStatement();
		//插入两条数据
		st.executeUpdate("insert into jdbc_user values(null,'张三','123','1992/12/26')");
		st.executeUpdate("insert into jdbc_user values(null,'李四','123','1992/12/26')");
		//获取预处理对象
		PreparedStatement ps = con.prepareStatement("insert into jdbc_user values(?,?,?,?)");
		//第一条数 设置占位符对应的参数
		ps.setString(1,null);
		ps.setString(2,"长海");
		ps.setString(3,"qwer");
		ps.setString(4,"1990/1/10");
		//执行插入
		ps.executeUpdate();
		//第二条数据
		ps.setString(1,null);
		ps.setString(2,"小斌");
		ps.setString(3,"1122");
		ps.setString(4,"1990/1/10");
		//执行插入
		ps.executeUpdate();
		//释放资源
		st.close();
		ps.close();
		con.close();
	}
}

Statement 与 PreparedStatement的区别?

1. Statement用于执行静态SQL语句，在执行时，必须指定一个事先准备好的SQL语句。
2. PrepareStatement是预编译的SQL语句对象，语句中可以包含动态参数“?”，在执行时可以为“?”动态设置参数值。
3. PrepareStatement可以减少编译次数提高数据库性能。

6. JDBC 控制事务

• 之前我们是使用 MySQL 的命令来操作事务。接下来我们使用 JDBC 来操作银行转账的事务。

数据准备

-- 创建账户表
CREATE TABLE account(
	-- 主键
	id INT PRIMARY KEY AUTO_INCREMENT,
	-- 姓名
	NAME VARCHAR(10),
	-- 转账金额
	money DOUBLE
);
-- 添加两个用户
INSERT INTO account (NAME, money) VALUES ('tom', 1000), ('jack', 1000);

事务相关API

• 我们使用 Connection中的方法实现事务管理

方法	说明
void setAutoCommit(boolean autoCommit)	参数是 true 或 false 如果设置为 false，表示关闭自动提交，相当于开启事务
void commit()	提交事务
void rollback()	回滚事务

开发步骤

1. 获取连接
2. 开启事务
3. 获取到 PreparedStatement , 执行两次更新操作
4. 正常情况下提交事务
5. 出现异常回滚事务
6. 最后关闭资源

代码示例

public class JDBCTransaction {
    
    
	//JDBC 操作事务
	public static void main(String[] args) {
    
    
		Connection con = null;
		PreparedStatement ps = null;
		try {
    
    
			//1. 获取连接
			con = JDBCUtils.getConnection();
			//2. 开启事务
			con.setAutoCommit(false);
			//3. 获取到 PreparedStatement 执行两次更新操作
			//3.1 tom 账户 -500
			ps = con.prepareStatement("update account set money = money - ? where name = ? ");
			ps.setDouble(1,500.0);
			ps.setString(2,"tom");
			ps.executeUpdate();
			//模拟tom转账后 出现异常
			System.out.println(1 / 0);
			//3.2 jack 账户 +500
			ps = con.prepareStatement("update account set money = money + ? where name = ? ");
			ps.setDouble(1,500.0);
			ps.setString(2,"jack");
			ps.executeUpdate();
			//4. 正常情况下提交事务
			con.commit();
			System.out.println("转账成功!");
		} catch (SQLException e) {
    
    
			e.printStackTrace();
			try {
    
    
				//5. 出现异常回滚事务
				con.rollback();
			} catch (SQLException ex) {
    
    
				ex.printStackTrace();
			}
		} finally {
    
    
			//6. 最后关闭资源
			JDBCUtils.close(con,ps);
		}
	}
}

7. 总结

任务六 数据库连接池&DBUtils

1.数据库连接池

连接池介绍

1. 什么是连接池
    实际开发中“获得连接”或“释放资源”是非常消耗系统资源的两个过程，为了解决此类性能问题，通常情况我们采用连接池技术，来共享连接Connection。这样我们就不需要每次都创建连接、释放连接了，这些操作都交给了连接池.

2. 连接池的好处
    用池来管理Connection，这样可以重复使用Connection。 当使用完Connection后，调用Connection的close()方法也不会真的关闭Connection，而是把Connection“归还”给池。

JDBC方式与连接池方式

• 普通 JDBC方式
  

• 连接池方式
  

如何使用数据库连接池

• Java为数据库连接池提供了公共的接口：javax.sql.DataSource，各个厂商需要让自己的连接池实现这个接口。这样应用程序可以方便的切换不同厂商的连接池！
• 常见的连接池有 DBCP连接池, C3P0连接池, Druid连接池, 接下里我们就详细学习一下

数据准备

#创建数据库
CREATE DATABASE db5 CHARACTER SET utf8;
#使用数据库
USE db5;
#创建员工表
CREATE TABLE employee (
	eid INT PRIMARY KEY AUTO_INCREMENT ,
	ename VARCHAR (20), -- 员工姓名
	age INT , -- 员工年龄
	sex VARCHAR (6), -- 员工性别
	salary DOUBLE , -- 薪水
	empdate DATE -- 入职日期
);

#插入数据
INSERT INTO employee (eid, ename, age, sex, salary, empdate) VALUES(NULL,'李清照',22,'女',4000,'2018-11-12');
INSERT INTO employee (eid, ename, age, sex, salary, empdate) VALUES(NULL,'林黛玉',20,'女',5000,'2019-03-14');
INSERT INTO employee (eid, ename, age, sex, salary, empdate) VALUES(NULL,'杜甫',40,'男',6000,'2020-01-01');
INSERT INTO employee (eid, ename, age, sex, salary, empdate) VALUES(NULL,'李白',25,'男',3000,'2017-10-01');

DBCP连接池

• DBCP也是一个开源的连接池，是Apache成员之一，在企业开发中也比较常见，tomcat内置的连接池。

1 创建项目 导入 jar包

1. 将这两个 jar包添加到 myJar文件夹中 （jar包在资料里的软件文件夹中）
   commons-dbcp-1.4.jar
commons-pool-1.5.6.jar
2. 添加myJar库 到项目的依赖中
   

2 编写工具类

• 连接数据库表的工具类, 采用DBCP连接池的方式来完成
  Java中提供了一个连接池的规则接口 ： DataSource , 它是java中提供的连接池
  在DBCP包中提供了DataSource接口的实现类，我们要用的具体的连接池 BasicDataSource 类

代码示例
public class DBCPUtils {
    
    
	//1.定义常量 保存数据库连接的相关信息
	public static final String DRIVERNAME = "com.mysql.jdbc.Driver";
	public static final String URL = "jdbc:mysql://localhost:3306/db5?characterEncoding=UTF-8";
	public static final String USERNAME = "root";
	public static final String PASSWORD = "123456";
	//2.创建连接池对象 (有DBCP提供的实现类)
	public static BasicDataSource dataSource = new BasicDataSource();
	//3.使用静态代码块进行配置
	static{
    
    
		dataSource.setDriverClassName(DRIVERNAME);
		dataSource.setUrl(URL);
		dataSource.setUsername(USERNAME);
		dataSource.setPassword(PASSWORD);
	}
	//4.获取连接的方法
	public static Connection getConnection() throws SQLException {
    
    
	//从连接池中获取连接
	Connection connection = dataSource.getConnection();
		return connection;
	}
	//5.释放资源方法
	public static void close(Connection con, Statement statement){
    
    
		if(con != null && statement != null){
    
    
			try {
    
    
				statement.close();
				//归还连接
				con.close();
			} catch (SQLException e) {
    
    
				e.printStackTrace();
			}
		}
	}
	
	public static void close(Connection con, Statement statement, ResultSet resultSet){
    
    
		if(con != null && statement != null && resultSet != null){
    
    
			try {
    
    
				resultSet.close();
				statement.close();
				//归还连接
				con.close();
			} catch (SQLException e) {
    
    
				e.printStackTrace();
			}
		}
	}
}

3 测试工具类

需求: 查询所有员工的姓名
public class TestDBCP {
    
    
	/*
	* 测试DBCP连接池
	* */
	public static void main(String[] args) throws SQLException {
    
    
		//1.从DBCP连接池中拿到连接
		Connection con = DBCPUtils.getConnection();
		//2.获取Statement对象
		Statement statement = con.createStatement();
		//3.查询所有员工的姓名
		String sql = "select ename from employee";
		ResultSet resultSet = statement.executeQuery(sql);
		//4.处理结果集
		while(resultSet.next()){
    
    
			String ename = resultSet.getString("ename");
			System.out.println("员工姓名: " + ename);
		}
		//5.释放资源
		DBCPUtils.close(con,statement,resultSet);
	}
}

4 常见配置项

分类	属性	描述
必须项	driverClassName	数据库驱动名称
	url	数据库地址
	username	用户名
	password	密码
基本配置	maxActive	最大连接数量 默认值：8
	maxIdle	最大空闲连接 50个连接，30个最大空闲连接，正用10间接，空闲40个，但设置了30个最大空闲，所以10个会关闭掉 默认值：8
	minIdle	最小空闲连接 默认值：0
	initialSize	初始化连接 默认值：0

C3P0连接池

• C3P0是一个开源的JDBC连接池,支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate、Spring(业务层)等。

1. 导入jar包及配置文件

1. 将jar包 复制到myJar文件夹即可,IDEA会自动导入
   c3p0-0.9.5.2.jar
mchange-commons-java-0.2.12.jar
2. 导入配置文件 c3p0-config.xml
   c3p0-config.xml 文件名不可更改
   直接放到src下,也可以放到到资源文件夹中

<c3p0-config>
	<!--默认配置-->
	<default-config>
		<property name="driverClass">com.mysql.jdbc.Driver</property>
		<property name="jdbcUrl">jdbc:mysql://localhost:3306/db5?characterEncoding=UTF-8</property>
		<property name="user">root</property>
		<property name="password">123456</property>
		<!-- initialPoolSize：初始化时获取三个连接，取值应在minPoolSize与maxPoolSize之间。 -->
		<property name="initialPoolSize">3</property>
		<!-- maxIdleTime：最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。-->
		<property name="maxIdleTime">60</property>
		<!-- maxPoolSize：连接池中保留的最大连接数 -->
		<property name="maxPoolSize">100</property>
		<!-- minPoolSize: 连接池中保留的最小连接数 -->
		<property name="minPoolSize">10</property>
	</default-config>
	
	<!--配置连接池mysql-->
	<named-config name="mysql">
		<property name="driverClass">com.mysql.jdbc.Driver</property>
		<property name="jdbcUrl">jdbc:mysql://localhost:3306/db5</property>
		<property name="user">root</property>
		<property name="password">123456</property>
		<property name="initialPoolSize">10</property>
		<property name="maxIdleTime">30</property>
		<property name="maxPoolSize">100</property>
		<property name="minPoolSize">10</property>
	</named-config>
	<!--配置连接池2,可以配置多个-->
</c3p0-config>

3. 在项目下创建一个resource文件夹(专门存放资源文件)
   
4. 选择文件夹,右键 将resource文件夹指定为资源文件夹
   
5. 将文件放在resource目录下即可,创建连接池对象的时候会去加载这个配置文件
   

2. 编写C3P0工具类

• C3P0提供的核心工具类, ComboPooledDataSource , 如果想使用连接池,就必须创建该类的对象
• new ComboPooledDataSource(); 使用 默认配置
• new ComboPooledDataSource(“mysql”); 使用命名配置

public class C3P0Utils {
    
    
	//1.创建连接池对象 C3P0对DataSource接口的实现类
	//使用的配置是 配置文件中的默认配置
	//public static ComboPooledDataSource dataSource = new ComboPooledDataSource();
	//使用指定的配置
	public static ComboPooledDataSource dataSource = new ComboPooledDataSource("mysql");
	//获取连接的方法
	public static Connection getConnection() throws SQLException {
    
    
		return dataSource.getConnection();
	}
	//释放资源
	public static void close(Connection con, Statement statement){
    
    
		if(con != null && statement != null){
    
    
			try {
    
    
				statement.close();
				//归还连接
				con.close();
			} catch (SQLException e) {
    
    
				e.printStackTrace();
			}
		}
	}
	
	public static void close(Connection con, Statement statement, ResultSet resultSet){
    
    
		if(con != null && statement != null && resultSet != null){
    
    
			try {
    
    
				resultSet.close();
				statement.close();
				//归还连接
				con.close();
			} catch (SQLException e) {
    
    
				e.printStackTrace();
			}
		}
	}
}

3. 测试工具类

需求: 查询姓名为 李白的员工信息
public class TestC3P0 {
    
    
	//需求 查询姓名为李白的 记录
	public static void main(String[] args) throws SQLException {
    
    
		//1.获取连接
		Connection con = C3P0Utils.getConnection();
		//2.获取预处理对象
		String sql = "select * from employee where ename = ?";
		PreparedStatement ps = con.prepareStatement(sql);
		//3.设置占位符的值
		ps.setString(1,"李白");
		ResultSet resultSet = ps.executeQuery();
		//4.处理结果集
		while(resultSet.next()){
    
    
			int eid = resultSet.getInt("eid");
			String ename = resultSet.getString("ename");
			int age = resultSet.getInt("age");
			String sex = resultSet.getString("sex");
			double salary = resultSet.getDouble("salary");
			Date date = resultSet.getDate("empdate");
			System.out.println(eid +" " + ename + " " + age +" " + sex +" " + salary +" "+date);
		}
		//5.释放资源
		C3P0Utils.close(con,ps,resultSet);
	}
}

4. 常见配置

分类	属性	描述
必须项	user	用户名
	password	密码
	driveClass	驱动
	jdbcUrl	路径
基本配置	initialPoolSize	连接池初始化时创建的连接数 默认值：3
	maxPoolSize	连接池中拥有的最大连接数 默认值：15
	minPoolSize	连接池保持的最小连接数 默认值：10
	maxIdleTime	连接的最大空闲时间。如果超过这个时间，某个数据库连接还没有被使用，则会断开掉这个连接，如果为0则永远不会断开连接 默认值：0

Druid连接池

• Druid（德鲁伊）是阿里巴巴开发的号称为监控而生的数据库连接池，Druid是目前最好的数据库连接池。在功能、性能、扩展性方面，都超过其他数据库连接池，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况。

1. 导入jar包及配置文件

1. 导入 jar包
   ·druid-1.0.9.jar·
2. 导入配置文件
   是properties形式的
   可以叫任意名称，可以放在任意目录下,我们统一放到 resources资源目录

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db5?characterEncoding=UTF-8
username=root
password=123456
initialSize=5
maxActive=10
maxWait=3000

2. 编写Druid工具类

• 获取数据库连接池对象
  通过工厂来来获取 DruidDataSourceFactory类的createDataSource方法
  createDataSource(Properties p) 方法参数可以是一个属性集对象

public class DruidUtils {
    
    
	//1.定义成员变量
	public static DataSource dataSource;
	
	//2.静态代码块
	static{
    
    
		try {
    
    
			//3.创建属性集对象
			Properties p = new Properties();
			//4.加载配置文件 
			//Druid 连接池不能够主动加载配置文件 ,需要指定文件
            //制定一个文件，getResourceAsStream会返回一个流，这个流和文件就建立了一个联系
			InputStream inputStream = DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties");
			//5. 使用Properties对象的 load方法 从字节流中读取配置信息
			p.load(inputStream);
			//6. 通过工厂类获取连接池对象
			dataSource = DruidDataSourceFactory.createDataSource(p);
		} catch (Exception e) {
    
    
			e.printStackTrace();
		}
	}
	
	//获取连接的方法
	public static Connection getConnection(){
    
    
		try {
    
    
			return dataSource.getConnection();
		} catch (SQLException e) {
    
    
			e.printStackTrace();
			return null;
		}
	}
	
	//释放资源
	public static void close(Connection con, Statement statement){
    
    
		if(con != null && statement != null){
    
    
			try {
    
    
				statement.close();
				//归还连接
				con.close();
			} catch (SQLException e) {
    
    
				e.printStackTrace();
			}
		}
	}
	
	public static void close(Connection con, Statement statement, ResultSet resultSet){
    
    
		if(con != null && statement != null && resultSet != null){
    
    
			try {
    
    
				resultSet.close();
				statement.close();
				//归还连接
				con.close();
			} catch (SQLException e) {
    
    
				e.printStackTrace();
			}
		}
	}
}

3. 测试工具类

需求: 查询薪资在3000 - 5000元之间的员工姓名

public class TestDruid {
    
    
	// 需求 查询 薪资在3000 到 5000之间的员工的姓名
	public static void main(String[] args) throws SQLException {
    
    
		//1.获取连接
		Connection con = DruidUtils.getConnection();
		//2.获取Statement对象
		Statement statement = con.createStatement();
		//3.执行查询
		ResultSet resultSet = statement.executeQuery("select ename from employee where salary between 3000 and 5000");
		//4.处理结果集
		while(resultSet.next()){
    
    
			String ename = resultSet.getString("ename");
			System.out.println(ename);
		}
		//5.释放资源
		DruidUtils.close(con,statement,resultSet);
	}
}

2.DBUtils工具类

DBUtils简介

• 使用JDBC我们发现冗余的代码太多了,为了简化开发 我们选择使用 DbUtils
• Commons DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能。
• 使用方式:
  DBUtils就是JDBC的简化开发工具包。
  需要项目导入commons-dbutils-1.6.jar。

1. Dbutils核心功能介绍

1. QueryRunner 中提供对sql语句操作的API.
2. ResultSetHandler接口，用于定义select操作后，怎样封装结果集.
3. DbUtils类,他就是一个工具类,定义了关闭资源与事务处理相关方法.

案例相关知识

1. 表和类之间的关系

• 整个表可以看做是一个类
• 表中的一行记录,对应一个类的实例(对象)
• 表中的一列,对应类中的一个成员属性

2. JavaBean组件

1. JavaBean 就是一个类, 开发中通常用于封装数据,有一下特点
   1) 需要实现 序列化接口, Serializable (暂时可以省略)
   2) 提供私有字段: private 类型 变量名;
   3) 提供 getter 和 setter
   4) 提供 空参构造
2. 创建Employee类和数据库的employee表对应
   1) 我们可以创建一个 entity包,专门用来存放 JavaBean类

public class Employee implements Serializable {
    
    
	private int eid;
	private String ename;
	private int age;
	private String sex;
	private double salary;
	private Date empdate;
	//空参 getter setter省略
}

DBUtils完成 CRUID

1. QueryRunner核心类

• 构造方法
  QueryRunner()
QueryRunner(DataSource ds) ,提供数据源（连接池），DBUtils底层自动维护连接connection

• 常用方法
  update(Connection conn, String sql, Object... params)，用来完成表数据的增加、删除、更新操作
  query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params)，用来完成表数据的查询操作

2. QueryRunner的创建

• 手动模式

//手动方式 创建QueryRunner对象
QueryRunner qr = new QueryRunner();

• 自动模式

//自动创建 传入数据库连接池对象
QueryRunner qr2 = new QueryRunner(DruidUtils.getDataSource());

• 自动模式需要传入连接池对象

//获取连接池对象
public static DataSource getDataSource(){
    
    
	return dataSource;
}

3. QueryRunner实现增、删、改操作

• 核心方法
  update(Connection conn, String sql, Object... params)

参数	说明
Connection conn	数据库连接对象, 自动模式创建QueryRun 可以不传 ,手动模式必须传递
String sql	占位符形式的SQL ,使用 ? 号占位符
Object… param	Object类型的 可变参,用来设置占位符上的参数

• 步骤
  1.创建QueryRunner(手动或自动)
  2.占位符方式 编写SQL
  3.设置占位符参数
  4.执行

添加

@Test
public void testInsert() throws SQLException {
    
    
	//1.创建 QueryRunner 手动模式创建
	QueryRunner qr = new QueryRunner();
	//2.编写 占位符方式 SQL
	String sql = "insert into employee values(?,?,?,?,?,?)";
	//3.设置占位符的参数
	Object[] param = {
    
    null,"张百万",20,"女",10000,"1990-12-26"};
	//4.执行 update方法
	Connection con = DruidUtils.getConnection();
	int i = qr.update(con, sql, param);
	//5.释放资源
	DbUtils.closeQuietly(con);
}

修改

//修改操作 修改姓名为张百万的员工工资
@Test
public void testUpdate() throws SQLException {
    
    
	//1.创建QueryRunner对象 自动模式,传入数据库连接池
	QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
	//2.编写SQL
	String sql = "update employee set salary = ? where ename = ?";
	//3.设置占位符参数
	Object[] param = {
    
    0,"张百万"};
	//4.执行update, 不需要传入连接对象
	qr.update(sql,param);
}

删除

//删除操作 删除id为1 的数据
@Test
public void testDelete() throws SQLException {
    
    
	QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
	String sql = "delete from employee where eid = ?";
	//只有一个参数,不需要创建数组
	qr.update(sql,1);
}

4. QueryRunner实现查询操作

• ResultSetHandler接口简介
  ResultSetHandler可以对查询出来的ResultSet结果集进行处理，达到一些业务上的需求。
• ResultSetHandler 结果集处理类
  本例展示的是使用ResultSetHandler接口的几个常见实现类实现数据库的增删改查，可以大大减少代码量，优化程序。
  每一种实现类都代表了对查询结果集的一种处理方式

ResultSetHandler 实现类	说明
ArrayHandler	将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值
ArrayListHandler	将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。
BeanHandler	将结果集中第一条记录封装到一个指定的javaBean中.
BeanListHandler	将结果集中每一条记录封装到指定的javaBean中，再将这些javaBean在封装到List集合中
ColumnListHandler	将结果集中指定的列的字段值，封装到一个List集合中
KeyedHandler	将结果集中每一条记录封装到Map<String,Object>,在将这个map集合做为另一个Map的value,另一个Map集合的key是指定的字段的值。
MapHandler	将结果集中第一条记录封装到了Map<String,Object>集合中，key就是字段名称，value就是字段值
MapListHandler	将结果集中每一条记录封装到了Map<String,Object>集合中，key就是字段名称，value就是字段值，在将这些Map封装到List集合中。
ScalarHandler	它是用于封装单个数据。例如 select count(*) from 表操作。

• ResultSetHandler 常用实现类测试
  QueryRunner的查询方法
  query方法的返回值都是泛型,具体的返回值类型,会根据结果集的处理方式,发生变化

方法	说明
query(String sql, handler ,Object[] param)	自动模式创建QueryRunner, 执行查询<b
query(Connection con,String sql,handler,Object[] param)	手动模式创建QueryRunner, 执行查询

创建一个测试类, 对ResultSetHandler接口的几个常见实现类进行测试
- 查询id为5的记录,封装到数组中
- 查询所有数据,封装到List集合中
- 查询id为5的记录,封装到指定JavaBean中
- 查询薪资大于 3000 的所员工信息,封装到JavaBean中再封装到List集合中
- 查询姓名是 张百万的员工信息,将结果封装到Map集合中
- 查询所有员工的薪资总额

1) 查询id为5的记录,封装到数组中

/*
* 查询id为5的记录,封装到数组中
* ArrayHandler 将结果集的第一条数据封装到数组中
* */
@Test
public void testFindById() throws SQLException {
    
    
	//1.创建QueryRunner
	QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
	//2.编写SQL
	String sql = "select * from employee where eid = ?";
	//3.执行查询
	Object[] query = qr.query(sql, new ArrayHandler(), 5);
	//4.获取数据
	System.out.println(Arrays.toString(query));
}

2) 查询所有数据,封装到List集合中

/**
* 查询所有数据,封装到List集合中
* ArrayListHandler可以将每条数据先封装到数组中, 再将数组封装到集合中
*
*/
@Test
public void testFindAll() throws SQLException {
    
    
	//1.创建QueryRunner
	QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
	//2.编写SQL
	String sql = "select * from employee";
	//3.执行查询
	List<Object[]> query = qr.query(sql, new ArrayListHandler());
	//4.遍历集合获取数据
	for (Object[] objects : query) {
    
    
		System.out.println(Arrays.toString(objects));
	}
}

3) 根据ID查询,封装到指定JavaBean中

/**
* 查询id为3的记录,封装到指定JavaBean中
* BeanHandler 将结果集的第一条数据封装到 javaBean中
*
**/
@Test
public void testFindByIdJavaBean() throws SQLException {
    
    
	QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
	String sql = "select * from employee where eid = ?";
	Employee employee = qr.query(sql, new BeanHandler<Employee>(Employee.class), 3);
	System.out.println(employee);
}

4) 查询薪资大于 3000 的所员工信息,封装到JavaBean中再封装到List集合中

/*
* 查询薪资大于 3000 的所员工信息,封装到JavaBean中再封装到List集合中
* BeanListHandler 将结果集的每一条和数据封装到 JavaBean中 再将JavaBean 放到list集合中
* */
@Test
public void testFindBySalary() throws SQLException {
    
    
	QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
	String sql = "select * from employee where salary > ?";
	List<Employee> list = qr.query(sql, new BeanListHandler<Employee>(Employee.class),3000);
	for (Employee employee : list) {
    
    
		System.out.println(employee);
	}
}

5) 查询姓名是 张百万的员工信息,将结果封装到Map集合中

/*
* 查询姓名是 张百万的员工信息,将结果封装到Map集合中
* MapHandler 将结果集的第一条记录封装到 Map<String,Object>中
* key对应的是 列名 value对应的是 列的值
* */
@Test
public void testFindByName() throws SQLException {
    
    
	QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
	String sql = "select * from employee where ename = ?";
	Map<String, Object> map = qr.query(sql, new MapHandler(), "张百万");
	Set<Map.Entry<String, Object>> entries = map.entrySet();
	for (Map.Entry<String, Object> entry : entries) {
    
    
		//打印结果
		System.out.println(entry.getKey() +" = " +entry.getValue());
	}
}

6) 查询所有员工的薪资总额

/*
* 查询所有员工的薪资总额
* ScalarHandler 用于封装单个的数据
* */
@Test
public void testGetSum() throws SQLException {
    
    
	QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
	String sql = "select sum(salary) from employee";
	Double sum = (Double)qr.query(sql, new ScalarHandler<>());
	System.out.println("员工薪资总额: " + sum);
}

• BeanHandler(Class type) (上面代码的3)中)
  创建BeanHandler 需要传递一个参数，参数就是JavaBean类的class文件对象
  我们的JavaBean是Employee
  Employee.class 通过反射去创建Employee对象
  将结果集封装到对象中并返回

3.数据库批处理

什么是批处理

• 批处理(batch) 操作数据库
  批处理指的是一次操作中执行多条SQL语句，批处理相比于一次一次执行效率会提高很多。
  当向数据库中添加大量的数据时，需要用到批处理。
• 举例: 送货员的工作：
  未使用批处理的时候，送货员每次只能运送 一件货物给商家；
  使用批处理，则是送货员将所有要运送的货物, 都用车带到发放处派给客户。

实现批处理

• Statement和PreparedStatement都支持批处理操作，这里我们介绍一下PreparedStatement的批处理方式：

1. 要用到的方法

方法	说明
void addBatch()	将给定的 SQL 命令添加到此 Statement 对象的当前命令列表中。 通过调用方法 executeBatch 可以批量执行此列表中的命令。
int[] executeBatch()	每次提交一批命令到数据库中执行，如果所有的命令都成功执行了， 那么返回一个数组，这个数组是说明每条命令所影响的行数

2. mysql 批处理是默认关闭的，所以需要加一个参数才打开mysql 数据库批处理，在url中添加

rewriteBatchedStatements=true
例如: url=jdbc:mysql://127.0.0.1:3306/db5?characterEncoding=UTF-8&rewriteBatchedStatements=true

3. 创建一张表

CREATE TABLE testBatch (
	id INT PRIMARY KEY AUTO_INCREMENT,
	uname VARCHAR(50)
)

4. 测试向表中插入 1万条数据

public class TestBatch {
    
    
	//使用批处理,向表中添加 1万条数据
	public static void main(String[] args) {
    
    
		try {
    
    
			//1.获取连接
			Connection con = DruidUtils.getConnection();
			//2.获取预处理对象
			String sql ="insert into testBatch(uname) values(?)";
			PreparedStatement ps = con.prepareStatement(sql);
			//3.创建 for循环 来设置占位符参数
			for (int i = 0; i < 10000 ; i++) {
    
    
				ps.setString(1,"小强"+i);
				//将SQL添加到批处理 列表
				ps.addBatch();
			}
			//添加时间戳 测试执行效率
			long start = System.currentTimeMillis();
			//统一 批量执行
			ps.executeBatch();
			long end = System.currentTimeMillis();
			System.out.println("插入10000条数据使用: " +(end - start) +" 毫秒!");
		} catch (SQLException e) {
    
    
			e.printStackTrace();
		}
	}
}

4.MySql元数据

什么是元数据

• 除了表之外的数据都是元数据,可以分为三类
  查询结果信息： UPDATE 或 DELETE语句 受影响的记录数。
  数据库和数据表的信息： 包含了数据库及数据表的结构信息。
  MySQL服务器信息： 包含了数据库服务器的当前状态，版本号等。

常用命令

-- 元数据相关的命令介绍
-- 1.查看服务器当前状态
-- 2.查看MySQl的版本信息
-- 3.查询表中的详细信息
-- 4.显示数据表的详细索引信息
-- 5.列出所有数据库
-- 6.显示当前数据库的所有表
-- 7.获取当前的数据库名

• select version(); 获取mysql服务器的版本信息
• show status; 查看服务器的状态信息
• show columns from table_name; 显示表的字段信息等，和desc table_name一样
• show index from table_name; 显示数据表的详细索引信息，包括PRIMARY KEY（主键）
• show databases:列出所有数据库
• show tables : 显示当前数据库的所有表
• select database(): 获取当前的数据库名

使用JDBC 获取元数据

• 通过JDBC 也可以获取到元数据,比如数据库的相关信息,或者当我们使用程序查询一个不熟悉的表时, 我们可以通过获取元素据信息,了解表中有多少个字段,字段的名称 和 字段的类型.

1. 常用类介绍

• JDBC中描述元数据的类

元数据类	作用
DatabaseMetaData	描述数据库的元数据对象
ResultSetMetaData	描述结果集的元数据对象

• 获取元数据对象的方法 : getMetaData ()
  connection 连接对象, 调用 getMetaData () 方法,获取的是DatabaseMetaData 数据库元数据对象
  PrepareStatement 预处理对象调用 getMetaData () , 获取的是ResultSetMetaData , 结果集元数据对象

• DatabaseMetaData的常用方法

方法	方法说明
getURL()	获取数据库的URL
getUserName()	获取当前数据库的用户名
getDatabaseProductName()	获取数据库的产品名称
getDatabaseProductVersion()	获取数据的版本号
getDriverName()	返回驱动程序的名称
isReadOnly()	判断数据库是否只允许只读 true 代表只读

• ResultSetMetaData的常用方法

方法	方法说明
getColumnCount()	当前结果集共有多少列
getColumnName(int i)	获取指定列号的列名, 参数是整数 从1开始
getColumnTypeName(int i)	获取指定列号列的类型, 参数是整数 从1开始

2. 代码示例

public class TestMetaData {
    
    
	//1.获取数据库相关的元数据信息 使用DatabaseMetaData
	@Test
	public void testDataBaseMetaData() throws SQLException {
    
    
		//1.获取数据库连接对象 connection
		Connection connection = DruidUtils.getConnection();
		//2.获取代表数据库的 元数据对象 DatabaseMetaData
		DatabaseMetaData metaData = connection.getMetaData();
		//3.获取数据库相关的元数据信息
		String url = metaData.getURL();
		System.out.println("数据库URL: " + url);
		String userName = metaData.getUserName();
		System.out.println("当前用户: " + userName );
		String productName = metaData.getDatabaseProductName();
		System.out.println("数据库产品名: " + productName);
		String version = metaData.getDatabaseProductVersion();
		System.out.println("数据库版本: " + version);
		String driverName = metaData.getDriverName();
		System.out.println("驱动名称: " + driverName);
		//判断当前数据库是否只允许只读
		boolean b = metaData.isReadOnly(); //如果是 true 就表示 只读
		if(b){
    
    
			System.out.println("当前数据库只允许读操作!");
		}else{
    
    
			System.out.println("不是只读数据库");
		}
		connection.close();
	}
	
	//获取结果集中的元数据信息
	@Test
	public void testResultSetMetaData() throws SQLException {
    
    
		//1.获取连接
		Connection con = DruidUtils.getConnection();
		//2.获取预处理对象
		PreparedStatement ps = con.prepareStatement("select * from employee");
		ResultSet resultSet = ps.executeQuery();
		//3.获取结果集元素据对象
		ResultSetMetaData metaData = ps.getMetaData();
		//1.获取当前结果集 共有多少列
		int count = metaData.getColumnCount();
		System.out.println("当前结果集中共有: " + count + " 列");
		//2.获结果集中 列的名称 和 类型
		for (int i = 1; i <= count; i++) {
    
    
			String columnName = metaData.getColumnName(i);
			System.out.println("列名: "+ columnName);
			String columnTypeName = metaData.getColumnTypeName(i);
			System.out.println("类型: " +columnTypeName);
		}
		//释放资源
		DruidUtils.close(con,ps,resultSet);
	}
}

5.总结

任务七 XML

1. XML基本介绍

概述

• XML即可扩展标记语言（Extensible Markup Language）
  W3C在1998年2月发布1.0版本，2004年2月又发布1.1版本，但因为1.1版本不能向下兼容1.0版本，所以1.1没有人用。同时，在2004年2月W3C又发布了1.0版本的第三版。我们要学习的还是1.0版本 !
• 特点
  可扩展的, 标签都是自定义的
  语法十分严格

XML的作用

功能	说明
存储数据	通常，我们在数据库中存储数据。不过，如果希望数据的可移植性更强，我们可以把数据存储 XML 文件中 (properties也可以存储数据)
配置文件	作为各种技术框架的配置文件使用 (最多)
在网络中传输	客户端可以使用XML格式向服务器端发送数据,服务器接收到xml格式数据,进行解析

2. XML的语法

XML文档声明格式

• 文档声明必须为结束；
• 文档声明必写在第一行；
• 语法格式:
  <?xml version="1.0" encoding="UTF-8"?>
• 属性说明:
  versioin：指定XML文档版本。必须属性，因为我们不会选择1.1，只会选择1.0；
  encoding：指定当前文档的编码。可选属性，默认值是utf-8；

元素

• Element 元素: 是XML文档中最重要的组成部分
• 元素的命名规则
  1. 不能使用空格，不能使用冒号
  2. xml 标签名称区分大小写
  3. XML 必须有且只有一个根元素
• 语法格式:
  <users><users>
  1) XML 必须有且只有一个根元素，它是所有其他元素的父元素，比如以下实例中 users 就是根元素：
  <?xml version="1.0" encoding="utf-8" ?> <users> </users>
  2) 普通元素的结构开始标签、元素体、结束标签组成。
  <hello> 大家好 </hello>
  3) 元素体：元素体可以是元素，也可以是文本
  <hello> <a>你好</a> </hello>
  4) 空元素：空元素只有开始标签，而没有结束标签，但元素必须自己闭合
  <close/>

属性

• <bean id="" class=""> </bean>

1. 属性是元素的一部分，它必须出现在元素的开始标签中
2. 属性的定义格式：属性名=属性值，其中属性值必须使用单引或双引
3. 一个元素可以有0~N个属性，但一个元素中不能出现同名属性
4. 属性名不能使用空格、冒号等特殊字符，且必须以字母开头

注释

• XML的注释，以“ ”结束。注释内容会被XML解析器忽略！

<?xml version="1.0" encoding="utf-8" ?>
<users>

    <user id="123" number="">
        <name>张百万</name>
        <age>15</age>
    </user>

    <user id="456">
        <name>小斌</name>
        <age>18</age>
        <hobby>
            <pingpang>

            </pingpang>
        </hobby>
    </user>

    <!--  空元素没有结束标签  -->
    <close/>

</users>

<!-- XML的注释

    1.XML中必须进行文档声明
        version 版本信息
        encoding 编码

    2.XML的文档声明必须写在第一行

    3.XML中的元素标签 命名规则
        1.标签定义 不能使用空格或者冒号
        2.标签名称 区分大小写

    4.XML中有且只有一个根元素

    5.元素体可以是文本或者还是一个标签，都可以
        可以定义空元素，空元素没有结束标签

    6.属性是元素的一部分，只能出现在标签的开始标签中
        属性值必须用单引号或者双引号包裹
        一个元素标签可以定义多个属性
-->

使用XML 描述数据表中的数据

<?xml version="1.0" encoding="UTF-8" ?>
<employees>

	<employee eid="2">
		<ename>林黛玉</ename>
		<age>20</age>
		<sex>女</sex>
		<salary>5000</salary>
		<empdate>2019-03-14</empdate>
	</employee>
	
	<employee eid="3">
		<ename>杜甫</ename>
		<age>40</age>
		<sex>男</sex>
		<salary>15000</salary>
		<empdate>2010-01-01</empdate>
	</employee>
	
</employees>

3. XML约束

• 在XML技术里，可以编写一个文档来约束一个XML文档的书写规范，这称之为XML约束。不需要我们写，只要能看懂就好

<?xml version="1.0" encoding="UTF-8" ?>
<employees>

    <employee eid="2">
        <ename>林黛玉</ename>
        <age>20</age>
        <sex>女</sex>
        <salary>5000</salary>
        <empdate>2000-01-01</empdate>
<!--    下面两个是表中没有的列，但这里可以写，不符合表，需要约束    -->
        <hobby></hobby>
        <hello></hello>
    </employee>

    <employee eid="3">
        <ename>杜普</ename>
        <age>40</age>
        <sex>男</sex>
        <salary>15000</salary>
        <empdate>2000-01-01</empdate>
    </employee>

</employees>

• 常见的xml约束：
  - DTD
  - Schema
• 作为程序员只要掌握两点
  - 会阅读
  - 会引入
  - 不用自己编写
  

DTD约束

• DTD（Document Type Definition），文档类型定义，用来约束XML文档。规定XML文档中元素的名称，子元素的名称及顺序，元素的属性等。

1. 编写DTD

• 开发中，我们不会自己编写DTD约束文档

• 常情况我们都是通过框架提供的DTD约束文档，编写对应的XML文档。常见框架使用DTD约束有：Struts2、hibernate等。

• 创建约束文件 student.dtd

<!ELEMENT students (student+) >
	<!ELEMENT student (name,age,sex)>
	<!ELEMENT name (#PCDATA)>
	<!ELEMENT age (#PCDATA)>
	<!ELEMENT sex (#PCDATA)>
	<!ATTLIST student number ID #REQUIRED>
<!--
	ELEMENT: 用来定义元素
	students (student+) : 代表根元素 必须是 <students>
	student+ : 根标签中至少有一个 student子元素, + 代表至少一个
	student (name,age,sex): student 标签中包含的子元素,按顺序出现
	#PCDATA: 是普通文本内容
	ATTLIST: 用来定义属性
		student number ID #REQUIRED
		student子元素中 有一个ID属性叫做 number,是必须填写的
		ID: 唯一 值只能是字母或者下划线开头
-->

2. 引入DTD

• 引入dtd文档到xml文档中,两种方式
  - 内部dtd：将约束规则定义在xml文档中
  - 外部dtd：将约束的规则定义在外部的dtd文件中
   本地: <!DOCTYPE 跟标签名 SYSTEM “dtd文件的位置”>
   网络: <!DOCTYPE 跟标签名 PUBLIC “dtd文件名字” “dtd文件的位置URL”>

• student.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE students SYSTEM "student.dtd">
<students>

	<student number="s1">
		<name>小斌</name>
		<age>22</age>
		<sex>男</sex>
	</student>
	
	<student number="s2">
		<name>广坤</name>
		<age>55</age>
		<sex>男</sex>
	</student>
	
</students>

Schema约束

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE students SYSTEM "student.dtd">
<students>

	<student number="s1">
		<name>小斌</name>
<!--    没有人活到22000，Schema可以控制这个范围    -->
		<age>22000</age>
		<sex>男</sex>
	</student>
	
</students>

1. 什么是Schema

1. Schema是新的XML文档约束, 比DTD强大很多，是DTD 替代者；
2. Schema本身也是XML文档，但Schema文档的扩展名为xsd，而不是xml。
3. Schema 功能更强大，内置多种简单和复杂的数据类型
4. Schema 支持命名空间 (一个XML中可以引入多个约束文档)

2. Schema约束示例

• student.xsd

<?xml version="1.0"?>
<xsd:schema xmlns="http://www.lagou.com/xml"
			xmlns:xsd="http://www.w3.org/2001/XMLSchema"
			targetNamespace="http://www.lagou.com/xml"
			elementFormDefault="qualified">
	<xsd:element name="students" type="studentsType"/>
	<xsd:complexType name="studentsType">
		<xsd:sequence>
			<xsd:element name="student" type="studentType" minOccurs="0" maxOccurs="unbounded"/>
		</xsd:sequence>
	</xsd:complexType>
	<xsd:complexType name="studentType">
		<xsd:sequence>
			<xsd:element name="name" type="xsd:string"/>
			<xsd:element name="age" type="ageType" />
			<xsd:element name="sex" type="sexType" />
		</xsd:sequence>
		<xsd:attribute name="number" type="numberType" use="required"/>
	</xsd:complexType>
	<xsd:simpleType name="sexType">
		<xsd:restriction base="xsd:string">
			<xsd:enumeration value="male"/>
			<xsd:enumeration value="female"/>
		</xsd:restriction>
	</xsd:simpleType>
	<xsd:simpleType name="ageType">
		<xsd:restriction base="xsd:integer">
			<xsd:minInclusive value="0"/>
			<xsd:maxInclusive value="200"/>
		</xsd:restriction>
	</xsd:simpleType>
	<xsd:simpleType name="numberType">
		<xsd:restriction base="xsd:string">
			<xsd:pattern value="hehe_\d{4}"/>
		</xsd:restriction>
	</xsd:simpleType>
</xsd:schema>

• Xml Schema的根元素：
  

3. XML引入Schema约束

• xml中引入schema约束的步骤：

1. 查看schema文档，找到根元素，在xml中写出来

<?xml version="1.0" encoding="UTF-8" ?>
<students>
</students>

2. 根元素来自哪个命名空间。使用xmlns指令来声明

<?xml version="1.0" encoding="UTF-8" ?>
<students
	xmlns="http://www.lagou.com/xml"
>
</students>

3. 引入 w3c的标准命名空间, 复制即可

<?xml version="1.0" encoding="UTF-8" ?>
<students
	xmlns="http://www.lagou.com/xml"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
>
</students>

4. 引入的命名空间跟哪个xsd文件对应？
   使用schemaLocation来指定：两个取值：第一个为命名空间 第二个为xsd文件的路径

<?xml version="1.0" encoding="UTF-8" ?>
<students
	xmlns="http://www.lagou.com/xml"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.lagou.com/xml student.xsd"
>
</students>

5. 命名空间
   指的是一个环境,所用的标签来自于哪个环境定义的。
6. student.xml

<?xml version="1.0" encoding="UTF-8" ?>
<students
	xmlns="http://www.lagou.com/xml"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.lagou.com/xml student.xsd"
>
	<student number="hehe_1234">
		<name>张百万</name>
		<age>25</age>
		<sex>female</sex>
	</student>

	<student number="hehe_0000">
		<name>小斌</name>
		<age>20</age>
		<sex>male</sex>
	</student>
</students>

4. XML 解析

解析概述

• 当将数据存储在XML后，我们就希望通过程序获得XML的内容。如果我们使用Java基础所学习的IO知识是可以完成的，不过你需要非常繁琐的操作才可以完成，且开发中会遇到不同问题（只读、读写）。人们为不同问题提供不同的解析方式，并提交对应的解析器，方便开发人员操作XML。

XML解析方式

1. 开发中比较常见的解析方式有两种，如下：

• DOM：要求解析器把整个XML文档装载到内存，并解析成一个Document对象。
  - 优点：元素与元素之间保留结构关系，故可以进行增删改查操作。
  - 缺点：XML文档过大，可能出现内存溢出现象。
• SAX：是一种速度更快，更有效的方法。它逐行扫描文档，一边扫描一边解析。并以事件驱动的方式进行具体解析，每执行一行，都将触发对应的事件。（了解）
  - 优点：占用内存少 处理速度快，可以处理大文件
  - 缺点：只能读，逐行后将释放资源。

XML常见的解析器

1. 解析器：就是根据不同的解析方式提供的具体实现。有的解析器操作过于繁琐，为了方便开发人员，有提供易于操作的解析开发包

• JAXP：sun公司提供的解析器，支持DOM和SAX两种思想
• DOM4J：一款非常优秀的解析器 , Dom4j是一个易用的、开源的库，用于XML，XPath和XSLT。
  它应用于Java平台，采用了Java集合框架并完全支持DOM，SAX和JAXP。
• Jsoup：jsoup 是一款Java 的HTML解析器 ,也可以解析XML
• PULL：Android内置的XML解析方式，类似SAX。

DOM4J 的使用

1. 导入JAR包

• dom4j-1.6.1.jar

2. API介绍

• 使用核心类SaxReader加载xml文档获得Document，通过Document 对象获得文档的根元素，然后就可以操作了

• 常用API如下：

1. SaxReader对象
   read(…) 加载执行xml文档
2. Document对象
   getRootElement() 获得根元素
3. Element对象
   elements(…) 获得指定名称的所有子元素。可以不指定名称
   element(…) 获得指定名称的第一个子元素。可以不指定名称
   getName() 获得当前元素的元素名
   attributeValue(…) 获得指定属性名的属性值
   elementText(…) 获得指定名称子元素的文本值
   getText() 获得当前元素的文本内容

3. 准备xml文件

• 编写user.xsd schema约束

<?xml version="1.0" encoding="UTF-8" ?>
<xsd:schema xmlns="http://www.lagou.com/xml"
	xmlns:xsd="http://www.w3.org/2001/XMLSchema"
	targetNamespace="http://www.lagou.com/xml"
	elementFormDefault="qualified">

	<xsd:element name="users" type="usersType"/>
	<xsd:complexType name="usersType">
		<xsd:sequence>
			<xsd:element name="user" type="userType" minOccurs="0" maxOccurs="unbounded"/>
		</xsd:sequence>
	</xsd:complexType>

	<xsd:complexType name="userType">
		<xsd:sequence>
			<xsd:element name="name" type="xsd:string"/>
			<xsd:element name="age" type="ageType" />
			<xsd:element name="hobby" type="hobbyType" />
		</xsd:sequence>
		<xsd:attribute name="id" type="numberType" use="required"/>
	</xsd:complexType>

	<xsd:simpleType name="ageType">
		<xsd:restriction base="xsd:integer">
			<xsd:minInclusive value="0"/>
			<xsd:maxInclusive value="100"/>
		</xsd:restriction>
	</xsd:simpleType>

	<xsd:simpleType name="hobbyType">
		<xsd:restriction base="xsd:string">
			<xsd:enumeration value="抽烟"/>
			<xsd:enumeration value="喝酒"/>
			<xsd:enumeration value="烫头"/>
		</xsd:restriction>
	</xsd:simpleType>

	<xsd:simpleType name="numberType">
		<xsd:restriction base="xsd:string">
			<xsd:pattern value="\d"/>
		</xsd:restriction>
	</xsd:simpleType>

</xsd:schema>

• 编写user.xml 引入约束

<?xml version="1.0" encoding="UTF-8" ?>
<users
	<!--自定义的命名空间-->
	xmlns="http://www.lagou.com/xml"   
	<!--W3提供的命名空间-->
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
	<!--约束文件的位置-->
	xsi:schemaLocation="http://www.lagou.com/xml user.xsd"
>

	<user id="1">
		<name>张百万</name>
		<age>20</age>
		<hobby>抽烟</hobby>
	</user>

	<user id="2">
		<name>于谦</name>
		<age>50</age>
		<hobby>喝酒</hobby>
	</user>

	<user id="3">
		<name>刘能</name>
		<age>40</age>
		<hobby>烫头</hobby>
	</user>

</users>

4. 读取XML

public class TestDOM4j {
    
    
	//获取XML文件中的 所有的元素名称(标签)
	@Test
	public void test1() throws DocumentException {
    
    
		//1.获取XML解析对象
		SAXReader reader = new SAXReader();
		//2.解析XML 获取 文档对象 document
		Document document =
		reader.read("H:\\jdbc_work\\xml_task03\\src\\com\\lagou\\xml03\\user.xml");
		//3.获取根元素
		Element rootElement = document.getRootElement();
		//获取根元素名称
		System.out.println(rootElement.getName());
		//获取 根元素下的标签
		List<Element> elements = rootElement.elements();
		for (Element element : elements) {
    
    
			System.out.println("根标签下的子节点: " + element.getName());
			List<Element> eList = element.elements();
			for (Element e : eList) {
    
    
				System.out.println("user标签下的子节点" + e.getName());
			}
			break;
		}
	}

	/**
	* 获取具体的节点内容 获取张百万的所有信息
	*/
	@Test
	public void test2() throws DocumentException {
    
    
		//1.创建XML文档解析对象
		SAXReader sr = new SAXReader();
		//2.读取XML获取到document对象
		Document document = sr.read("src\\com\\lagou\\xml02\\user.xml");
		//3.获取根节点
		Element rootElement = document.getRootElement();
		//4.得到当前节点的 所有子节点
		List<Element> elements = rootElement.elements();
		//5.获取第一个子节点
		Element user = elements.get(0);
		//6.获取所有信息
		String id = user.attributeValue("id");
		String name = user.elementText("name");
		String age = user.elementText("age");
		//使用getText获取当前元素的文本内容
		String hobby = user.element("hobby").getText();
		//打印
		System.out.println(id+" " + name +" " + age +" " + hobby);
	}
}

xpath方式读取xml

1. xpath介绍

• XPath 是一门在 XML 文档中查找信息的语言。 可以是使用xpath查找xml中的内容。
• XPath 的好处: 由于DOM4J在解析XML时只能一层一层解析，所以当XML文件层数过多时使用会很不方便，结合XPATH就可以直接获取到某个元素

1. 需要再导入 jaxen-1.1-beta-6.jar

2. XPath基本语法介绍

• 使用dom4j支持xpath的操作的几种主要形式

语法	说明
/AAA/DDD/BBB	表示一层一层的，AAA下面 DDD下面的BBB
//BBB	表示和这个名称相同，表示只要名称是BBB，都得到
//*	所有元素
BBB[1] , BBB[last()]	第一种表示第一个BBB元素, 第二种表示最后一个BBB元素
//BBB[@id]	表示只要BBB元素上面有id属性，都得到
//BBB[@id=‘b1’]	表示元素名称是BBB,在BBB上面有id属性，并且id的属性值是b1

3. API介绍

• 常用方法：

1. selectSingleNode(query): 查找和 XPath 查询匹配的一个节点。
   参数是Xpath 查询串。
2. selectNodes(query): 得到的是xml根节点下的所有满足 xpath 的节点；
   参数是Xpath 查询串。
3. Node: 节点对象

4. Xpath读取XML

• 数据准备 book.xml

<?xml version="1.0" encoding="UTF-8" ?>
<bookstore>
	<book id="book1">
		<name>金瓶梅</name>
		<author>金圣叹</author>
		<price>99</price>
	</book>
	<book id="book2">
		<name>红楼梦</name>
		<author>曹雪芹</author>
		<price>69</price>
	</book>
	<book id="book3">
		<name>Java编程思想</name>
		<author>埃克尔</author>
		<price>59</price>
	</book>
</bookstore>

• 代码示例

1. 使用selectSingleNode方法 查询指定节点中的内容

/*
* 1. 使用selectSingleNode方法 查询指定节点中的内容
* */
@Test
public void test1() throws DocumentException {
    
    
	//1.创建解析器对象
	SAXReader sr = new SAXReader();
	//2.获取文档对象
	Document document =
	sr.read("H:\\jdbc_work\\xml_task03\\src\\com\\lagou\\xml03\\book.xml");
	//3.调用 selectSingleNode() 方法,获取name节点对象
	Node node1 = document.selectSingleNode("/bookstore/book/name");
	System.out.println("节点: " + node1.getName());
	System.out.println("书名: " + node1.getText());
	//4.获取第二本书的名称
	Node node2 = document.selectSingleNode("/bookstore/book[2]/name");
	System.out.println("第二本书的书名为: " + node2.getText());
	}

2. 使用selectSingleNode方法 获取属性值,或者属性值对应的节点

/*
* 2.使用selectSingleNode方法 获取属性值,或者属性值对应的节点
* */
@Test
public void test2() throws DocumentException {
    
    
	//1.创建解析器对象
	SAXReader sr = new SAXReader();
	//2.获取文档对象
	Document document = sr.read("H:\\jdbc_work\\xml_task03\\src\\com\\lagou\\xml03\\book.xml");
	//3.获取第一个book节点的 id属性的值
	Node node1 = document.selectSingleNode("/bookstore/book/attribute::id");
	System.out.println("第一个book的id值为: " + node1.getText());
	//4.获取最后一个book节点的 id属性的值
	Node node2 = document.selectSingleNode("/bookstore/book[last()]/attribute::id");
	System.out.println("最后一个book节点的id值为: " + node2.getText());
	//5.获取id属性值为 book2的 书名
	Node node3 = document.selectSingleNode("/bookstore/book[@id='book2']");
	String name = node3.selectSingleNode("name").getText();
	System.out.println("id为book2的书名是: " + name);
}

3. 使用 selectNodes()方法 获取对应名称的所有节点

/*
* 3.使用 selectNodes()方法 获取对应名称的所有节点
*
* */
@Test
public void test3() throws DocumentException {
    
    
	//1.创建解析器对象
	SAXReader sr = new SAXReader();
	//2.获取文档对象
	Document document =
	sr.read("H:\\jdbc_work\\xml_task03\\src\\com\\lagou\\xml03\\book.xml");
	//3.获取所有节点,打印节点名
	List<Node> list = document.selectNodes("//*");
	for (Node node : list) {
    
    
		System.out.println("节点名: " + node.getName());
	}
	//4.获取所有的书名
	List<Node> names = document.selectNodes("//name");
	for (Node name : names) {
    
    
		System.out.println(name.getText());
	}
	//5.获取指定 id值为book1的节点的所有 内容
	List<Node> book1 =
	document.selectNodes("/bookstore/book[@id='book1']//*");
	for (Node node : book1) {
    
    
		System.out.println(node.getName()+" = " + node.getText());
	}
}

5. JDBC自定义XML

定义配置文件

1. 创建自定义xml 文件, 保存 数据库连接信息
   jdbc-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<jdbc>
	<property name="driverClass">com.mysql.jdbc.Driver</property>
	<property name="jdbcUrl">jdbc:mysql://localhost:3306/db5? characterEncoding=UTF-8</property>
	<property name="user">root</property>
	<property name="password">123456</property>
</jdbc>

编写工具类(配置式)
2) 编写工具类 ,使用xpath 读取数据库信息

public class JDBCUtils {
    
    
	//1. 定义字符串变量, 记录获取连接所需要的信息
	public static String DRIVERNAME;
	public static String URL;
	public static String USER;
	public static String PASSWORD;
	//2.静态代码块
	static {
    
    
		try {
    
    
			//使用 xpath读取 xml中的配置信息
			SAXReader sr = new SAXReader();
			Document document = sr.read("H:\\workspace01\\JDBC_day02\\src\\com\\lagou\\xml03\\jdbc-config.xml");
			Node node = document.selectSingleNode("/jdbc/property[@name='driverClass']");
			//System.out.println(node.getText());
			DRIVERNAME = node.getText();
			URL = document.selectSingleNode("/jdbc/property[@name='jdbcUrl']").getText();
			USER = document.selectSingleNode("/jdbc/property[@name='user']").getText();
			PASSWORD = document.selectSingleNode("/jdbc/property[@name='password']").getText();
			//注册驱动
			Class.forName(DRIVERNAME);
		} catch (Exception e) {
    
    
			e.printStackTrace();
		}
	}
	//3.获取连接的静态方法
	public static Connection getConnection(){
    
    
		try {
    
    
			//获取连接对象
			Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
			//返回连接对象
			return connection;
		} catch (SQLException e) {
    
    
			e.printStackTrace();
			return null;
		}
	}
}

测试工具类
3) 测试 : 获取所有员工的姓名

//获取所有员工的姓名
public static void main(String[] args) {
    
    
	try {
    
    
		//1.获取连接
		Connection connection = JDBCUtils.getConnection();
		//2.获取 statement ,执行SQL
		Statement statement = connection.createStatement();
		String sql = "select * from employee";
		//3.处理结果集
		ResultSet resultSet = statement.executeQuery(sql);
		while(resultSet.next()){
    
    
			String ename = resultSet.getString("ename");
			System.out.println(ename);
		}
	} catch (SQLException e) {
    
    
		e.printStackTrace();
	}
}

任务八 综合案例

1. 商城案例表设计

• 通过对商城项目的部分表关系进行分析,完成数据库表的设计

表关系分析

建库,建表

1. 创建名为 store的数据库, 对应商城项目

create database db6 character set utf8;

2. 创建用户表

CREATE TABLE user (
	uid varchar(32) PRIMARY KEY, -- 用户ID
	username varchar(20) , -- 用户名
	password varchar(20) , -- 密码
	telephone varchar(20) , -- 电话
	birthday date , -- 生日
	sex varchar(10) -- 性别
);
INSERT INTO USER VALUES
('001','渣渣辉','123456','13511112222','2015-11-04','男'),
('002','药水哥','123456','13533334444','1990-02-01','男'),
('003','大明白','123456','13544445555','2015-11-03','男'),
('004','长海','123456','13566667777','2000-02-01','男'),
('005','乔杉','123456','13588889999','2000-02-01','男');

3. 创建订单表

CREATE TABLE orders (
	oid varchar(32) PRIMARY KEY, -- 订单id
	ordertime datetime , -- 下单时间
	total double , -- 总金额
	name varchar(20), -- 收货人姓名
	telephone varchar(20) , -- 电话
	address varchar(30) , -- 地址
	state int(11) , -- 订单状态
	uid varchar(32), -- 外键字段 对应用户表id
	CONSTRAINT ofk_0001 FOREIGN KEY (uid) REFERENCES user (uid)
);
-- 插入一条订单数据
INSERT INTO orders
VALUES('order001','2019-10-11',5500,'乔杉','15512342345','皇家洗浴',0,'001');

4. 创建商品分类表

CREATE TABLE category (
	cid varchar(32) PRIMARY KEY,
	cname varchar(20)
);
INSERT INTO `category` VALUES ('1','手机数码'),('2','电脑办公'),('3','运动鞋服'),('4','图书音像');

5. 创建商品表

CREATE TABLE product (
	pid varchar(32) PRIMARY KEY, -- 商品id
	pname varchar(50) , -- 商品名称
	price double, -- 商品价格
	pdesc varchar(255), -- 商品描述
	pflag int(11) , -- 商品状态 1 上架 ,0 下架
	cid varchar(32) , -- 外键对应 分类表id
	KEY sfk_0001 (cid),
	CONSTRAINT sfk_0001 FOREIGN KEY (cid) REFERENCES category (cid)
);
INSERT INTO `product` VALUES
('1','小米6',2200,'小米 移动联通电信4G手机 双卡双待',0,'1'),
('2','华为Mate9',2599,'华为 双卡双待 高清大屏',0,'1'),
('3','OPPO11',3000,'移动联通 双4G手机',0,'1'),
('4','华为荣耀',1499,'3GB内存标准版 黑色 移动4G手机',0,'1'),
('5','华硕台式电脑',5000,'爆款直降，满千减百',0,'2'),
('6','MacBook',6688,'128GB 闪存',0,'2'),
('7','ThinkPad',4199,'轻薄系列1)',0,'2'),
('8','联想小新',4499,'14英寸超薄笔记本电脑',0,'2'),
('9','李宁音速6',500,'实战篮球鞋',0,'3'),
('10','AJ11',3300,'乔丹实战系列',0,'3'),
('11','AJ1',5800,'精神小伙系列',0,'3');

5. 订单项表 (中间表)

-- 订单项表
CREATE TABLE orderitem (
	itemid VARCHAR(32) PRIMARY KEY, -- 订单项ID
	pid VARCHAR(32), -- 外键 对应商品表 id
	oid VARCHAR(32), -- 外键 对应订单表 id
	KEY fk_0001 (pid),
	KEY fk_0002 (oid),
	CONSTRAINT fk_0001 FOREIGN KEY (pid) REFERENCES product (pid),
	CONSTRAINT fk_0002 FOREIGN KEY (oid) REFERENCES orders (oid)
);
-- 向中间表中插入两条数据
INSERT INTO orderitem VALUES('item001','1','order001');
INSERT INTO orderitem VALUES('item002','11','order001');

2. 环境搭建

项目结构

com.lagou.app 		测试包 用于对DAO代码进行测试
com.lagou.dao 		dao包  数据访问层,包含所有对数据库的相关操作的类
com.lagou.entity 	实体包 保存根据数据库表 对应创建的JavaBean类
com.lagou.utils 	工具包

导入所需Jar包

• 我们只需要导入myjar仓库到项目中就可以了
  

导入配置文件及工具类

3. JavaBean类创建

设计用户与订单

1. 一对多关系分析

• 在Java一对多的数据关系中，需要遵循以下设计原则：
  a. Java类的名称 = 实体表的名称
  b. Java类的属性 = 实体表的字段
  c. Java类的一个对象 = 表的一行记录
  d. 外键关系 = 引用配置
• 一个用户拥有多个订单,所以 用户是一的一方, 订单是多的一方
  

2. User类

/**
* 用户表 对应 User类
* `uid` VARCHAR(32) NOT NULL,
* `username` VARCHAR(20) DEFAULT NULL,
* `password` VARCHAR(20) DEFAULT NULL,
* `telephone` VARCHAR(20) DEFAULT NULL,
* `birthday` DATE DEFAULT NULL,
* `sex` VARCHAR(10) DEFAULT NULL,
* */
public class User {
    
    
	private String uid;
	private String username;
	private String password;
	private String telephone;
	private String birthday;
	private String sex;
	//提供 get set toString方法
}

3. Orders类

/**
* 订单表
* `oid` VARCHAR(32) NOT NULL,
* `ordertime` DATETIME DEFAULT NULL,
* `total` DOUBLE DEFAULT NULL,
* `name` VARCHAR(20) DEFAULT NULL,
* `telephone` VARCHAR(20) DEFAULT NULL,
* `address` VARCHAR(30) DEFAULT NULL,
* `state` INT(11) DEFAULT NULL,
* `uid` VARCHAR(32) DEFAULT NULL,
*
* */
public class Orders {
    
    
	private String oid; //订单号
	private String ordertime; //下单时间
	private double total; //订单的总金额
	private String name; //收货人姓名
	private String telephone; //收货人电话
	private String address; //收货人地址
	private int state; //订单状态 1 代表已支付 , 0 代表未支付
	//订单属于哪个用户呢 ?
	//提供 get set toString方法
}

4. Orders类设计分析

• 第一种方式
  - 根据两张表关系的描述 我们可以在 订单类中 添加一个uid成员变量,表示订单属于哪个用户private String uid;
  - 但是这样设计会存在一些问题,比如 我要查询的是订单是属于哪个用户的用户名 ? 但是我们只有一个uid

• 第二种方式
  - Java类表示一对多关系,可以在多的一方添加一个成员变量, 这个成员变量的类型 就是一的一方的类型.
  - 再在订单表中 添加一个 User对象,User对象中 ,保存该订单关联的用户的所有信息
   ‘private String uid;’
   ‘private User user;’

5. 修改Orders类

public class Orders {
    
    
	private String oid; //订单号
	private String ordertime; //下单时间
	private double total; //订单的总金额
	private String name; //收货人姓名
	private String telephone; //收货人电话
	private String address; //收货人地址
	private int state; //订单状态 1 代表已支付 , 0 代表未支付
	//订单属于哪个用户呢 ?
	private String uid; //表示外键
	private User user; //用来保存订单对应的详细的用户信息
	//提供 get set toString方法
}

设计商品与分类

• 分类与商品 同样是一对多关系, 我们可以在多的一方进行操作 添加一个成员变量 类型是一的一方的类型

1. Category类

public class Category {
    
    
	private String cid;
	private String cname;
	//提供 get set toString方法
}

2. Product类

public class Product {
    
    
	private String pid;
	private String pname;
	private double price;
	private String pdesc;
	private int pflag; //是否上架 1 上架 ,0 下架
	private String cid; //外键 对应分类表主键
	private Category category; //用于保存Category的详细数据
	//提供 get set toString方法
}

设计订单项

1. 多对多关系分析

• 商品与订单是多对多关系, 一个订单上可以有多个商品, 一个商品可以出现在多个订单中.
• 多对多建表原则 需要一张中间表,中间表中至少有两个字段,作为中间表的外键分别指向另外两张表的主键

2. 创建OrderItem

/**
* 订单项表(中间表)
* `itemid` VARCHAR(32) NOT NULL,
* `pid` VARCHAR(32) DEFAULT NULL,
* `oid` VARCHAR(32) DEFAULT NULL,
*
* */
public class OrderItem {
    
    
	//订单项 指的是中间表中的一条数据
	private String itemid; //订单项的id
	private String pid; //外键 指向商品表主键
	private String oid; //外键 指向订单表的主键
	private Product product;//订单项内部的商品详细信息
	private Orders orders;//订单项属于哪个订单
}

4. 编写DAO类

UserDao

• 需求一: 编写一个注册用户的方法,接收的参数是一个User对象
• 需求二: 编写一个 用户登录的方法,接收的参数是 用户名 和密码, 返回值是User对象

1. 编写UserDao

public class UserDao {
    
    

	/**
	* 注册用户
	* */
	public int register(User user) throws SQLException {
    
    
	
	//1.获取QueryRunner
	QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
	
	//2.编写SQL
	String sql = "insert into user values(?,?,?,?,?,?)";
	
	Object[] param = {
    
    user.getUid(), user.getUsername(), user.getPassword(), user.getTelephone(), user.getBirthday(), user.getSex()};
	
	//3.执行插入操作
	int update = qr.update(sql,param);
	
	//4.返回受影响的行数
	return update;
	
	/**
	* 用户登录
	* */
	public User login(String username , String password) throws SQLException {
    
    
	
		QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
		
		String sql = "select * from user where username = ? and password = ?";
		
		//返回的是一个User对象 使用BeanHandler将结果集的第一条和数据封装到一个Javabean中
		User user = qr.query(sql, new BeanHandler<User> (User.class), username, password);
		
		return user;
	}
}

2. 测试注册与登录功能

public class TestUserDao {
    
    
	//创建UserDao
	UserDao userDao = new UserDao();
	//测试注册功能
	@Test
	public void testRegister() throws SQLException {
    
    
		//1. 创建User对象
		User user = new User();
		//2. 对User对象进行赋值
		user.setUid(UUIDUtils.getUUID());
		user.setUsername("大郎");
		user.setPassword("654321");
		user.setTelephone("15052005200");
		user.setSex("男");
		user.setBirthday(DateUtils.getDateFormart());
		//3.执行注册
		int register = userDao.register(user);
		//4.判断注册是否成功
		if(register > 0){
    
    
			System.out.println("注册成功,欢迎您: " +
			user.getUsername());
		}else{
    
    
			System.out.println("注册失败! !");
		}
	}
	//测试登录功能
	@Test
	public void testLogin() throws SQLException {
    
    
		//调用UserDao的 login方法,传入用户名密码
		User user = userDao.login("大郎", "654321");
		//判断user不为空 登录成功
		if(user != null){
    
    
			System.out.println(user.getUsername() +" 欢迎您!");
		}else{
    
    
			System.out.println("用户名或者密码错误! !");
		}
	}
}

ProductDao

• 需求1: 根据商品ID 获取商品名称 ,商品价格 以及商品所属分类的名称
  参数 pid, 返回值 product对象
• 需求2: 根据分类ID 获取商品分类信息
  参数 cid , 返回值 category对象
• 需求3: 查询指定分类ID 下的商品个数
  参数 cid , 返回值 int类型 商品个数
• 需求4: 查询指定分类ID 下的所有商品信息
  参数分类ID ,返回值 List集合 集合中保存商品对象

1. 编写 ProductDao

public class ProductDao {
    
    
	//1.根据商品ID 获取商品名称 ,商品价格 以及商品所属分类的名称
	public Product findProductById(String pid) throws SQLException {
    
    
		QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
		String sql = "select * from product where pid = ?";
		Product product = qr.query(sql, new BeanHandler<Product>(Product.class), pid);
		//调用 findCategoryById()方法, 传递外键cid 获取商品对应 的分类信息
		Category category = findCategoryById(product.getCid());
		//将category保存到商品对象中
		product.setCategory(category);
		return product;
	}
	//2.根据分类ID 获取商品分类信息
	public Category findCategoryById(String cid) throws SQLException {
    
    
		QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
		String sql = "select * from category where cid = ?";
		Category category = qr.query(sql, new BeanHandler<Category>(Category.class),cid);
		return category;
	}
	//3.查询指定分类ID 下的商品个数
	public int getCount(String cid) throws SQLException {
    
    
		QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
		String sql = "select count(*) from product where cid = ?";
		//获取的单列数据 ,使用ScalarHandler 封装
		Long count = (Long)qr.query(sql,new ScalarHandler<>(),cid);
		//将Lang类型转换为 int 类型,并返回
		return count.intValue();
	}
	//4.查询指定分类下的所有商品信息
	public List<Product> findProductByCid(String cid) throws SQLException {
    
    
		QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
		String sql = "select * from product where cid = ?";
		//查询结果是一个List集合, 使用BeanListHandler 封装结果集
		List<Product> list = qr.query(sql, new BeanListHandler<Product>(Product.class), cid);
		return list;
	}
}

2. 测试 ProductDao

public class TestProductDao {
    
    
	ProductDao productDao = new ProductDao();
	//1.测试 根据商品ID 获取商品名称 ,商品价格 以及商品所属分类的名称
	@Test
	public void testFindProductById() throws SQLException {
    
    
		Product product = productDao.findProductById("1");
		System.out.println("商品名称: "+product.getPname()+", 商品价格: " + product.getPrice() +", 商品所属分类: "+
		product.getCategory().getCname());
	}
	//2.测试 查询指定分类ID下的商品数
	@Test
	public void testGetCount() throws SQLException {
    
    
		//查询 cid为3的分类下有多少个商品
		int count = productDao.getCount("3");
		System.out.println("分类ID为3的分类下商品个数: " + count);
	}
	//3.测试 查询指定分类下的所有商品信息
	@Test
	public void testFindProductByCid() throws SQLException {
    
    
		//查询cid为 2的分类下 所有的商品信息
		List<Product> list = productDao.findProductByCid("2");
		for (Product product : list) {
    
    
			System.out.println(product);
		}
	}
}

OrdersDao

1. 多对一分析

• OrderItem表与Orders表的关系是 多对一
  
• 之前我们一直是在描述一对多,那么我们再反向描述一下 多对一, 方式是在Orders中应该有一个 集合用来保存订单中的订单项信息
  
• 在Orders类中添加 订单项的集合

//该订单中有多少订单项
List<OrderItem> orderItems = new ArrayList<OrderItem>();
public List<OrderItem> getOrderItems() {
    
    
	return orderItems;
}
public void setOrderItems(List<OrderItem> orderItems) {
    
    
	this.orderItems = orderItems;
}

2. 创建OrdersDao

• 需求1: 获取 uid为 001 的用户的所有订单信息
  参数 uid, 返回值 LIst 订单集合
• 需求2: 获取订单编号为 order001的订单中的所有商品信息
  参数 oid, 返回值List 商品集合

-- 获取订单编号为: order001的订单中的所有商品信息
-- 1.查询订单项表中 oid是order001的 所有商品信息
SELECT oi.pid
FROM orderitem oi WHERE oid = 'order001';
-- 2.将上面的查询语句作为in函数的条件, 查询product表
SELECT * FROM product WHERE pid IN
(SELECT oi.pid
FROM orderitem oi WHERE oid = 'order001');

public class OrdersDao {
    
    
	//需求1: 获取 uid为 001 的用户的所有订单信息
	public List<Orders> findAllOrders(String uid) throws SQLException {
    
    
		QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
		String sql = "select * from orders where uid = ?";
		//一个用户所有的订单信息
		List<Orders> ordersList = qr.query(sql, new BeanListHandler<Orders>(Orders.class), uid);
		return ordersList;
	}
	//需求2: 获取订单编号为 order001的订单中的所有商品信息
	public List<Product> findOrderById(String oid) throws SQLException {
    
    
		QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
		//1.查询订单项表 获取订单项表中 订单ID为order001的数据
		String sql = "SELECT pid FROM orderitem WHERE oid = ? ";
		//2.查询的结果是 多条订单项数据
		List<OrderItem> list = qr.query(sql, new BeanListHandler<OrderItem>(OrderItem.class), oid);
		//3.创建集合保存商品信息
		List<Product> productList = new ArrayList<>();
		ProductDao productDao = new ProductDao();
		//4.遍历订单项集合 获取Pid
		for (OrderItem orderItem : list) {
    
    
			//4.1从orderitem中获取 pid
			String pid = orderItem.getPid();
			//4.2 调用productDao
			Product product = productDao.findProductById(pid);
			//4.3 保存到集合
			productList.add(product);
		}
		//返回 订单中对应的商品信息
		return productList;
	}
}

3. 测试OrdersDao

public class TestOrderDao {
    
     OrdersDao ordersDao = new OrdersDao();
	//1.获取 uid为 001 的用户的所有订单信息
	@Test
	public void testFindAllOrders() throws SQLException {
    
    
		List<Orders> allOrders =
		ordersDao.findAllOrders("001");
		//遍历打印订单信息
		for (Orders order : allOrders) {
    
    
			System.out.println(order);
		}
	}
	//测试 获取订单编号为: order001的订单中的所有商品信息
	@Test
	public void testFindOrderById() throws SQLException {
    
    
		List<Product> list = ordersDao.findOrderById("order001");
		System.out.println("订单编号为order001中的商品有: ");
		for (Product product : list) {
    
    
			System.out.println(product);
		}
	}
}

第二阶段模块二 作业

编程题1

### 数据准备
1) 创建数据库
create database test01 character set utf8;

2) 创建表：account(账户表)，有如下结构及数据：（复制以下SQL语句执行）
CREATE TABLE account (
  id int(11)  PRIMARY KEY AUTO_INCREMENT,	
  username varchar(100) ,	-- 用户姓名
  card varchar(100) ,		-- 卡号
  balance double	-- 当前余额
) ;
insert  into account(id,username,card,balance)  values (1,'tom','1122334455',20000.00),(2,'lucy','55443332211',10000.00);

2) 创建表：Transaction(交易记录表) （复制以下SQL语句执行） 
CREATE TABLE TRANSACTION (
  id INT PRIMARY KEY AUTO_INCREMENT,
  cardid VARCHAR(100) ,	-- 交易卡号
  tratype VARCHAR(100) ,    -- 交易类型： 转入 或者 转出
  tramoney DOUBLE	 ,	-- 交易金额
  tradate DATETIME 	-- 交易日期
) ;

### 代码编写

1) 创建项目 Test_01
2) 导入jar包
3) 创建包 包结构为 
www.lagou.utils  存放工具类
www.lagou.entity 存放JavaBean类
www.lagou.app    创建测试类 

4)  按照步骤 实现卡号：1122334455向55443332211转账5000元的操作；

步骤
a) 使用连接池创建QueryRunner对象；
b) 判断转出方是否有足够余额，如果不足，提示信息：”余额不足！”，并结束程序；
c) 通过卡号 进行转账的操作；
d) 转账结束后, 将转入、转出记录分别写入到Transaction表中。

编程题2

### 数据准备
CREATE TABLE phone (
  id INT PRIMARY KEY  AUTO_INCREMENT,
  pname VARCHAR(20),-- 手机名称
  price DOUBLE , -- 手机单价
  prodate DATE , -- 生产日期
  color VARCHAR(20) -- 颜色
) ;

INSERT  INTO phone(id,pname,price,prodate,color) VALUES 
(1,'IPhone11',7800.00,'2019-07-20','土豪金'),
(2,'荣耀6X',5689.00,'2018-02-12','白色'),
(3,'诺基亚3',5699.00,'2011-12-05','银白色'),
(4,'红米6',599.00,'2017-01-18','香槟金'),
(5,'IPhoneX',5800.00,'2018-01-18','日落黑');


### 代码编写
1) 继续在项目 Test_01中编写代码即可
2) 需求1:  查询价格高于2000元，生产日期是2019年之前的所有手机
3) 需求2:  查询所有颜色是白色的手机信息

## 编程题3
### 数据准备
1) 创建表：dept(部门表)，有如下结构及数据：（复制以下SQL语句执行）
CREATE TABLE dept (
  	id INT PRIMARY KEY AUTO_INCREMENT,	-- 部门ID
  	deptname VARCHAR(20) DEFAULT NULL	-- 部门名称
);
INSERT  INTO dept(id,deptname) VALUES (1,'销售部'),(2,'财务部'),(3,'人事部');


2) 创建表：employee(员工表) （复制以下SQL语句执行）
CREATE TABLE employee (
	id INT PRIMARY KEY AUTO_INCREMENT ,
	NAME VARCHAR (30),		-- 员工姓名
	age DOUBLE ,				-- 员工年龄
	sex VARCHAR (6),			-- 员工性别
	salary DOUBLE ,			-- 薪水
	empdate DATE ,			-- 入职日期
	did INT, 			-- 所属部门ID
	FOREIGN KEY (did) REFERENCES dept (id)
); 

INSERT INTO employee VALUES(1,'奥利给',35,'男',35000,'2000-10-07',1);
INSERT INTO employee VALUES(2,'小汉堡',32,'女',38000,'2005-11-12',2);
INSERT INTO employee VALUES(3,'哈拉少',30,'男',32000,'2008-03-14',2);
INSERT INTO employee VALUES(4,'广坤',40,'男',36000,'2007-09-18',NULL);


### 代码编写
1) 继续在项目 Test_01中编写代码即可
需求1: 查询所有的员工信息 (不包含没有部门的员工)。
需求2: 查询每个员工的 姓名, 薪资 和 所属部门名称