###1.1命令行连接
mysql -uroot -p123456 --连接数据库
update mysql.user set authentication_string=password('123456') where user='root' and host='localhost';
-- 修改用户密码
flush privileges;--刷新权限
-- ————————————————————————————————————————
-- 所有的语句都使用分号“;”结尾
show databases;-- 查看所有数据库
mysql> use tasksystem; -- 切换为tasksystem数据库，命令格式为 use 数据库名称
Database changed
mysql> show tables; -- 查看数据库中所有的表
+----------------------+
| Tables_in_tasksystem |
+----------------------+
| task |
| task_item |
+----------------------+
mysql> describe task;-- 显示表task中的所有信息
+-------------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------------+--------------+------+-----+---------+----------------+
| task_id | bigint(20) | NO | PRI | NULL | auto_increment |
| create_by | varchar(64) | YES | | | |
| create_time | datetime | YES | | NULL | |
| update_by | varchar(64) | YES | | | |
| update_time | datetime | YES | | NULL | |
| NAME | varchar(30) | YES | | | |
| pic | varchar(100) | YES | | | |
| sort | int(11) | YES | | NULL | |
| type | tinyint(4) | YES | | 1 | |
| t_id | bigint(20) | YES | | NULL | |
| deadline | datetime | YES | | NULL | |
| remarks | varchar(100) | YES | | NULL | |
+-------------+--------------+------+-----+---------+----------------+
create database newDb; -- 创建一个数据库
exit; -- 退出连接
数据库XXX语言 CRUD 增删改查
DDL 数据库定义语言
DML 操作
DQL 查询
DCL 控制
##2、操作数据库
操作数据库>操作数据库中的表>操作数据库中表的数据
2.1操作数据库(了解)1、创建数据库
CREATE database if not EXISTS db_learn; -- 加入“if not EXISTS”有重复数据库不会报错，只有警告
2、删除数据库
DROP DATAbase IF EXISTS aaa;--删除数据库aaa
3、使用数据库
Use `db_learn`; -- 使用db_learn数据库，`是tab键上面的那个键，如果表名或者字段名是一个特殊字符，需要带这个字符
4、查看数据库
SHOW databases ;-- 查看所有数据库2.2数据库的列类型
数值
- tinyint 十分小的数据 1个字节
- smallint 较小的数据 2个字节
- mediumint 中等大小的数据 3个字节
- int 标准的整数 4个字节
- bigint 较大的数据 8个字节
- float 浮点数 4个字节
- double 浮点数 8个字节（精度问题）
- decimal 字符串形式的浮点数 金融计算的时候一般使用
字符串
- char 字符串固定大小的 0~255
- varchar 可变字符串 0~65535 常用的String
- tinytext 微型文本 2^8-1
- text 文本串 2^16-1 保存大文本
时间日期
java.util.Date
- date YYYY-MM-DD,日期格式
- time HH:mm:ss，时间格式
- datetime YYYY-MM-DD HH:mm:ss 最常用的时间格式
- timestamp 时间戳，1970。1.1到现在的毫秒数！较为常用
- year 年份表示
null
- 没有值，未知
- ==不要使用NULL进行运算，没有意义
###2.3、数据库的字段属性（重点）
Unsigned:
- 无符号的整数
- 不能声明为负数
zerofill:
- 0填充的
- 不足的位数用0来填充
自增：
- 自动在上一条记录的基础上+1
- 通常用来设计唯一的主键 index，必须是整数类型
- 可以自定义设计主键自增的起始值和步长
空/非空 null/not null
- 假设设置为 not null，不给它赋值就会报错
- NULL，如果不填写值，默认就是null
默认：
- 设置默认的值
- sex，默认值为男，如果不指定该列的值，则会有默认的值
做项目每一个表都必须存在以下5个字段
id 主键 `version` 乐观锁 is_delete 伪删除 gmt_create 创建时间 gmt_update 修改时间2.4创建数据库表
CREATE TABLE IF NOT EXISTS `student`( `id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号', `name` VARCHAr(30) NOT NULL DEFAULT '匿名' COMMENT '姓名', `pwd` VARCHAr(20) NOT NULL DEFAULT '123456' COMMENT '密码', `sex` VARCHAr(2) NOT NULL DEFAULT '女' COMMENT '性别', `birthday` DATETIME DEFAULT NULL COMMENT '出生日期', `address` VARCHAr(100) DEFAULT NULL COMMENT '家庭住址', `email` VARCHAr(50) DEFAULT NULL COMMENT '邮箱', PRIMARY KEY (`ID`) )ENGINE=INNODB DEFAULT CHARSET=utf8
格式
create table [if not exists] `表名`(
`字段名` 列类型 [属性] [索引] [注释],
`字段名` 列类型 [属性] [索引] [注释],
`字段名` 列类型 [属性] [索引] [注释],
`字段名` 列类型 [属性] [索引] [注释],
)[表类型][字符集类型][表的注释]
常用命令
SHOW CREATE DATAbase books_db;-- 查看创建数据库的语句 SHOW CREATE TABLE student;-- 查看student数据表的定义 DESC student;-- 显示表的结构2.5、数据表的类型
INNODB 默认使用 MYISAM 早些年使用
| MYISAM | INNODB | |
|---|---|---|
| 事务支持 | 不支持 | 支持 |
| 数据行锁定 | 不支持 | 支持 |
| 外键约束 | 不支持 | 支持 |
| 全局索引 | 支持 | 不支持 |
| 表空间的大小 | 较小 | 较大，约为MYISAM的2倍 |
常规使用
- MYISAM 节约空间，速度较快
- INNODB 安全性高，事务的处理，多表用户操作
在物理空间存在的位置
所有的数据库文件都存在data目录下
本质还是文件的存储
MySQL引擎在物理文件上的区别
- InnoDB在数据库表中只有一个*.frm文件，以及上级目录下的ibdata1文件
- MYISAM对应文件
- *.fim —表结构的定义文件
- *.MYD 数据文件(data)
- *.MYI 索引文件(index)
设置数据库的字符接编码
CHARSET=UTF8
不设置的话,会是默认字符集编码（不支持中文！）
MySQL的默认编码是Latin1，不支持中文
-- 修改表名：ALTER TABLE 旧表名 RENAME AS 新表名; ALTER TABLE student RENAME AS student1;--把student表改名为student1 -- 添加字段：ALTER TABLE 表名 ADD 字段名 列属性 ALTER TABLE student1 ADD age -- 修改字段属性：ALTER TABLE 表名 MODIFy 需要修改的字段名 约束条件; ALTER TABLE student1 MODIFy age varchar(11); -- 字段重命名：ALTER TABLE 表名 CHANGE 新名字 旧名字 约束条件; ALTER TABLE student1 CHANGE age age1 INT(1); -- 字段删除：ALTER TABLE 表名 DROP 字段名; ALTER TABLE student1 DROP age1;
删除表
-- 删除表（如果表存在再删除） DROP TABLE IF EXISTS student1;
所有的创建和删除操作尽量加上判断，以免报错
注意点：
- ``字段名尽量加上这两个字符包裹
- sql关键词大小不敏感，尽量小写
- 所有符号全用英文，中文符号会报错
方式一：创建表的时候增加约束（比较麻烦）
-- 学生表的gradeid字段要去引用年级表字段的gradeid -- 定义外键key -- 给这个外键添加约束（执行引用） references 引用 CREATE TABLE IF NOT EXISTS `student`( `id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号', `name` VARCHAr(30) NOT NULL DEFAULT '匿名' COMMENT '姓名', `pwd` VARCHAr(20) NOT NULL DEFAULT '123456' COMMENT '密码', `sex` VARCHAr(2) NOT NULL DEFAULT '女' COMMENT '性别', `birthday` DATETIME DEFAULT NULL COMMENT '出生日期', `gradeid` INT(10) NOT NULL COMMENT '学生年级', `address` VARCHAr(100) DEFAULT NULL COMMENT '家庭住址', `email` VARCHAr(50) DEFAULT NULL COMMENT '邮箱', PRIMARY KEY (`ID`), KEY `FK_gradeid` (`gradeid`), ConSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade`(`gradeid`) )ENGINE=INNODB DEFAULT CHARSET=utf8
删除有外键关系的表的时候，必须要先删除引用别人的表（从表），再删除被引用的表（主表）
方式二：创建表成功后，添加外键约束
-- 创建表时没有外键关系 CREATE TABLE IF NOT EXISTS `student`( `id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号', `name` VARCHAr(30) NOT NULL DEFAULT '匿名' COMMENT '姓名', `pwd` VARCHAr(20) NOT NULL DEFAULT '123456' COMMENT '密码', `sex` VARCHAr(2) NOT NULL DEFAULT '女' COMMENT '性别', `birthday` DATETIME DEFAULT NULL COMMENT '出生日期', `gradeid` INT(10) NOT NULL COMMENT '学生年级', `address` VARCHAr(100) DEFAULT NULL COMMENT '家庭住址', `email` VARCHAr(50) DEFAULT NULL COMMENT '邮箱', PRIMARY KEY (`ID`), KEY `FK_gradeid` (`gradeid`), ConSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade`(`gradeid`) )ENGINE=INNODB DEFAULT CHARSET=utf8 ALTER TABLE `student` ADD ConSTRAINT `FK_gradeid` FOREIGN KEY(`gradeid`) REFERENCES `grade`(`gradeid`);
以上的操作都是物理外键，数据库级别的外键，都不建议使用（避免数据库过多造成困扰，了解）
最佳实践
- 数据库就是单纯的表，只用来存数据，只有行（数据）和列（字段）
- 我们想使用多张表的数据，想使用外键（用程序去实现）
**数据库的意义：**数据存储，数据管理
DML语言：数据操作语言
- Insert
- update
- delete
###3.3、添加
-- 插入语句
-- INSERT INTO 表名([字段1,字段2,字段3]) VALUES('值1'),('值2'),……
INSERT INTO `grade`(`gradename`) VALUES('大四');
INSERT into `grade`(`gradename`) VALUES('大三'),('大二'),('大一');
INSERT INTO `student`(`name`,`pwd`,`sex`,`gradeid`) VALUES ('张三','aaaa','男',1);--插入一条数据
INSERT INTO `student`(`name`,`pwd`,`sex`,`gradeid`) VALUES ('李四','bbb','男',1),('王五','ccc','女',1);--插入多条数据
INSERT INTO `student` VALUES (4,'李四','aaaa','男','2000-01-01',2,'浙江','email');--直接插入一条完整的数据
语法：INSERT INTO 表名([字段1,字段2,字段3]) VALUES('值1'),('值2'),……
注意事项：
- 字段和字段之间使用英文逗号，隔开
- 字段是可以省略的，但是后面的值必须要一一对应，不能少
- 可以同时插入多条数据，VALUES后面的值需要使用,隔开即可VALUES(),(),(),()
update：修改谁（条件） set原来的值=新值
-- 修改学员名字，带了简介 UPDATE `student` SET `name`='白水泡糖' WHERe id=1; -- 不指定条件的情况下，会改动所有表！ UPDATE `student` SET `name`='白水泡糖'; -- 语法： -- UPDATE 表名 set colnum_name=value,[colnum_name=value,......] where [条件]
条件：where子句运算符id等于某个值，大于某个值，在某个区间内修改……
操作符会返回 布尔值
| 操作符 | 含义 | 范围 | 结果 |
|---|---|---|---|
| = | 等于 | 5=6 | false |
| != 或 <> | 不等于 | 5<>6 | true |
| > | 大于 | ||
| < | 小于 | ||
| <= | 小于等于 | ||
| >= | 大于等于 | ||
| BETWEEN… AND … | 在某个范围内 | [2,5] | |
| AND | 我和你 && | 5>1 and 1>2 | false |
| OR | 我或你 || | 5>1 or 1>2 | true |
-- 通过多个条件定位数据 UPDATE `student` SET `name`='白水泡糖123' WHERe `name`='白水泡糖' AND sex='女';
语法：UPDATE 表名 set colnum_name=value,[colnum_name=value,......] where [条件]
注意事项：
- colnum_name 是数据库的列，尽量带上``
- 条件，筛选的条件，如果没有指定，则会修改所有的列
- value，是一个具体的值，也可以是一个变量
UPDATE `student` SET `birthday`=CURRENT_TIME WHERe `name`='白水泡糖' AND sex='男';
- 多个设置的属性之间，使用英文逗号,隔开
###3.5、删除
delete命令
语法：delete from 表名 [where 条件]
-- 删除指定数据 DELETe FROM `student` WHERe id=1;
TRUNCATE命令
作用：完全清空一个数据表，表的结构和索引约束不会变！
-- 清空student表 TRUNCATE `student`
delete和TRUNCATE的区别
- 相同点：都能删除数据，都不会删除表结构
- 不同：
- TRUNCATE 重新设置 自增列 计数器会归零
- TRUNCATE 不会影响事务
-- 测试delete和TRUNCATE区别
CREATE TABLE `test` (
`id` INT(4) NOT NULL AUTO_INCREMENT,
`co11` VARCHAr(20) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO `test` (`co11`) VALUES('1'),('2'),('3');
DELETE FROM `test`; -- 不会影响自增
TRUNCATE TABLE `test`; -- 自增会归零
了解即可：delete删除的问题，重启数据库，现象
- InnoDB 自增列会从1开始（存在内存中，断电即失）
- MyISAM 继续从上一个自增量开始（存在文件中，不糊丢失）
##4、DQL查询数据
###4.1
- 所有的查询操作都用select
- 简单的查询，复杂的查询都能做
- 数据库中最核心的语言，最重要的语句
- 使用频率最高的语句
-- 查询全部的学生 SELECT 字段 FROM 表
SELECt * FROM student;
-- 查询指定字段
SELECt `StudentNo`,`StudentName` FROM student;
-- 别名，给结果起一个名字 AS
SELECt `StudentNo` AS 学号 , `StudentName` AS 学生姓名 FROM student;
-- 函数 Concat(a,b)
SELECt CONCAt('姓名：',StudentName) AS 新名字 FROM student;
语法：SELECt 字段... FROM 表
有的时候，列名字不是那么见名知意的，就可以用AS来起别名
去重 distinct
作用：去除SELECt查询出来的结果中重复的数据，只显示一条
-- 查询一下有那些同学参加了考试，成绩 SELECT * FROM result;-- 查询全部的考试成绩 -- 查询有哪些同学参加了考试 SELECt `StudentNo` FROM result; -- 发现重复数据，去重 SELECt DISTINCT `StudentNo` from result;
数据的列（表达式）
SELECt VERSION() -- 查询系统版本（函数） SELECT 100*3-1 AS 计算结果 -- 用来计算（表达式） SELECT @@auto_increment_increment -- 查询自增的步长（变量） -- 学院考试成绩+1分查看 SELECT `StudentNo`,`StudentResult`+1 AS '提分后' FROM result;
数据库中的表达式：文本值，列，Null,函数，笔算表达式，系统变量
select 表达式 from表
4.3、where条件子句逻辑运算符
作用：检索数据中符合条件的值
搜索的条件由一个或者多个表达式组成，结果 布尔值
| 运算符 | 语法 | 描述 |
|---|---|---|
| and && | a and b a&&b | 逻辑与，两个都为真，结果为真 |
| or || | a or b a||b | 逻辑或，其中一个为真，结果为真 |
| Not ! | not a !a | 逻辑非，真为假，假为真 |
-- SELECt studentNo,`StudentResult` FROM result; SELECt studentNo,`StudentResult` FROM result WHERe studentresult>=95 AND studentresult<=100; -- 模糊查询（区间查询） SELECt studentNo,`StudentResult` FROM result WHERe studentresult BETWEEN 95 AND 100;
模糊查询：比较运算符
| 运算符 | 语法 | 描述 |
|---|---|---|
| IS NULL | a IS NULL | 如果操作符为NULL，结果为真 |
| IS NOT NULL | a IS NOT NULL | 如果操作符不为NULL，结果为真 |
| BETWWEEN | a between b and c | 若a在b和c之间，则结果为真 |
| LIKE | a LIKE b | SQL匹配，如果a匹配到b，则结果为真 |
| IN | a in (a1,a2,a3,a4,…) | 假设a为a1,a2,a3,…中的某一个值，则结果为真 |
-- 查询姓刘的同学
-- like结合 % (代表0到任意个字符)
SELECt `StudentNo`,`StudentName` FROM `student`
WHERe StudentName LIKE '刘%';
-- 查询姓刘的同学，名字后面只有1个字的
SELECt `StudentNo`,`StudentName` FROM `student`
WHERe StudentName LIKE '刘_';
-- 查询姓刘的同学，名字后面只有2个字的
SELECt `StudentNo`,`StudentName` FROM `student`
WHERe StudentName LIKE '刘__';
-- 查询名字中间有加字
SELECt `StudentNo`,`StudentName` FROM `student`
WHERe StudentName LIKE '%嘉%';
-- 查询学号
SELECt `StudentNo`,`StudentName` FROM `student`
WHERe StudentNo IN (1000,1001,1002);
-- 按照地名查询
SELECt `StudentNo`,`StudentName` FROM `student`
WHERe `Address` IN ('北京朝阳');
-- WHERe `Address` IN ('北京%'); 错误，in不能用%，%是在like里用的
-- 查询地址为空的同学
SELECt `StudentNo`,`StudentName` FROM `student`
WHERe address='' or address IS NULL; -- 两种判断为空的方法
4.4、联表查询
JOIN
-- 联表查询join -- 查询参加了考试的同学（学号，姓名，科目编号，分数） -- 查询并集 -- join on 连接查询，on后代表条件判断 -- where 等值查询 SELECt s.StudentNo,studentname,subjectno,studentresult FROM student AS s INNER JOIN result AS r WHERe s.StudentNo = r.StudentNo; -- SELECt StudentNo,studentname,subjectno,studentresult -- FROM student AS s -- INNER JOIN result AS r -- WHERe s.StudentNo = r.StudentNo; -- [Err] 1052 - Column 'StudentNo' in field list is ambiguous。列不明确，所以要在SELECt的时候加上s.StudentNo -- 用右连接 SELECT s.StudentNo,studentname,subjectno,studentresult FROM student s RIGHT JOIN result r ON s.studentno = r.studentno; -- 左查询 SELECt s.StudentNo,studentname,subjectno,studentresult FROM student s LEFT JOIN result r ON s.studentno = r.studentno;
| 操作 | 描述 |
|---|---|
| inner join | 如果表中至少有一个匹配的值，就返回行 |
| left join | 即使右表中没有匹配，也会从左表中返回所有的值 |
| right join | 即使左表中没有匹配，也会从右表中返回所有的值 |
自连接
自己的表和自己的表连接，核心：一张表拆为两张一样的表即可
父类
| categoryid | categoryName |
|---|---|
| 2 | 新技术 |
| 3 | 软件开发 |
| 5 | 美术设计 |
子类
| pid | categoryid | categoryName |
|---|---|---|
| 3 | 4 | 数据库 |
| 2 | 8 | 办公信息 |
| 3 | 6 | web开发 |
| 5 | 7 | ps技术 |
操作：查询父类对应的子类的关系
| 父类 | 子类 |
|---|---|
| 信息开发 | 办公信息 |
| 软件开发 | 数据库 |
| 软件开发 | web开发 |
| 美术设计 | ps技术 |
-- 查询父子信息：把一张表看为2个一模一样的表 SELECt a.`categoryName` AS '父栏目',b.`categoryName` AS '子栏目' FROM `category` AS a,`category` AS b WHERe a.`categoryid`=b.`pid` -- 查询学员所属的年级（学号，学生的姓名，年级名称） SELECt studentNo,studentName,`GradeName` FROM student s INNER JOIN `grade` g ON s.`gradeid`=G.`gradeid` -- 查询科目所属的年级（科目名称，年级名称） SELECt `subjectname`,`GradeName` FROM `subject` sub INNER JOIN `grade` g ON sub.`gradeid`=g.`gradeid` -- 查询参加数据库结构-1 考试的同学信息：学号，学生姓名，科目名，分数 SELECt s.`studentNo`,`studentName`,`subjectname`,`studentresult` from student s INNER JOIN `result` r ON s.studentno = r.studentno INNER JOIN `subject` sub ON r.subjectno=sub.subjectno WHERe subjectname='数据库结构-1' ;4.5、分页和排序
-- ============分页limit 和排序 order by================== -- 排序：升序 ASC . 降序 DESC -- ORDER BY 通过那个字段排序，怎么排 -- 查询结果根据成绩降序排序 -- 分页，每页只显示5条数据 -- 语法：limit 当前页，页面的大小 SELECt s.`studentNo`,`studentName`,`subjectname`,`studentresult` from student s INNER JOIN `result` r ON s.studentno = r.studentno INNER JOIN `subject` sub ON r.subjectno=sub.subjectno WHERe subjectname='数据库结构-1' ORDER BY studentresult ASC LIMIT 0,5; -- 第一页 LIMIT 0,pageSize -- 第二页 LIMIT pageSize,pageSize -- 第三页 LIMIT 2*pageSize,pageSize -- 第N页 LIMIT (N-1)*pageSize,pageSize -- 【pageSize：页面大小】 -- 【(n-1)*pageSize:起始值】 -- 【n:当前页】 -- 【数据总数/页面大小=总页数】
语法：limit(查询起始下标：pageSize)
-- 使用子查询 -- 查询所有数据库结构-1的学生学号 SELECt `studentno`,`subjectno`,`studentresult` FROM `result` WHERe subjectno=( SELECt subjectno FROM `subject` WHERe subjectname='数据库结构-1' ) ORDER BY studentresult DESC -- 分数大于90的人 SELECt DISTINCT s.studentno,studentname FROM student s INNER JOIN result r ON r.studentno=s.studentno WHERe `studentresult` >= 90;5.3、MD5信息加密
MD5不可逆，具体的md5是一样的
MD5破解网站的原理：有一个字典，MD5加密后的值 加密前的值
-- 新建一个md5表
CREATE TABLE `testmd5`(
`id` INT(4) NOT NULL,
`name` VARCHAR(20) NOT NULL,
`pwd` VARCHAR(50) NOT NULL,
PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT INTO testmd5 VALUES(1,'张三','123456'),
(2,'李四','123456'),
(3,'王五','123456');
-- 加密id=1的密码
UPDATe testmd5 SET pwd=MD5(pwd) WHERe id=1;
-- 插入时加密
INSERT INTO testmd5 VALUES(4,'小明',MD5('123456'));
-- 如何校验：将用户传递进来的密码进行md5加密，然后对比加密后的值
SELECT * FROM testmd5 WHERe `name`='小明' and pwd=MD5('123456');
##6、事务
6.1、什么是事务要么都成功，要么都失败
将一组SQL放在一个批次中进行
事务原则：ACID原则 原子性，一致性，隔离性，持久性
原子性（Atomicity）
要么都成功要么都失败
一致性（Consistency）
事务前后数据完整性要保证一致
持久性（Durability）–事务提交
事务一旦提交则不可逆，被持久化到数据库中
隔离性（Isolation）
事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，事务之间要相互隔离
隔离所导致的问题
脏读：指一个事物读取了另外一个事务未提交的数据
不可重复读：在一个事务内读取表中的某一行数据，多次读取结果不同（不一定是错误，只是某些场合不对）
幻读（虚读）：指在一个事务内读取到了别的事务插入的数据，导致前后读取结果不一致
执行事务
-- mysql默认开启事务自动提交 SET autocommit=0 SET autocommit=0 -- 手动处理事务 -- 事务开启 START TRANSACTION -- 标记一个事务的开始，从这个之后的sql都在同一个事务内 INSERT XX INSERT XX -- 提交：持久化（成功！） COMMIT -- 回滚：回到原来的样子（失败！） ROLLBACK -- 事务结束 SET autocommit=1 -- 开启自动提交 SAVEPOINT 保存点名 -- 设置一个事务的保存点 ROLLBACK to SAVEPOINT 保存点名 -- 回滚到保存点 RELEASE SAVEPOINT 保存点名 -- 删除保存点
模拟场景
-- 创建shop数据库
CREATE DATAbase shop CHARACTER SET utf8 COLLATE utf8_general_ci;
-- 创建account表
CREATE TABLE `account`(
`id` INT(3) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(30) NOT NULL,
`money` DECIMAL(9,2) NOT NULL,
PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8
-- 插入数据
INSERT INTO account(`name`,`money`)
VALUES ('A',2000.00),('B',10000.0)
-- =================事务====================
-- 事务
SET autocommit = 0; -- 关闭自动提交
START TRANSACTION; -- 开启一个事务（一组事务）
UPDATe account SET money=money-500 WHERe `name` = 'A'; -- A减500
UPDATE account SET money=money+500 WHERe `name` = 'B'; -- B减500
COMMIT; -- 提交事务
ROLLBACK; -- 回滚,事务一旦提交就无法修改，持久化
SET autocommit = 1; -- 回复默认值
7、索引
MySQL官方对索引的定义为：索引（Index）是帮助MySQL高效获取数据的数据结构。
提取句子主干，就可以得到索引的本质。索引是一种数据结构
###7.1、索引的分类
在一个表中，主键索引只能有1个，唯一索引可以有多个
- 主键索引（PRIMARY KEY）
- 唯一的标识，主键不可重复，只能有一个列作为主键
- 唯一索引（UNIQUE KEY）
- 避免重复的列出现，唯一索引可以重复，多个列都可以表示为唯一索引。唯一指的是列的每个数据被独占不可再重复，可重复是指这样的唯一索引可以设置多个
- 常规索引（KEY/INDEX）
- 默认，index。key关键字来设置
- 全文索引（FullText）
- 在特定的数据库引擎下才有，MyISAM
- 快速定位数据
-- 索引的使用
-- 1、在创建表的时候给字段增加字段
-- 2、创建完毕后增加索引
-- 显示所有的索引信息
SHOW INDEX FROM student;
-- 增加一个索引
ALTER TABLE school.student ADD FULLTEXT INDEX `studentName`(`studentName`);
-- 索引的使用
-- 1、在创建表的时候给字段增加字段
-- 2、创建完毕后增加索引
-- 显示所有的索引信息
SHOW INDEX FROM student;
-- 增加一个索引(索引名)
ALTER TABLE school.student ADD FULLTEXT INDEX `studentName`(`studentName`);
-- EXPLAIN 分析sql执行的状况
EXPLAIN SELECt *FROM student; -- 非全文索引
SELECt *FROM student WHERe MATCH(studentname) AGAINST('刘');
7.2、模拟测试
-- 创建app用户表 CREATE TABLE `app_user` ( `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT, `name` varchar(50) DEFAULT '' COMMENT '用户昵称', `email` varchar(50) NOT NULL COMMENT '用户邮箱', `phone` varchar(20) DEFAULT '' COMMENT '手机号', `gender` tinyint(4) unsigned DEFAULT '0' COMMENT '性别（0：男；1：女）', `password` varchar(100) NOT NULL COMMENT '密码', `age` tinyint(4) DEFAULT '0' COMMENT '年龄', `create_time` datetime DEFAULT CURRENT_TIMESTAMP, `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='app用户表'; -- 创建插入100万条数据的函数mock_data() DELIMITER $$ -- 写函数前必须要写，标志 CREATE FUNCTION mock_data() RETURNS INT BEGIN DECLARE num INT DEFAULT 1000000; DECLARE i INT DEFAULT 0; WHILE i当我们执行SELECT *FROM app_user WHERe name='用户9999'
SELECt *FROM app_user WHERe name='用户9999'; -- 耗时0.0679s EXPLAIN SELECt *FROM app_user WHERe name='用户9999'; -- 发现是在rows=992793（这个数字因人而异），非常大 -- 创建索引 -- id_表名_字段名 -- CREATE INDEX 索引名 ON 表(字段) CREATE INDEX id_app_user_name ON app_user(`name`); -- 再次查询 SELECt *FROM app_user WHERe name='用户9999'; -- 耗时 0.004s，速度提升非常明显###7.3、索引原则
- 索引不是越多越好
- 不要对经常变动的数据加索引
- 小数据量的表不需要加索引
- 索引一般加在常用来查询的字段上！
索引的数据结构
Hash类型的索引
Btree：InnoDB 的默认数据结构
JAVA 方法(){ try(){ 正常的业务代码; commit() }catch(){ roolback() } }8、权限管理和备份###8.1、用户管理
SQL命令操作
用户表：mysql.user
-- 创建用户 CREATE USER bspt IDENTIFIED BY '123456'; -- 修改当前用户密码 SET PASSWORD=PASSWORd('111111'); -- 修改指定用户密码 SET PASSWORD FOR bspt=PASSWORd('111111'); -- 重命名 -- RENAME USER 原名 TO 新名字; RENAME USER bspt TO baishuipaotang; -- 用户授权 ALL PRIVILEGES 全部权限，全部的库 -- 除了给别人授权权限，其他权限与root一样 GRANT ALL PRIVILEGES ON *.* TO baishuipaotang; -- 查询权限 SHOW GRANTS FOR baishuipaotang;[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lgg6LLbv-1638959695370)(D:Markdownday4_mysql用户权限.png)]
8.2、MySQL备份为什么要备份：
- 保证重要数据不丢失
- 数据转移
MySQL数据库备份的方式
直接拷贝物理文件
在Navicat等可视化工具中转储SQL文件
在想要导出的表或者库中右击，选择转储SQL文件，一般来说结构和数据都转储
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-22VTYBbk-1638959695371)(D:Markdownday4_mysql备份.png)]
使用命令行导出mysqldump命令
-- mysqldump -h 主机 -u 用户名 -p 密码 数据库 表名 > 物理磁盘位置/文件名 mysqldump -hlocalhost -uroot -p123456 school student >D:/Markdown/day4_mysql/abc.sql9、规范数据库设计 9.1、为什么需要设计当数据库比较复杂的时候，我们就需要设计
糟糕的数据库设计：
- 数据冗杂，浪费空间
- 数据库插入和删除都会麻烦、异常【屏蔽使用物理外键】
- 程序性能差的
良好的数据库设计：
- 节省内存空间
- 保证数据库的完整性
- 方便我们开发系统
软件开发中，关于数据库的设计
- 分析需求：分析业务和需要处理的数据库的需求
- 概要设计：设计关系图E-R图
设计数据库的步骤：（个人博客）
9.2三大范式
- 收集信息，分析需求
- 用户表（用户登录注销，用户的个人信息，写博客，创建分类）
- 分类表（文章分类，谁创建的）
- 文章表（文章的信息）
- 友链表（友链信息）
- 自定义表（系统信息，某个关键的字，或者一些主字段） key:value
- 标识实体（把需求落地到每一个字段）
- 标识实体之间的关系
- 写博客：user——>blog
- 创建分类：user——>category
- 关注：user——>user
- 友链：links
- 评论：user——>user——>blog
为什么需要数据规范化
- 信息重复
- 更新异常
- 插入异常
- 无法正常显示信息
- 删除异常
- 丢失有效的信息
三大范式
第一范式（1NF）
原子性：保证每一列不可再分
第二范式（2NF）
前提：满足第一范式
每张表只描述一件事情
第三范式(3NF)
前提：满足第一范式和第二范式
第三范式需要确保数据表中的每一列数据都和主键直接相关，而不能间接相关
规范性和性能的问题
关联查询的表不得超过三张表
10、JDBC（重点） 10.1、数据库驱动
- 考虑商业化的需求和目标，（成本，用户体验）数据库的性能更加重要
- 在考虑规范性能的问题的时候，要适当的考虑一下规范性
- 故意给某些表增加一些冗余的字段（从多表查询中变成单表查询
- 故意增加一些计算列（从大数据量降低为小数据量的查询：索引）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aySLVk6q-1638959695372)(D:Markdownday4_mysqlJDBC.png)]
我们程序的会通过数据库驱动与数据库打交道
###10.2、JDBC
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cEky7M7Y-1638959695373)(D:Markdownday4_mysqlJDBC2.png)]
java.sql
javax.sql
还需要导入一个数据库驱动包
10.3、第一个JDBC程序CREATE DATAbase `jdbcStudy` CHARACTER SET utf8 COLLATE utf8_general_ci; USE `jdbcStudy`; CREATE TABLE `users`( `id` INT PRIMARY KEY, `NAME` VARCHAR(40), `PASSWORD` VARCHAR(40), `email` VARCHAR(60), birthday DATE ); INSERT INTO `users`(`id`,`NAME`,`PASSWORD`,`email`,`birthday`) VALUES(1,'zhangsan','123456','zs@sina.com','1980-12-04'), (2,'lisi','123456','lisi@sina.com','1981-12-04'), (3,'wangwu','123456','wangwu@sina.com','1979-12-04')1、新建项目，然后在项目内新建一个lib文件夹，
2、将jdbc的包粘贴到lib目录下，右击目录后选择Add as Library...，单击弹窗的ok后，就完成了导包
3、编写代码
package com.bspt.lesson01; import java.sql.*; public class JdbcFirstDemo { public static void main(String[] args) throws ClassNotFoundException, SQLException { //1、加载驱动 // Class.forName("com.mysql.jdbc.Driver");//已经被弃用的写法 Class.forName("com.mysql.cj.jdbc.Driver");//固定写法 //2、用户信息和url String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true"; String username = "root"; String password = "123456"; //3、连接成功，数据库对象,Connection代表数据库 Connection connection = DriverManager.getConnection(url,username,password); //4、执行SQL的对象 Statement statement = connection.createStatement(); //5、执行SQL的对象 去 执行SQL，可能存在结果，查看返回 String sql = "SELECt * FROM users"; ResultSet resultSet = statement.executeQuery(sql);//结果集中封装了所有查询出的结果 while(resultSet.next()){ System.out.println("id=" + resultSet.getObject("id")); System.out.println("name=" + resultSet.getObject("NAME")); System.out.println("password=" + resultSet.getObject("PASSWORD")); System.out.println("email=" + resultSet.getObject("email")); System.out.println("birthday=" + resultSet.getObject("birthday")); } //6、释放连接 resultSet.close(); statement.close(); connection.close(); } }步骤总结：
1、加载驱动
2、连接数据库DriverManager
3、获得执行sql的对象Statement
4、获得返回的结果集
5、释放连接
DriverManger
Class.forName("com.mysql.cj.jdbc.Driver");//固定写法 //DriverManager.registerDriver(new Driver()); Connection connection = DriverManager.getConnection(url,username,password); // connection 代表数据库 //事务回滚 //事务提交 //数据库设置自动提交 connection.rollback(); connection.commit(); connection.setAutoCommit();URL
String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true"; //协议://主机地址:端口号/数据库名?参数1&参数2&参数3 // musql -- 默认3306 // oralce -- 默认1521 //jdbc:oralce:thin:@localhost:1521:sid String username = "root"; String password = "123456";Statement 执行SQL的对象 connection.prepareStatement() 执行SQL的对象
String sql = "SELECt * FROM users"; Statement statement = connection.createStatement(); statement.executeQuery();//执行查询 statement.execute();//执行任何sql操作 statement.executeUpdate();//更新、插入、删除都是用这个，返回一个受影响的行ResultSet
ResultSet resultSet = statement.executeQuery(sql);//结果集中封装了所有查询出的结果 resultSet.getObject();//在不知道列类型的情况下使用 //如果知道列的类型就用指定类 resultSet.getObject(); resultSet.getString(); resultSet.getInt(); resultSet.getFloat(); resultSet.getDate(); ....指针遍历
resultSet.beforeFirst();//移动到最前面的 数据 resultSet.afterLast();//移动到最后一个数据 resultSet.next();//移动到下一个数据 resultSet.previous();//移动到前一个数据 resultSet.absolute(row);//移动到指定航释放资源
//6、释放连接 resultSet.close(); statement.close(); connection.close();代码实现
1、提取工具类
package com.bspt.lesson02.utils; import java.io.IOException; import java.io.InputStream; import java.sql.*; import java.util.Properties; public class JdbcUtils { private static String driver = null; private static String url = null; private static String username = null; private static String password = null; static { try{ InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties"); Properties properties = new Properties(); properties.load(in); driver = properties.getProperty("driver"); url = properties.getProperty("url"); username = properties.getProperty("username"); password = properties.getProperty("password"); Class.forName(driver); } catch (Exception e){ e.printStackTrace(); } } //获取连接 public static Connection getConnect() throws SQLException { return DriverManager.getConnection(url,username,password); } //释放连接资源 public static void release(Connection conn, Statement st, ResultSet rs){ if(rs != null){ try{ rs.close(); }catch (SQLException e){ e.printStackTrace(); } } if(st != null){ try{ st.close(); }catch (SQLException e){ e.printStackTrace(); } } if(conn != null){ try{ conn.close(); }catch (SQLException e){ e.printStackTrace(); } } } }2、编写增删改的方法executeUpdate
- 增
package com.bspt.lesson02; import com.bspt.lesson02.utils.JdbcUtils; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class TestInsert { public static void main(String[] args) { Connection conn = null; Statement st = null; ResultSet rs = null; try { conn = JdbcUtils.getConnect();//获取数据库连接 st = conn.createStatement(); String sql = "INSERT INTO users(id,`NAME`,`PASSWORD`,`email`,`birthday`)n" + "VALUES(4,'bspt','123456','1145141919@qq.com','2022-01-01')"; int i = st.executeUpdate(sql); if(i > 0){ System.out.println("插入成功！"); } } catch (SQLException e) { e.printStackTrace(); } finally { JdbcUtils.release(conn,st,rs); } } }
- 删
package com.bspt.lesson02; import com.bspt.lesson02.utils.JdbcUtils; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class TestDelete { public static void main(String[] args) { Connection conn = null; Statement st = null; ResultSet rs = null; try { conn = JdbcUtils.getConnect();//获取数据库连接 st = conn.createStatement(); String sql = "DELETE FROM users WHERe id=4"; int i = st.executeUpdate(sql); if(i > 0){ System.out.println("删除成功！"); } } catch (SQLException e) { e.printStackTrace(); } finally { JdbcUtils.release(conn,st,rs); } } }
- 改
package com.bspt.lesson02; import com.bspt.lesson02.utils.JdbcUtils; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class TestUpdate { public static void main(String[] args) { Connection conn = null; Statement st = null; ResultSet rs = null; try { conn = JdbcUtils.getConnect();//获取数据库连接 st = conn.createStatement(); String sql = "UPDATE users SET `NAME`='bspt',`email`='1145141919@qq.com' WHERe id=1"; int i = st.executeUpdate(sql); if(i > 0){ System.out.println("更新成功！"); } } catch (SQLException e) { e.printStackTrace(); } finally { JdbcUtils.release(conn,st,rs); } } }3、查
package com.bspt.lesson02; import com.bspt.lesson02.utils.JdbcUtils; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class TestSelect { public static void main(String[] args) { Connection conn = null; Statement st = null; ResultSet rs = null; try{ conn = JdbcUtils.getConnect(); st = conn.createStatement(); //SQL String sql = "select * from users where id=1"; rs = st.executeQuery(sql); while(rs.next()){ System.out.println(rs.getString("NAME")); } } catch (SQLException e){ e.printStackTrace(); } finally { JdbcUtils.release(conn,st,rs); } } }SQL注入问题
SQL存在漏洞，会被攻击导致数据泄露
本质：SQL会被拼接，如下面例子的" 'or '1=1"，从而导致账号密码全被查出来
package com.bspt.lesson02; import com.bspt.lesson02.utils.JdbcUtils; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class SQLInseart { public static void main(String[] args) { login(" 'or '1=1"," 'or '1=1"); } public static void login(String username,String password){ Connection conn = null; Statement st = null; ResultSet rs = null; try{ conn = JdbcUtils.getConnect(); st = conn.createStatement(); //SQL SELECt * FROM users WHERe `NAME`='bspt' AND `password`='123456'; String sql = "SELECt * FROM users WHERe `NAME`='"+username+"' AND `password`='"+password+"'"; rs = st.executeQuery(sql); while(rs.next()){ System.out.println("username="+rs.getString("NAME")); System.out.println("password="+rs.getString("password")); System.out.println(); } } catch (SQLException e){ e.printStackTrace(); } finally { JdbcUtils.release(conn,st,rs); } } }10.4、statement对象Jdbc中的statement对象用于向数据库发送SQL语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可。
Statement对象的executeUpdate方法，用于向数据库发送增、删、改的sql语句，executeUpdate执行完后，将会返回一个整数（即增删改语句导致了数据库多少行数据发生了变化）。
Statement.executeQuery方法用于向数据库发送查询语句，executeQuery方法返回代表查询结果的ResultSet对象。
CRUD操作-增、删、改
conn = JdbcUtils.getConnect(); st = conn.createStatement(); String sql = "insert into user(...) values(...)";//插入 //String sql = "delete from user where id=1";//删除 //String sql = "update user set name='' where name=''";//更新 int num = st.executeUpdate(sql); if(num > 0){ System.out.println("插入成功"); //System.out.println("删除成功"); //System.out.println("更新成功"); }CRUD操作-read
conn = JdbcUtils.getConnect(); st = conn.createStatement(); String sql = "select * from user where id=1";//插入 ResultSet rs = st.executeQuery(sql); while(rs.next()){ //根据获取列的数据类型，分别调用rs的相应方法映射到java中 }10.5、prepareStatement对象prepareStatement 可以防止SQL注入，效率更高！
1、新增
package com.bspt.lesson03; import com.bspt.lesson02.utils.JdbcUtils; import javax.xml.crypto.Data; import java.sql.*; import java.sql.Connection; import java.util.Date; public class TestInsert { public static void main(String[] args) { Connection conn = null; PreparedStatement st = null; ResultSet rs = null; try { conn = JdbcUtils.getConnect(); //区别 //使用? 占位符替代参数 String sql = "INSERT INTO users(id,`NAME`,`PASSWORD`,`email`,`birthday`) values(?,?,?,?,?)"; st = conn.prepareStatement(sql);//预编译SQL，先写SQL但不执行 //手动设置参数 st.setInt(1,4);//id st.setString(2,"jiren");//名字 st.setString(3,"1145141919"); st.setString(4,"1145141919@qq.com"); st.setDate(5,new java.sql.Date(new Date().getTime())); int i = st.executeUpdate(); if(i > 0){ System.out.println("插入成功！"); } } catch (SQLException e) { e.printStackTrace(); } finally { JdbcUtils.release(conn,st,rs); } } }2、删除
package com.bspt.lesson03; import com.bspt.lesson02.utils.JdbcUtils; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.Date; public class TestDlete { public static void main(String[] args) { Connection conn = null; PreparedStatement st = null; ResultSet rs = null; try { conn = JdbcUtils.getConnect(); //区别 //使用? 占位符替代参数 String sql = "delete from users where id=?"; st = conn.prepareStatement(sql);//预编译SQL，先写SQL但不执行 //手动设置参数 st.setInt(1,4); int i = st.executeUpdate(); if(i > 0){ System.out.println("删除成功！"); } } catch (SQLException e) { e.printStackTrace(); } finally { JdbcUtils.release(conn,st,rs); } } }3、更新
package com.bspt.lesson03; import com.bspt.lesson02.utils.JdbcUtils; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.Date; public class TestUpdate { public static void main(String[] args) { Connection conn = null; PreparedStatement st = null; ResultSet rs = null; try { conn = JdbcUtils.getConnect(); //区别 //使用? 占位符替代参数 String sql = "update users set `NAME`=? where id=?"; st = conn.prepareStatement(sql);//预编译SQL，先写SQL但不执行 //手动设置参数 st.setString(1,"jr"); st.setInt(2,4); int i = st.executeUpdate(); if(i > 0){ System.out.println("更新成功！"); } } catch (SQLException e) { e.printStackTrace(); } finally { JdbcUtils.release(conn,st,rs); } } }4、查询
package com.bspt.lesson03; import com.bspt.lesson02.utils.JdbcUtils; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; public class TestSelect { public static void main(String[] args) { Connection conn = null; PreparedStatement st = null; ResultSet rs = null; try { conn = JdbcUtils.getConnect(); String sql = "select * from users where id=?"; st = conn.prepareStatement(sql);//预编译 st.setInt(1,1);//传递参数 rs = st.executeQuery();//执行 if(rs.next()){ System.out.println(rs.getString("name")); } } catch (SQLException e){ e.printStackTrace(); } finally { JdbcUtils.release(conn,st,rs); } } }###10.6、IDEA连接数据库
1、在IDEA右侧的DATEbase菜单中选中+号，选择Date Source中的MySQL
2、如果时间不匹配就去百度搜索修改时区
3、连接成功后，添加数据库：选择Schemas菜单，选择添加Jdbcstudy数据库
4、双击数据库，修改数据，点击submit确认修改
10.8、事务要么都成功，要么都失败
ACID原则
原子性：要么全部完成，要么都不完成
一致性：总数不变
隔离性：多个进程互不干扰
持久性：一单提交不可逆，持久化到数据库
隔离性的问题：
脏读：一个事务读取了另一个没有提交的事务
不可重复读：在同一个事务内，重复读取表中的数据，表数据发生了改变
虚读（幻读）：在一个事务内，读取到了别人插入的数据，导致前后读出来结果不一致
代码实现
-- 创建account表 CREATE TABLE account( id INT PRIMARY KEY AUTO_INCREMENT, NAME VARCHAR(40), money FLOAT ); insert into account(name,money) values('A',1000); insert into account(name,money) values('B',1000); insert into account(name,money) values('C',1000);package com.bspt.lesson04; import com.bspt.lesson02.utils.JdbcUtils; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; public class TestTransaction1 { public static void main(String[] args) { Connection conn = null; PreparedStatement st = null; ResultSet rs = null; try{ conn = JdbcUtils.getConnect(); //关闭数据库的自动提交功能，自动会开启事务 conn.setAutoCommit(false);//开启事务 String sql1 = "update account set money=money-100 where name = 'A'"; st = conn.prepareStatement(sql1); st.executeUpdate(); String sql2 = "update account set money=money+100 where name = 'B'"; st = conn.prepareStatement(sql2); st.executeUpdate(); //业务完成，提交事务 conn.commit(); System.out.println("提交成功！"); } catch (SQLException e){ //如果失败会默认回滚 try{ conn.rollback(); } catch (SQLException e1){ e1.printStackTrace(); } e.printStackTrace(); } finally { JdbcUtils.release(conn,st,rs); } } }10.9、数据库连接池数据库连接 — 执行完毕 — 释放
连接 — 释放：十分浪费系统资源
池化技术：准备一些预先的资源，过来就连接预先准备好的
------ 开门–业务员：等待 – 服务—
最小连接数：10
最大连接数：15
等待超时：100ms
编写连接池，实现一个接口 DataSource
开源数据源实现（拿来即用）
DBCP
C3P0
Druid：阿里巴巴
使用了这些数据库连接池之后，我们在项目开发中就不需要编写连接数据库的代码了
DBCP
需要用到的jar包
commons-dbcp2-2.9.0.jar commons-pool2-2.11.1.jar
C3P0
需要的jar包
c3p0-0.9.5.5.jar mchange-commons-java-0.2.19.jar
结论
无论使用什么数据源，本质还是一样的，DataSource还是不会变的，方法就不会变
