数据库MySQL

数据库MySQL

1、初始MySQL

JavaEE：企业级Java开发 Web

前端（页面：展示数据）

后台（连接点：连接数据库JDBC，连接前端（控制，控制视图跳转，和给前端传递数据））

数据库（存数据，TXT，Excel，Word）

只会写代码，学好数据库，基本混饭吃；

操作系统，数据结构与算法！当一个不错的程序猿！

离散数学，数字电路，体系结构，编译原理。+实战经验---》高级程序猿~ 优秀的程序猿~

1.1、为什么要学习数据库

1、岗位需求

2、现在的世界，大数据时代~

3、被迫需求：存数据

4、数据库是所有软件体系中最核心的存在 DBA

1.2、什么是数据库

数据库（DB，DataBase）

概念：数据仓库，软件，安装在操作系统（Window，Linux，Mac......）之上！SQL，可以存储大量的数据。500万以下的数据

作用：存储数据，管理数据

1.3、数据库分类

关系型数据库：（SQL）

• 类似Excel表，行跟列

• MySQL，Oracle，SqlServer，DB2，SQLlite

• 通过表和表之间，行和列之间的关系进行数据的存储，学员信息表，考勤表，.......

非关系型数据库：（NoSQL）Not OnlySQL

• Redis，MongoDB

• 非关系型数据库，对象存储，通过对象自身属性来决定的。

DBMS（数据库管理系统）

• 数据库的管理软件，科学有效的管理我们的数据。维护和获取数据；
• MySQL，数据库管理系统！

1.4、MySQL简介

MySQL是一个关系型数据库管理系统，由瑞典MySQL AB 公司开发，属于 Oracle 旗下产品。MySQL是最好的 RDBMS (Relational Database Management System，关系数据库管理系统) 应用软件之一。

MySQL所使用的 SQL 语言是用于访问数据库的最常用标准化语言。体积小、速度快、总体拥有成本低，尤其是开放源码这一特点，一般中小型和大型网站的开发都选择 MySQL 作为网站数据库。

官网：https://www.mysql.com/

安装建议:
1、尽量不要使用exe，注册表
2、尽可能使用压缩包安装~

1.5、安装MySQL

详见(狂神说)公众号：https://mp.weixin.qq.com/s/E1PM4EHwU6Joot4OG0gDjw

sc delete mysql ,清空服务

1.6、安装SQLyog

默认的四个数据库，不可以删除。

1.7连接数据库

命令行连接

在cmd命令行打开mysql的方法

1、桌面左下角windows图标--搜索框内输入cmd，结果如图所示，点击cmd.exe，或者使用快捷键Windows键(在键盘上有个Windows标志的按键)+R输入cmd后回车（管理员身份运行）。

2、启动mysql数据库：在出来的DOS命令窗口中输入 net start mysql，或者使用快捷键Windows键(在键盘上有个Windows标志的按键)+ R直接输入net start mysql后回车。(另附：关闭的命令为net stop mysql)

3、在DOS命令窗口输入 mysql -hlocalhost -uroot -p回车 进入mysql数据库，其中-h表示服务器名，localhost表示本地；-u为数据库用户名，root是mysql默认用户名；-p为密码，如果设置了密码，可直接在-p后链接输入，如：-p123456，用户没有设置密码，显示Enter password时，直接回车即可。

4、注意，如果你的mysql没有安装在C盘下，你需要先使用DOS命令进入mysql的安装目录下的bin目录中。以我的电脑为例，方法如下：输入D:进入D盘，在输入cd D:\Tools\MySQL5.5.25\bin进入到mysql的bin目录下才可以输入 mysql -hlocalhost -uroot -p

5、输入show databases；显示你有的数据库(mysql数据库中的命令必须以分号结尾“；”)

6、如果要退出mysql数据库，输入exit;回车

基本常用命令

update user set password=password('123456')where user='root'; 修改密码
flush privileges; 刷新数据库
show databases; 显示所有数据库
use dbname；打开某个数据库
show tables; 显示数据库mysql中所有的表
describe user; 显示表mysql数据库中user表的列信息
create database name; 创建数据库
use databasename; 选择数据库

exit; 退出Mysql
? 命令关键词 : 寻求帮助
-- 表示注释

数据库XXX语言 CRUD增删改查！

DDL 定义

DML 操作

DQL 查询

DCL 控制

2、操作数据库

操作数据库--->操作数据库中的表---->操作数据库表中的数据

SQL语句不区分大小写

2.1、操作数据库（了解）

2.1.1、创建数据库

CREATE	DATABASE [IF NOT EXISTS] westos 

2.1.2、删除数据库

DROP DATABASE IF EXISTS westos

2.1.3、使用数据库

USE school

2.1.4、查看数据库

SHOW DATABASES	--查看所有的数据库

2.2、数据库的列类型

数值

• tinyint  十分小的数据（1个字节的大小）
• smallint  较小的数据（2个字节的大小）
• mediumint  中等大小的数据（3个字节的大小）
• int     标准的整数（4个字节的大小）常用
• bigint    较大的数据（8个字节的大小）
• float     浮点数（4个字节的大小）
• double     双精度浮点数（8个字节的大小）
• decimal     字符串形式的浮点数，金融计算的时候，一般使用decimal

字符串

• char     字符串固定大小  0~255
• varchar    可变字符串  0~65535  常用的变量  String
• tinytext    微型文本  2⁸-1
• text      文本串   2¹⁶-1

时间日期

java.util.Date

• date   YYYY-MM-DD  日期格式

• time   HH:mm:ss   时间格式

• datatime  YYYY-MM-DD HH:mm:ss  最常用的时间格式

• timestamp  时间戳  1970.01.01到现在的毫秒数  全球统一

• year  年份表示

null

• 没有值，未知
• 注意：不要使用NULL进行运算，结果为NULL，无意义的操作

2.3、数据库的字段属性（重点）

• Unsigned
  • 无符号的整数
  • 声明该列不能为负数
• zerofill
  • 0填充的
  • 不足的位数用0填充
• auto_increment
  • 自增
  • 自动在上一条记录的基础上＋1（默认）
  • 通常用来设置唯一的主键（主键自增），必须是整数类型
  • 可以自定义设计主键自增的起始值和步长
• NULL/notNull
  • 空/非空
  • 假设设置为not null ，如果不给它赋值，就会报错！
  • 假设设置为Null ，如果不给它赋值，默认为null
• default
  • 默认
  • sex，默认值为男，如果不指定该列的值，则会有默认的值！

2.4、创建数据库表

-- 目标 : 创建一个school数据库
-- 创建学生表(列,字段)
-- 学号int 登录密码varchar(20) 姓名,性别varchar(2),出生日期(datatime),家庭住址,email
-- 创建表之前 , 一定要先选择数据库

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

-- 查看数据库的定义
SHOW CREATE DATABASE school;
-- 查看数据表的定义
SHOW CREATE TABLE student;
-- 显示表结构
DESC student;  -- 设置严格检查模式(不能容错了)SET sql_mode='STRICT_TRANS_TABLES';

格式

CREATE TABLE IF NOT EXISTS `student` (
    `字段名` 列属性(长度) [属性] [索引] [注释],
    `字段名` 列属性(长度) [属性] [索引] [注释],
    `字段名` 列属性(长度) [属性] [索引] [注释],
    ......
     `字段名` 列属性(长度) [属性] [索引] [注释]
) [表类型]=[字符集设置]

常用命令

SHOW CREATE DATABASE school -- 查看创建数据库的语句
SHOW CREATE TABLE student -- 查看student数据表的定义语句
DESC student --显示表的结构

2.5、数据表的类型

--关于数据库引擎
/*
    INNODB		默认使用~
    MYISAM		早些年使用的
*/

	MYISAM	INNODB
事务支持	不支持	支持
数据行锁定	不支持	支持
外键约束	不支持	支持
全文索引	支持	不支持
表空间大小	较小	较大，约为2MYISAM

常规使用操作：

• MYISAM：节约空间，速度较快

• INNODB：安全性高，事务的处理，多表多用户操作

在物理空间存在的位置

所有的数据库文件都存在data目录下，一个文件夹就对应一个数据库

本质还是文件的形式存储

MySQL引擎在物理文件上的区别

• InnoDB 在数据库表中只有一个*.frm文件，以及上级目录下的ibdata文件
• MYISAM对应文件
  • *.frm -表结构的定义文件
  • *.MYD -数据文件（data）
  • *.MYI -索引文件

设置数据库表的字符集编码

CHARSET=utf8

不设置的话，会是mysql 默认的字符集编码~ (不支持中文! )

MySQL的默认编码是Latin1,不支持中文

在my.ini中配置默认的编码

character-set-server=utf8

2.6、修改表和删除表

修改表

--修改表名	ALTER TABLE 旧表名 RENAME AS 新表名
    ALTER TABLE teacher RENAME AS teacher1
--增加表的字段ALTER TABLE 表名 ADD 字段名 列属性
    ALTER TABLE teacher1 ADD age INT(11)
--修改表的字段(重命名，修改约束! )
--ALTER TABLE 表名 MODIFY 字段名 列属性[]
    ALTER TABLE teacher1 MODIFY age VARCHAR(11)	--修改约束
 --ALTER TABLE 表名 CHANGE 旧名字 新名字 列属性[]
    ALTER TABLE teacher1 CHANGE age age1 INT(1) --字段重名名
--删除表的字段	ALTER TABLE 表名 DROP 字段名
	ALTER TABLE teacher1 DROP age1

删除表

--删除表	DROP TABLE [IF EXISTS] 表名	(如果表存在再删除)
DROP TABLE IF EXISTS teacher1

所有的创建和删除操作尽量加上判断，以免报错

注意点:

• ``：字段名，使用这个包裹！
• 注释：--或者/**/
• sql关键字大小不敏感，建议小写
• 所有的符号全部用英文！

3、MySQL的数据管理

3.1、外键（了解即可）

方式一、建表时指定外键约束

-- 创建外键的方式一 : 创建子表同时创建外键

-- 年级表 (id\年级名称)
CREATE TABLE `grade` (
`gradeid` INT(10) NOT NULL AUTO_INCREMENT COMMENT '年级ID',
`gradename` VARCHAR(50) NOT NULL COMMENT '年级名称',
PRIMARY KEY (`gradeid`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

-- 学生信息表 (学号,姓名,性别,年级,手机,地址,出生日期,邮箱,身份证号)
CREATE TABLE `student` (
`studentno` INT(4) NOT NULL COMMENT '学号',
`studentname` VARCHAR(20) NOT NULL DEFAULT '匿名' COMMENT '姓名',
`sex` TINYINT(1) DEFAULT '1' COMMENT '性别',
`gradeid` INT(10) DEFAULT NULL COMMENT '年级',
`phoneNum` VARCHAR(50) NOT NULL COMMENT '手机',
`address` VARCHAR(255) DEFAULT NULL COMMENT '地址',
`borndate` DATETIME DEFAULT NULL COMMENT '生日',
`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
`idCard` VARCHAR(18) DEFAULT NULL COMMENT '身份证号',
PRIMARY KEY (`studentno`),
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(`gradeidi`) REFERENCES `grade' (`gradeid`);
--公式：
ALTER TABLE `表名` ADD CONSTRAINT `约束名` FOREIGN KEY(`作为外键的列`) REFERENCES `另一个表' (`另一个表的字段`(一般是另一个表的主键));

以上的操作都是物理外键，数据库级别的外键，我们不建议使用！（避免数据库过多造成困扰，这里了解即可。）

最佳实践

• 数据库就是单纯的表，只用来存数据，只有行（数据）和列（字段）
• 我们想使用多张表的数据，想使用外键(程序去实现)

3.2、DML语言(必须全部记住)

DML：数据操作语言（增删改操作）

数据库意义: 数据存储，数据管理

• insert    添加
• update   修改
• delete    删除

3.3、添加

insert

插入语句(添加)
insert into 表名(字段名1,字段2,字段3) values ('值1', '值2', '值3'，....)
INSERT INTO `grade` (`gradename、) VALUES ('大四')
--般写插入语句，我们一定要数据和字段一一对应!
--插入多个字段
INSERT INTO `grade` (`gradename`) VALUES ('大二'),('大一')

注意事项:

1. 字段和字段之间使用英文逗号隔开
2. 字段是可以省略的，但是后面的值必须要要一一对应
3. 可以同时插入多条数据，VALUES后面的值，需要使用，隔开即可

3.4、修改

update 修改谁 （条件） set 原来的值 = 新值

--修改学员名字，带了条件
UPDATE `student` SET `name`='张三' WHERE id = 1;
--不指定条件的情况下，会改动所有表!
UPDATE `student` SET `name`='长江7号'

--语法：
--UPDATE 表名 set colnum_name = value,[colnum_name = value,....] where [条件]

--修改多个属性,逗号隔开
UPDATE `student` SET `name`='上官宝',`email`='24736743@qq.com' WHERE id = 1;

条件：where子句运算符 id等于某个值，大于某个值，在某个区间内修改...

操作符会返回布尔值

操作符	含义	范围	结果
=	等于	5=6	false
<>或!=	不等于	5<>6	true
>	大于	5>6	false
<	小于	5<6	true
>=	大于等于	5>=6	false
<=	小于等于	5<=6	true
BETWEN(betwen)...AND...	在某个范围内	[2,5]
AND	和（&&）	5>1and2<3	false
OR	或（||）	5>1or2<3	true

--通过多个条件定位数据
UPDATE `student` SET `name`='长江7号' 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`（避免这样不加条件删除表，这样会删除表中所有数据）
--删除指定数据
DELETE FROM `student` WHERE id = 1;

TRUNCATE 命令

作用：完全清空一张数据库表，表的结构和索引约束不会改变！

--清空student表
TRUNCATE `student`

delete和TRUNCATE的区别

• 相同点：都能删除数据，都不会删除表结构
• 不同：
  • TRUNCATE 重新设置自增列，计数器归零
  • TRUNCATE 不会影响事务

了解即可：DELETE删除的问题 ，重启数据库，现象

• InnoDB 自增列会从1开始（存在内存当中的，断电即失）
• MyISAM 继续从上一个自增量开始（存在文件当中的，不会丢失）

4、DQL查询数据（最重点）

4.1、DQL

(Data Query LANGUAGE：数据查询语言)

• 所有的查询操作都用它 Select
• 简单的查询，复杂的查询它都能做~
• 数据库中最核心的语言，最重要的语句
• 使用频率最高的语句

4.2、指定查询字段

查询全部的学生

--SELECT 字段 FROM 表名
SELECT * FROM student

查询询指定字段

--SELECT `字段名1`,`字段名2` FROM 表名
SELECT `StudentNo`,`StudentName` FROM student

别名，给结果起一个名字 AS

--SELECT `字段名` As 别名1,`字段名` As 别名2 FROM 表名（别名可以不加双引号）
SELECT `StudentNo` As 学号,`StudentName` As 学生姓名 FROM student
--SELECT `字段名` As 别名1,`字段名` As 别名2 FROM 表名 As 表别名（也可以给结果表取别名）
SELECT `StudentNo` As 学号,`StudentName` As 学生姓名 FROM student As s1

函数 Concat(a,b)

--SELECT CONCAT('待拼接的字符',字段名) AS 新名字 FROM 表名
SELECT CONCAT('姓名:',StudentName) AS 新名字 FROM student

有的时候，列名字不是那么的见名知意。我们起别名是最好的选择。

4.3、去重（去除重复的数据）

distinct 去重

--查询有哪些同学参加了考试
SELECT `StudentNo` FROM result

发现重复数据，这时候要去重

SELECT DISTINCT `StudentNo` FROM result

4.4、数据库的列（表达式）

SELECT VERSION()	--查询系统版本	(函数)
SELECT 100*3-1 AS 计算结果	--用来计算	（表达式）
SELECT @@auto_increment_increment	--查询自增的步长	（变量）

--学员考试成绩+1分查看
SELECT `StudentNo`,`StudentResult`+1 AS '提分后' FROM result

数据库中的表达式：文本值， 列，Nll，函数，计算表达式，系统变量...

select 表达式 from 表名

4.5、where条件子句

作用：检索数据中符合条件的值

搜索的条件由一个或者多个表达式组成！结果为布尔值

4.5.1逻辑运算符

运算符	语法	描述
and &&	a and b a&&b	逻辑与，两个都为真，结果为真
or ||	a or b a||b	逻辑或，一个为真，结果为真
Not !	not a !a	逻辑非，真为假，假为真

尽量使用英文字母

AND

--查询考试成绩在95~100分之间
SELECT `StudentNo`,`StudentResult` FROM result 
WHERE StudentResult>=95 AND StudentResult<=100

BETWEEN...AND...

----模糊查询(区间范围)
SELECT `StudentNo`,`StudentResult` FROM result 
WHERE StudentResult BETWEEN 95 AND 100

!= NOT

--除了1000号学生之外的同学的成绩
SELECT `StudentNo`,`StudentResult` FROM result WHERE studentNo != 1000;
--上面的SQL语句等价于下面这条语句
SELECT `StudentNo`,`StudentResult` FROM result WHERE NOT studentNo = 1000;

4.5.2、模糊查询：比较运算符

运算符	语法	描述
IS NULL	a is null	如果操作符为NUII, 结果为真
IS NOT NULL	a is not null	如果操作符不为null，结果为真
BETWEEN	a between b and c	若a在b和c之间，则结果为真
LIKE	a like b	SQL匹配，如果a能够匹配到b， 则结果为真
IN	a in (a1,a2,a3,......)	假设a在a1,或者a2.... 其中的某一个值中，结果为真

LIKE

--查询姓刘的同学
--like结合  %(代表0到任意个字符)   _(一个字符)
SELECT `StudentNo`,`StudentName` FROM `student` 
WHERE StudentName LIKE '刘%'

查询姓“刘”后面只有一个字的，就只有一个下划线

SELECT `StudentNo`,`StudentName` FROM `student` 
WHERE StudentName LIKE '刘_'

查询姓“刘”后面有两个字的，就有两个下划线

SELECT `StudentNo`,`StudentName` FROM `student` 
WHERE StudentName LIKE '刘__'

查询名字中间有“上官”的同学

SELECT `StudentNo`,`StudentName` FROM `student` 
WHERE StudentName LIKE '%上官%'

IN（具体的一个或多个值里面）

--查询1001, 1002, 1003号学员
SELECT `StudentNo`,`StudentName` FROM `student` 
WHERE StudentNo IN (1001,1002,1003);

--查询在安徽和河南洛阳的学生
SELECT `StudentNo`,`StudentName` FROM `student` 
WHERE `Address` IN ('安徽','河南洛阳');

Null 和NotNull

--查询地址为空的学生null或者''
SELECT `StudentNo`,`StudentName` FROM `student` 
WHERE `Address` ='' OR `Address` IS NULL

通过上面的图片可以看到有一个出生日期为null的同学

--查询有出生日期的同学	不为空
SELECT `StudentNo`,`StudentName` FROM `student` 
WHERE `BornDate` IS NOT NULL	

--查询没有出生日期的同学	为空
SELECT `StudentNo`,`StudentName` FROM `student` 
WHERE `BornDate` IS NULL

4.6、联表查询

JOIN 对比

4.6.1、Inner JOIN （内连接查询）

--查询参加了考试的同学(学号，姓名，科目编号，分数)
/* 思路
    1.分析需求，分析查询的字段来自哪些表，(连接查询)
    2.确定使用哪种连接查询? 7种
    确定交叉点(这两个表中哪个数据是相同的)
    判断的条件:学生表 的中studentNo =成绩表studentNo
*/
--join (连接的表) on (判断的条件)	连接查询
--where			等值查询
SELECT s.studentNO,studentName,SubjectNo,StudentResult
FROM student AS s
INNER JOIN result AS r
WHERE s.studentNO = r.studentNO;

4.6.2、Right JOIN （右连接查询）

--查询参加了考试的同学(学号，姓名，科目编号，分数)
/* 思路
    1.分析需求，分析查询的字段来自哪些表，(连接查询)
    2.确定使用哪种连接查询? 7种
    确定交叉点(这两个表中哪个数据是相同的)
    判断的条件:学生表 的中studentNo =成绩表studentNo
*/
--别名的AS可写可不写，可以用where也可以用on，但是我们使用join的时候最好带着on，因为它俩是一对的。
--where后面是附加的判断条件。
--左表是student表，右表是result表，右连接是以右表为基准查询。
SELECT s.studentNO,studentName,SubjectNo,StudentResult
FROM student s		
RIGHT JOIN result r
ON s.studentNO = r.studentNO;

4.6.3、Left JOIN （左连接查询）

--查询参加了考试的同学(学号，姓名，科目编号，分数)
/* 思路
    1.分析需求，分析查询的字段来自哪些表，(连接查询)
    2.确定使用哪种连接查询? 7种
    确定交叉点(这两个表中哪个数据是相同的)
    判断的条件:学生表 的中studentNo =成绩表studentNo
*/
--别名的AS可写可不写，可以用where也可以用on
--左表是student表，右表是result表，左连接是以左表为基准查询。
SELECT s.studentNO,studentName,SubjectNo,StudentResult
FROM student s		
LEFT JOIN result r
ON s.studentNO = r.studentNO;

这时候发现一个问题，我们通过内连接和外连接查询没有出现问题，但是通过左连接查询出现成绩为null的结果

分析原因：

操作	描述
Inner JOIN	如果表中至少有一个匹配，就返回行
Right JOIN	会从右表中返回所有的值，即使左表中没有匹配
Left JOIN	会从左表中返回所有的值，即使右表中没有匹配

可以看出左连接查询会返回左表所有的值

--给左连接查询加一条where条件，再试一次
SELECT s.studentNO,studentName,SubjectNo,StudentResult
FROM student s		
LEFT JOIN result r
ON s.studentNO = r.studentNO
WHERE StudentResult IS NOT NULL;

--查询缺考的同学(学号，姓名，科目编号，分数)
SELECT s.studentNO,studentName,SubjectNo,StudentResult
FROM student s		
LEFT JOIN result r
ON s.studentNO = r.studentNO
WHERE StudentResult IS NULL;

升级难度，下面是三表查询

--思考题(查询了参加考试（就是有成绩）的同学信息：学号，学生姓名，科目名，分数)
/* 思路
    1.分析需求，分析查询的字段来自哪些表，student、result、subject(连接查询)
    2.确定使用哪种连接查询? 7种
    确定交叉点(这两个表中哪个数据是相同的)
    判断的条件:学生表 的中studentNo =成绩表studentNo
*/
SELECT s.studentNo,studentName,SubjectName,StudentResult
FROM student s
RIGHT JOIN result r
ON r.studentNo = s.studentNo
INNER JOIN `subject` sub
ON r.SubjectNo = sub.SubjectNo;

解题思路：

我要查询哪些数据	select
从那几个表中查	FROM表	XXX Join 连接的表	on	交叉条件
假设存在一种多张表查询，慢慢来，先查询两张表然后再慢慢增加

4.7、自连接

自己的表和自己的表连接，核心：一张表拆为两张一样的表即可

用一个例子解释自连接

父类表

categoryid(自己的id)	categoryname
2	信息技术
3	软件开发
5	美术设计

子类表

pid(父id)	categoryid(自己的id)	categoryname
3	4	数据库
2	8	办公信息
3	6	web开发
5	7	ps技术

操作：查询父类对应的子类关系

父类	子类
信息技术	办公信息
软件开发	数据库
软件开发	web开发
美术设计	ps技术

那么现在我们需要查询这样一种父子类的表

--查询父子信息，把一张表看为两个一模一样的表
SELECT a.`categoryName` AS '父栏目',b.`categoryName` AS '子栏目'
FROM `category` AS a,`category` AS b
WHERE a.`categoryid` = b.`pid`;

4.8、分页和排序

• 分页：limit
• 排序：order by
  • 升序：ASC
  • 降序：DESC

降序：DESC

--查询的结果根据成绩	降序排序
--ORDER BY	通过那个字段排序，怎么排
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 DESC;

升序：ASC

--查询的结果根据成绩	降序排序
--ORDER BY	通过那个字段排序，怎么排
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

为什么要分页?
缓解数据库压力，给人的体验更好，瀑布流/分页

--语法：limit	起始值，页面的大小
--数据从0开始，和数组下标有点类似
第一页	limit 0,5							(1-1)*5,5
第二页 limit 5,5							(2-1)*5,5
第三页	limit 10,5							(3-1)*5,5
......
第N页	 limit (n-1)*pageSize,pageSize		 (n-1)*5,5
--pageSize：页面大小
--(n-1)*pageSize：起始值
--n：当前页
--总页数：数据总数/页面大小

每页只显示五条数据

--分页，每页只显示两条数据
--语法：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,2;

练习：

--思考:
--查询 “数据库结构-1” 课程成绩排名前三的学生，并且分数要大于80的学生信息(学号，姓名，课程名称，分数)
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' AND `StudentResult`>=80
ORDER BY StudentResult DESC
LIMIT 0,3;

4.9、子查询

where (这个值是计算出来的)

例如：WHERE subjectName='数据库结构-1' AND StudentResult>=80，这个语句的80是写上去的80，而不是计算出来的，如果让这个80用一个类似变量替代，那么就可以在里面嵌套一个子查询。

子查询的本质：在where语句中嵌套一个子查询语句

--查询数据库结构-1的所有考试结果(学号, 科目编号，成绩) ,降序排列
--方式一：使用连接查询
SELECT `studentNo`,r.`SubjectNo`,`StudentResult`
FROM `result` r
INNER JOIN `subject` sub
ON r.`SubjectNo` = sub.`SubjectNo`
WHERE `subjectName`='数据库结构-1'
ORDER BY StudentResult DESC

--查询数据库结构-1的所有考试结果(学号, 科目编号，成绩) ,降序排列
--方式一：使用子查询
SELECT `studentNo`,`SubjectNo`,`StudentResult`
FROM `result` r
WHERE `SubjectNo`=(
    SELECT `SubjectNo` FROM subject 
    WHERE `SubjectName` ='数据库结构-1'
)
ORDER BY StudentResult DESC;

--分解：
SELECT `studentNo`,`SubjectNo`,`StudentResult`
FROM `result` r
WHERE `SubjectNo`=?
----因为不知道这个?是多少，所以要查询数据库结构-1的科目编号是多少
SELECT `SubjectNo` FROM subject WHERE `SubjectName` ='数据库结构-1'
--然后用上面查询科目编号的语句替换掉那个问号，并且用英文状态下的括号包裹起来。

练习

--分数不小于80分的学生的学号和姓名
SELECT DISTINCT s.`StudentNo`,`StudentName`
FROM student s
INNER JOIN result r
ON r.StudentNo = s.StudentNo
WHERE `StudentResult`>=80

--分数不小于80分的学生的学号和姓名
--在这个基础上,增加一个科目"高等数学-2"，
--但是高等数学-2这个名称不在student表也不在result表，所以就涉及到底三张表，即查询高等数学-2的编号
--方法一：用子查询
SELECT DISTINCT s.`StudentNo`,`StudentName`
FROM student s
INNER JOIN result r
ON r.StudentNo = s.StudentNo
WHERE `StudentResult`>=80 AND `SubjectNo`=(
    SELECT `SubjectNo` FROM subject 
    WHERE `SubjectName` ='高等数学-2'
)
--整理一下题目：查询课程为 高等数学-2 且分数不小于80 的同学的学号和姓名
--方法二：联表查询
SELECT DISTINCT s.`StudentNo`,`StudentName`
FROM student s
INNER JOIN result r
ON r.StudentNo = s.StudentNo
INNER JOIN `subject` sub
ON r.`SubjectNo` = sub.`SubjectNo`
WHERE `subjectName`='高等数学-2' AND `StudentResult`>=80
--方法三：用IN
SELECT StudentNo, StudentName FROM student WHERE StudentNo IN (
	SELECT StudentNo FROM result WHERE StudentResult>80 AND SubjectNo = (
		SELECT SubjectNo FROM `subject` WHERE `SubjectName`='高等数学-2'
	)
) 

方法一：用子查询

方法二：联表查询

方法三：用IN

select小结

看清这这张图片里面的条件顺序

5、MySQL函数

5.1、常用函数

数学运算

--数学运算
--绝对值
SELECT ABS(-8)				--8
--向上取整
SELECT SEILING(9.4)			--10
--向下取整
SELECT FLOOR(9.4)			--9
--随机数（0~1）
SELECT RAND()
--判断一个参数的符号，0返回0，负数返回-1，正数返回1
SELECT SIGN(-10)			---1

--字符串函数
--字符串长度
SELECT CHAR_LENGTH('即使再小的帆也能远航')		--10
--拼接字符串
SELECT CONCAT('你','好','，','世','界','！')		--你好，世界！
--替换字符串（下标从1开始）
SELECT INSERT('你好，中国',4,2,'世界')				--你好，世界
--转小写
SELECT LOWER('HelloWord')						--helloword
--转大写
SELECT UPPER('HelloWord')						--HELLOWORD
--查找某个字符在字符串中第一次出现的位置
SELECT INSTR('HelloWord','e')					--2
--替换出现的指定字符串
SELECT REPLACE('你好，世界！','世界','地球')			--你好，地球！
--返回指定的子字符串（下标从1开始）(原字符串,截取的位置,截取的长度)
SELECT SUBSTR('你好，世界！',2,3)					--好，世
--反转字符串
SELECT REVERSE('你好，世界！')					--！界世，好你

--查询姓“周”的同学，并且把姓改为“邹”
SELECT REPLACE(studentname,'周','邹') FROM student 
WHERE studentname LIKE '周%';
--但是实际的数据的姓名是没有改变的

日期

--时间和日期函数（记住）
--获取当前日期
SELECT CURRENT_DATE()				--2022-06-01
--获取当前日期
SELECT CURDATE()					--2022-06-01
--获取当前时间
SELECT NOW()						--2022-06-01 22:05:43
--获取本地时间
SELECT NOW()						--2022-06-01 22:07:20
--获取系统时间
SELECT SYSDATE()					--2022-06-01 22:08:46
--获取年，月，日，时，分，秒
SELECT YEAR(NOW())
SELECT MONTH(NOW())
SELECT DAY(NOW())
SELECT HOUR(NOW())
SELECT MINUTE(NOW())
SELECT SECOND(NOW())

系统

--系统
--获取当前数据库登录的用户
SELECT SYSTEM_USER()
--获取当前数据库登录的用户
SELECT USER()
--获取当前数据库的版本
SELECT VERSION()

5.2、聚合函数(常用)

函数名称	描述
COUNT()	计数
SUM()	求和
AVG()	平均值
MAX()	最大值
MIN()	最小值

COUNT()

SELECT COUNT(studentname) AS 学生人数 FROM student;

tips

SUM()

SELECT SUM(`StudentResult`) AS 分数总和 FROM result;

AVG()

SELECT AVG(`StudentResult`) AS 平均分 FROM result;

MAX()

SELECT MAX(`StudentResult`) AS 最高分 FROM result;

MIN()

SELECT MIN(`StudentResult`) AS 最低分 FROM result;

练习

--查询不同课程的平均分，最高分，最低分
--核心：(根据不同的课程分组)
SELECT SubjectName,AVG(StudentResult),MAX(StudentResult),MIN(StudentResult)
FROM result r
INNER JOIN `subject` sub
ON r.`SubjectNo` = sub.`SubjectNo`
GROUP BY r.`SubjectNo`		--通过什么字段来分组

--查询不同课程的平均分，最高分，最低分，平均分大于80
--核心：(根据不同的课程分组)
SELECT SubjectName,AVG(StudentResult) AS 平均分,MAX(StudentResult),MIN(StudentResult)
FROM result r
INNER JOIN `subject` sub
ON r.`SubjectNo` = sub.`SubjectNo`
GROUP BY r.`SubjectNo`		--通过什么字段来分组
HAVING 平均分>80				--HAVING用于分组过滤后的条件判断

5.3、数据库级别的MD5加密(扩展)

什么是MD5?

主要增强算法复杂度和不可逆性

MD5不可逆，具体的值的md5是一样的

MD5破解网站的原理，背后有一个字典，MD5加密后的值 加密前的值

加密步骤

未加密时

-- MD5加密数据库每个用户的密码
-- 全部加密
UPDATE testmd5 SET `pwd`=MD5(pwd);

但是我们不应该在数据插入后对密码进行加密，而是在插入数据时对密码进行加密。

-- 插入的时候加密
INSERT INTO `testmd5` VALUES(8,'许十',MD5('123456'));

-- 如何校验：将用户传递进来的密码，进行md5加密，然后比对加密后的值
SELECT * FROM testmd5 WHERE `name` ='孙七' AND pwd=MD5('123456');

总结MD5：

所以在使用MD5加密密码的时候，应该是在插入用户数据时，一块把密码加密，数据库里面存放的就是加密后的一长段字符。进行用户密码校验的时候把用户输入的密码（明文密码）进行加密，得到一个加密后的一长段字符，把这个一长段字符和数据库对应的用户密码（一长段字符）进行比对即可。

6、事务

6.1、什么是事务

要么都成功，要么都失败

————————

1、SQL执行 A给B转账 A：1000 ---> 200 B：200
2、SQL执行 B收到A的钱 A：800 ---> B：400

————————

将一组SQL放在一个批次中去执行~

事务原则: ACID 原则（原子性，一致性，隔离性，持久性）

  ACID，是指数据库管理系统（DBMS）在写入或更新资料的过程中，为保证事务（transaction）是正确可靠的，所必须具备的四个特性：原子性（atomicity，或称不可分割性）、一致性（consistency）、隔离性（isolation，又称独立性）、持久性（durability）。

• 原子性（atomicity）
  • 要么都成功，要么都失败
• 一致性（consistency）
  • 事务前后的数据完整性要保证一致
• 隔离性（isolation）
  • 事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。
• 持久性（durability）
  • 事务一旦提交则不可逆，被持久化到数据库中！

隔离所导致的一些问题

• 脏读
  • 指一个事务读取了另外一个事务未提交的数据。
• 不可重复读
  • 在一个事务内读取表中的某一行数据，多次读取结果不同。(这个不定是错误，只是某些场合不对)
• 虚读(幻读)
  • 是指在一个事务内读取到了别的事务插入的数据，导致前后读取不一致。(一般是行影响，多了一行)

6.2、执行事务的原理

-- mysql是默认开启事务自动提交的
SET autocommit = 0   /*关闭*/
SET autocommit = 1   /*开启（MySQL默认的设置）*/

-- 手动处理事务
SET autocommit = 0		-- 关闭自动提交事务
-- 事务开启
START TRANSACTION	-- 标记一个事务的开始，从这个之后的sql都在同一个事务内
-- 提交：持久化（成功就提交）
COMMIT
-- 回滚：回到原来的样子（失败就回滚）
ROOLBACK
-- 事务结束
SET autocommit = 1		-- 开启自动提交事务

-- 下面作了解
SAVEPOINT	-- 保存点，如果事务太长了，就可以设置一个事务的保存点，（休息一下）
ROOLBACK TO SAVEPOINT	-- 回滚到保存点（类似单机游戏的保存之后的读档）
RELEASE SAVEPOINT		-- 撤销保存点（类似单机游戏删除保存记录），一个事务可以有多个保存点

事务的执行过程

6.3、模拟转账

-- 创建一张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
-- 初始状态下，A有2000，B有10000
INSERT INTO account(`name`,`money`) VALUES ('A',2000.00);
INSERT INTO account(`name`,`money`) VALUES ('B',10000.00);

-- 模拟转账：事务
SET autocommit = 0;		-- 关闭自动提交事务
START TRANSACTION;		-- 开启一个事务，从这个之后的sql都在同一个事务内

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;		-- 事务结束，开启自动提交事务

关闭自动提交事务

开启一个事务

A减500,B加500

回滚事务

操作失败就回滚

提交事务

操作成功就提交

事务结束

7、索引

MySQL官方对索引的定义为：索引(Index) 是帮助MySQL高效获取数据的数据结构。

提取句子主干，就可以得到索引的本质：索引是数据结构。

7.1、索引的分类

• 主键索引（PRIMATY KEY）
  • 唯一标识，主键不可重复，只能有一个列作为主键（主属性）
• 唯一索引（UNIQUE KEY）
  • 避免重复的列出现，唯一索引可以重复，多个列都可以标识为唯一索引（非主属性）
• 常规索引（KEY或者INDEX）
  • 默认的，index或者key关键字来设置
• 全文索引（FullText）
  • 在特定的数据库引|擎下才有，MyISAM
  • 快速定位数据

-- 索引的使用
-- 1、在创建表的时候给字段增加索引
-- 2、创建完毕后，增加索引
-- 显示所有的索引信息
SHOW INDEX FROM student
-- 增加一个全文索引	(索引名) 列名
ALTER TABLE `student` ADD FULLTEXT INDEX `studentName`(`studentName`);

-- EXPLAIN	分析SQL执行的状况
EXPLAIN SELECT * FROM student;	--非全文索引

EXPLAIN SELECT * FROM student WHERE MATCH(studentName) AGAINST('刘');

7.2、测试索引

tips：自动插入成100条数据

-- 插入100万条数据
-- 写函数之前必须要写DELIMITER $$，这是一个标志
DELIMITER $$
CREATE FUNCTION mock_data()
RETURNS INT DETERMINISTIC
BEGIN
	DECLARE num INT DEFAULT 1000000;
	DECLARE i INT DEFAULT 0;
	WHILE i<num DO
		INSERT INTO app_user(`name`,`email`,`phone`,`gender`,`password`,`age`)
		VALUES(CONCAT('用户',i),'19224305@qq.com',CONCAT('18',FLOOR(RAND()*999999999)),FLOOR(RAND()*2),UUID(),FLOOR(RAND()*100));
		SET i=i+1;
	END WHILE;
	RETURN i;
END;

SELECT mock_data(); -- 执行此函数 生成一百万条数据

DROP FUNCTION mock_data;	-- 删除自定义函数

TRUNCATE `app_user`;	-- 清空表数据

-- 插入SQL的语句
INSERT INTO app_user(`name`,`email`,`phone`,`gender`,`password`,`age`)
VALUES(CONCAT('用户1'),'19224305@qq.com',CONCAT('18',FLOOR(RAND()*999999999)),FLOOR(RAND()*2),UUID(),FLOOR(RAND()*100));

测试

SELECT * FROM app_user WHERE `name`='用户9999';	---耗时0.994sec
-- id_表名_字段名
-- CREATE INDEX 索引名 on 表(字段)			-- 创建索引
CREATE INDEX id_app_user_name ON app_user(`name`);
SELECT * FROM app_user WHERE `name`='用户9999';	---耗时0.001sec

索引在小数据量的时候，用户不大，但是在大数据的时候，区别十分明显~

7.3、索引原则

• 索引不是越多越好
• 不要对经常变动数据加索引
• 小数据量的表不需要加索引
• 索引一般加在常用来查询的字段上！

索引的数据结构

Hash 类型的索引

Btree：InnoDB的默认数据结构

阅读MySQL索弓背后的数据结构及算法原理：http://blog.codinglabs.org/articles/theory-of-mysql-index.html

8、权限管理和数据库备份

8.1、用户管理

SQL yog可视化管理

SQL命令

用户表: mysql.user

-- 创建用户：CREATE USER 用户名 IDENTIFIED BY '密码'
CREATE USER dahai IDENTIFIED BY '123456'
-- 修改密码	（修改当前用户密码）
SET PASSWORD = PASSWORD('111111')
-- 修改密码	（修改指定用户密码）
SET PASSWORD FOR dahai = PASSWORD('111111')
-- 重命名：RENAME USER 原来的用户名 TO 新的用户名
RENAME USER dahai TO dahai2
-- 用户授权，ALL PRIVILEGES全部的权限，库.表
-- ALL PRIVILEGES 除了给别人授权，其他都能够干
GRANT ALL PRIVILEGES ON *.* TO dahai2
-- 查看权限
-- 查看指定用户的权限
SHOW GRANTS FOR dahai2
-- 查看管理员的权限
SHOW GRANTS FOR root@localhost
-- （root权限本质：GRANT ALL PRIVILEGES ON *.* TO `root@localhost` WITH GRANT OPTION）
-- 撤销权限 REVOKE哪些权限，在哪个库撤销，给谁撤销
REVOKE ALL PRIVILEGES ON *.* FROM dahai2
-- 删除用户
DROP USER dahai2

8.2、MySQL备份

为什么要备份：

• 保证重要的数据不丢失
• 数据转移A--->B

MySQL数据库备份的方式

• 直接拷贝物理文件

• 在SQLYog可视化界面备份数据库文件

• 使用命令行导出 mysqldump 命令行使用

  # win+R（管理员）输入cmd命令，
  # 然后输入 mysqldump -h主机 -u用户名 -p密码 数据库 表名 >要备份的路径地址
  # 备份多张表
  # 输入 mysqldump -h主机 -u用户名 -p密码 数据库 表名1 表名2 表名3 表名4 >要备份的路径地址
  mysqldump -hlocalhost -uroot -p123456 school student >D:/a.sql
  

导入数据库

9、规范数据库设计

9.1、为什么需要设计

当数据库比较复杂的时候，我们就需要设计

糟糕的数据库设计

• 数据冗余，浪费空间
• 数据插入和删除都会比较麻烦/异常【屏蔽使用物理外键】
• 程序的性能差

良好的数据库设计

• 节省内存空间
• 保证数据库的完整性
• 方便我们开发系统

软件开发中，关于数据库的设计

• 分析需求：分析业务和需求处理的数据库的需求
• 概要设计：设计关系图 E-R 图

设计数据库的步骤：（个人博客）

• 收信息，分析需求
  • 用户表（用户登录注销，用户的个人信息，写博客，创建分类）
  • 分类表（文章分类，谁创建的）
  • 文章表（文章的信息）
  • 评论表（评论的信息）
  • 友链表（友链信息）
  • 自定义表（系统信息，某个关键的字，或者一些主字段）key：value
  • 说说表（发表心情的表）
• 标识实体类（把需求落地到每个字段）
• 标识实体之间的关系
  • 写博客：user--->blog
  • 创建分类：user--->category
  • 关注：user--->flow_user
  • 友链：links
  • 评论：user--->user ,user--->blog

用户表

分类表

文章表

评论表

友链表

9.2、三大范式

为什么需要数据规范化?

• 信息重复
• 更新异常
• 插入异常
  • 无法正常显示信息
• 删除异常
  • 丢失有效的信息

三大范式

第一范式（1NF）

原子性：保证每一列不可再分

第二范式（2NF）

前提：满足第一范式

每张表只描述一件事情

第三范式（3NF）

前提：满足第一范式和第二范式

第三范式需要确保数据表中的每一列数据都和主键直接相关，而不能间接相关。

(规范数据库的设计)

规范性和性能的问题

关联查询的表不得超过三张表

• 考虑商业化的需求和目标，(成本， 用户体验! )数据库的性能更加重要
• 在规范性能的问题的时候，需要适当的考虑一下 规范性！
• 故意给某些表增加一些冗余的字段。(从多表查询中变为单表查询)
• 故意增加一些计算列（从大数据量降低为小数据量的查询：索引）

10、JDBC（重点）

10.1、数据库驱动

驱动：声卡、显卡、数据库

我们的程序会通过数据库驱动，和数据库打交道！

10.2、JDBC

SUN公司为了简化开发人员的（对数据库的统一）操作，提供了一个（Java操作数据库的）规范，俗称 JDBC

这些规范的实现由具体的厂商去做~

对于开发人员来说，我们只需要掌握JDBC接口的操作即可

java.sql

javax.sql

还需要导入一个数据库驱动包，mysql-connector-java

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、创建一个普通项目

2、导入数据库驱动

复制jar包

然后右键lib目录

Add as Library后

3、编写测试代码

JdbcFirstDemo类

package com.dh.lesson01;

import com.mysql.cj.jdbc.Driver;

import java.sql.*;

//我的第一个JDBC程序
public class JdbcFirstDemo {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.加载驱动
        Class.forName("com.mysql.cj.jdbc.Driver");  //固定写法，加载驱动

        //2.用户信息和url
        String url = "jdbc:mysql://localhost:3306/jdbcStudy?useSSL=true&useUnicode=true&characterEncoding=UTF-8";
        String username = "root";
        String password ="123456";
        //3.连接成功，返回数据库对象， Connection代表数据库
        Connection connection = DriverManager.getConnection(url, username, password);

        //4.执行SQL的对象    Statement执行SQL语句的（Statement相对于SQLYog里面的绿色执行按钮）
        Statement statement = connection.createStatement();

        //5.执行SQL的对象去执行SQL，可能存在结果，查看返回的结果
        String sql = "SELECT * FROM users";

        //查询用executeQuery()
        //增删改用executeUpdate()
        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("pwd="+ resultSet.getObject("PASSWORD"));
            System.out.println("email="+ resultSet.getObject("email"));
            System.out.println("birthday="+ resultSet.getObject("birthday"));
            System.out.println();
        }
        //6.释放连接
        resultSet.close();
        statement.close();
        connection.close();
    }
}

运行结果

//运行结果
id=1
name=zhangsan
pwd=123456
email=zs@sina.com
birthday=1980-12-04

id=2
name=lisi
pwd=123456
email=lisi@sina.com
birthday=1981-12-04

id=3
name=wangwu
pwd=123456
email=wangwu@sina.com
birthday=1979-12-04

4、步骤总结：

1、加载驱动

2、用户信息和url

3、连接数据库 DriverManager

4、创建执行SQL的对象 Statement

5、执行SQL的对象去执行SQL，获得返回的结果集

6、释放连接

DriverManager

//DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver());
//等价于下面这条，推荐写下面这种
Class.forName("com.mysql.cj.jdbc.Driver"); // 固定写法，加载驱动
Connection connection = DriverManager.getConnection(url, username, password);
//connection代表数据库
//数据库设置自动提交
//事务提交
//事务回滚
connection.commit();
connection.rollback();
connection.setAutoCommit();

URL

String url = "jdbc:mysql://localhost:3306/jdbcStudy?useSSL=true&useUnicode=true&characterEncoding=UTF-8";
// MySQL默认是3306端口号
//jdbc:mysql://主机地址:端口号/数据库名?参数1&参数2&参数3
//oracle默认是1521端口号
//jdbc:oracle:thint:@localhost:1521:sid

Statement 执行SQL的对象，PrepareStatement 执行SQL的对象

String sql = "SELECT * FROM users";	//编写SQL

//statement.executeQuery(sql)	//查询操作返回ResultSet
//statement.execute(sql)	//执行任何SQL
//statement.executeUpdate(sql)	//更新、插入、删除。都是用这个，返回一个受影响的行数

ResultSet 查询的结果集，封装了所有的查询结果

获得指定的数据类型

resultSet.getObject();  //在不知道列类型的情况下使用
//如果知道列的类型就使用指定的类型
resultSet.getString();
resultSet.getInt();
resultSet.getFloat();
resultSet.getDouble();
resultSet.getDate();
...

遍历

resultSet.beforeFirst(); //移动到最前面
resultSet.afterLast(); 	//移动到最后面
resultSet.next();		//移动到下一个
resultSet.previous();	//移动到前一行
resultSet.absolute(row);	//移动到指定行

释放资源

//释放连接
resultSet.close();
statement.close();
connection.close();		//特别耗费资源，用完要关闭

10.4、statement对象

Jdbc中的statement对象用于向数据库发送SQL语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可。
Statement对象的executeUpdate方法，用于向数据库发送增、删、改的sql语句，executeUpdate执行完后， 将会返回一个整数（即增删改语句导致了数据库几行数据发生了变化）。
Statement.executeQuery方法用于向数据库发送查询语句，executeQuery方法返回代表查询结果的ResultSet对象。

CRUD操作-create

使用executeUpdate(String sq|)方法完成数据添加操作，示例操作:

Statement st = conn.createStatement();
String sql = "insert into user(... )values(... .)";
int num = st.executeUpdate(sql);
if (num>0){
	System.out.println("插入成功! ! !");
}

CRUD操作-delete

使用executeUpdate(String sql)方法完成数据删除操作，示例操作:

Statement st = conn.createStatement();
String sql = "delete from user where id=1";
int num = st.executeUpdate(sql);
if (num>0){
	System.out.println("删除成功! ! !");
}

CRUD操作-update

使用executeUpdate(String sql)方法完成数据修改（更新）操作，示例操作:

Statement st = conn.createStatement();
string sql = "update user set name = where name =''";
int num = st.executeUpdate(sql);
if (num>0){
	System.out.println("修改成功! ! !");
}

CRUD操作-read

使用executeQuery(String sql)方法完成数据查询操作，示例操作:

Statement st = conn.createStatement();
String sq1 = "select * from user where id=1";
ResultSet rs = st.executeQuery(sql);
while(rs.next()){
	//根据获取列的数据类型，分别调用rs的相应方法映射到java对象中
}

代码演示

db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8
username=root
password=123456

JdbcUtils类

package com.dh.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 resourceAsStream = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
            Properties properties = new Properties();
            properties.load(resourceAsStream);
            driver = properties.getProperty("driver");
            url = properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");

            //1.加载驱动，驱动只用加载一次
            Class.forName(driver);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //获取连接
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }

    //释放连接资源
    public static void release(Connection connection, Statement statement, ResultSet resultSet){
        //关闭resultSet
        if (resultSet!=null){
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        //关闭statement
        if (statement!=null){
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        //关闭connection
        if (connection!=null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }
}

**TestInsert类 ** （增加）

package com.dh.lesson02;

import com.dh.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 connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            connection = JdbcUtils.getConnection(); //获取数据库连接
            statement = connection.createStatement();   //获得SQL的执行对象
            String sql = "INSERT INTO users(`id`, `NAME`,`PASSWORD`,`email`, `birthday`)" +
                    "VALUES(4,'mike','123456','24736743@qq.com','1999-09-09')";
            int i = statement.executeUpdate(sql);
            if (i > 0){
                System.out.println("插入成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(connection,statement,resultSet);
        }
    }
}

TestDelete类 （删除）

package com.dh.lesson02;

import com.dh.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 connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            connection = JdbcUtils.getConnection(); //获取数据库连接
            statement = connection.createStatement();   //获得SQL的执行对象
            String sql = "DELETE FROM users WHERE id = 4";
            int i = statement.executeUpdate(sql);
            if (i > 0){
                System.out.println("删除成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(connection,statement,resultSet);
        }
    }
}

TestUpdate类 （修改）

package com.dh.lesson02;

import com.dh.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 connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            connection = JdbcUtils.getConnection(); //获取数据库连接
            statement = connection.createStatement();   //获得SQL的执行对象
            String sql = "UPDATE users SET `NAME` = '张三丰',`email` = '10086@163.com' WHERE `id` = 1";
            int i = statement.executeUpdate(sql);
            if (i > 0){
                System.out.println("修改成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(connection,statement,resultSet);
        }
    }
}

TestSelect类 （查询）

package com.dh.lesson02;

import com.dh.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 connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            connection = JdbcUtils.getConnection(); //获取数据库连接
            statement = connection.createStatement();   //获得SQL的执行对象
            String sql = "select * from users where id = 1";
            resultSet = statement.executeQuery(sql);    //查询完毕会返回一个结果集

            while (resultSet.next()){
                System.out.println("id="+ resultSet.getInt("id"));
                System.out.println("name="+ resultSet.getString("NAME"));
                System.out.println("pwd="+ resultSet.getString("PASSWORD"));
                System.out.println("email="+ resultSet.getString("email"));
                System.out.println("birthday="+ resultSet.getDate("birthday"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(connection,statement,resultSet);
        }
    }
}

SQL注入问题

SQL存在漏洞，会被攻击导致数据泄露，SQL会被拼接 or

package com.dh.lesson02;

import com.dh.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class SqlZhuRu {
    public static void main(String[] args) {
        login("wangwu","123456");

    }
    //登录业务
    public static void login(String username,String password){
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            connection = JdbcUtils.getConnection(); //获取数据库连接
            statement = connection.createStatement();   //获得SQL的执行对象
            String sql = "select * from users where `NAME` = '"+ username +"' AND `password` = '"+ password +"'";
            resultSet = statement.executeQuery(sql);    //查询完毕会返回一个结果集

            while (resultSet.next()){
                System.out.println("id="+ resultSet.getInt("id"));
                System.out.println("name="+ resultSet.getString("NAME"));
                System.out.println("pwd="+ resultSet.getString("PASSWORD"));
                System.out.println("email="+ resultSet.getString("email"));
                System.out.println("birthday="+ resultSet.getDate("birthday"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(connection,statement,resultSet);
        }
    }
}
/*输出结果：
    id=3
    name=wangwu
    pwd=123456
    email=wangwu@sina.com
    birthday=1979-12-04
*/

可以看出是可以查出数据的，但是上面的代码是有问题的，看下面操作

package com.dh.lesson02;

import com.dh.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class SqlZhuRu {
    public static void main(String[] args) {
        //正常登录
        //login("wangwu","123456");
        //骚操作登录
        login(" 'or '1=1"," 'or '1=1");
    }
    //登录业务
}

可以看到全部的数据都被返回了。这就是SQL注入

//正常拼接
//String sql = "select * from users where `NAME` = 'wangwu' AND `password`='123456'";
//骚操作拼接
 //String sql = "select * from users where `NAME` = ''or '1=1' AND `password` = ''or '1=1'";
//可以看出骚操作后面的`NAME`拼接的是：一个空字符Or'1=1'，这个条件在计算机里面是永远成立的。密码也是这样拼接的，很不安全。

PrepareStatement可以有效的防止SQL注入，因为对比Statement，PrepareStatement是安全的。

10.5、PrepareStatement对象

PrepareStatement（表示有准备的）

PreparedStatement可以防止SQL注入。效率更好！

1、新增

package com.dh.lesson03;

import com.dh.lesson02.utils.JdbcUtils;

import java.sql.*;
import java.util.Calendar;
import java.util.Date;

public class TestInsert {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        try {
            connection = JdbcUtils.getConnection(); //获取数据库连接
            //区别来了
            //statement = connection.createStatement();   //获得SQL的执行对象
            //使用?占位符代替参数
            String sql = "INSERT INTO users(`id`, `NAME`,`PASSWORD`,`email`, `birthday`) VALUES(?,?,?,?,?)";
            statement = connection.prepareStatement(sql); //预编译的SQL，先写SQL，但是不执行
            //手动给参数赋值
            statement.setInt(1,4);          //id
            statement.setString(2,"彭于晏");
            statement.setString(3,"123456");
            statement.setString(4,"9999@163.com");

            //注意点:  sql.Date            数据库
            //         util.Date           Java     new Date().getTime()获得时间戳
            //statement.setDate(5,new java.sql.Date(new Date().getTime()));//用当前时间作为生日
            //指定时间作为生日
            Calendar calendar = Calendar.getInstance();
            //注意这里的月份要减去1，外国人那边的月份设定
            calendar.set(1999,12-1,31);
            //statement.setDate(5,new java.sql.Date(calendar.getTimeInMillis()));
            //注意new java.sql.Date(这里放的是util.Date类)
            statement.setDate(5,new java.sql.Date(calendar.getTime().getTime()));

            //执行
            int i = statement.executeUpdate();
            if (i > 0){
                System.out.println("插入成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(connection,statement,resultSet);
        }
    }
}

2、删除

package com.dh.lesson03;

import com.dh.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Calendar;

public class TestDelete {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        try {
            connection = JdbcUtils.getConnection(); //获取数据库连接
            //区别来了
            //statement = connection.createStatement();   //获得SQL的执行对象
            //使用?占位符代替参数
            String sql = "delete from users where id=?";
            statement = connection.prepareStatement(sql); //预编译的SQL，先写SQL，但是不执行
            //手动给参数赋值
            statement.setInt(1,4);
            //执行
            int i = statement.executeUpdate();
            if (i > 0){
                System.out.println("删除成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(connection,statement,resultSet);
        }
    }
}

3、更新

package com.dh.lesson03;

import com.dh.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class TestUpdate {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        try {
            connection = JdbcUtils.getConnection(); //获取数据库连接
            String sql = "update users set `NAME`=? where id=? ;";
            statement = connection.prepareStatement(sql); //预编译的SQL，先写SQL，但是不执行
            //手动给参数赋值
            statement.setString(1,"上官宝");
            statement.setInt(2,1);
            //执行
            int i = statement.executeUpdate();
            if (i > 0){
                System.out.println("更新成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(connection,statement,resultSet);
        }
    }
}

4、查询

package com.dh.lesson03;

import com.dh.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 connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        try {
            connection = JdbcUtils.getConnection();         //连接数据库
            String sql = "select * from users where id=?";  //编写SQL
            statement = connection.prepareStatement(sql);   //预编译SQL语句
            statement.setInt(1,1);          //传递参数
            resultSet = statement.executeQuery();           //执行

            while (resultSet.next()){
                System.out.println("id="+ resultSet.getInt("id"));
                System.out.println("name="+ resultSet.getString("NAME"));
                System.out.println("pwd="+ resultSet.getString("PASSWORD"));
                System.out.println("email="+ resultSet.getString("email"));
                System.out.println("birthday="+ resultSet.getDate("birthday"));
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(connection,statement,resultSet);
        }

    }
}

SQL注入问题

package com.dh.lesson03;

import com.dh.lesson02.utils.JdbcUtils;

import java.sql.*;

public class SqlZhuRu {
    public static void main(String[] args) {
        //login("lisi","123456");
        login("'' or 1=1","'' or 1=1");

    }

    //登录业务

    public static void login(String username,String password){
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        try {
            connection = JdbcUtils.getConnection(); //获取数据库连接
            String sql = "select * from users where `NAME` = ? AND `password` = ?";
            statement = connection.prepareStatement(sql);   //获得SQL的执行对象

            statement.setString(1,username);
            statement.setString(2,password);

            resultSet = statement.executeQuery();    //查询完毕会返回一个结果集

            while (resultSet.next()){
                System.out.println("id="+ resultSet.getInt("id"));
                System.out.println("name="+ resultSet.getString("NAME"));
                System.out.println("pwd="+ resultSet.getString("PASSWORD"));
                System.out.println("email="+ resultSet.getString("email"));
                System.out.println("birthday="+ resultSet.getDate("birthday"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(connection,statement,resultSet);
        }
    }
}

运行结果

PreparedStatement防止SQL注入的本质，把传递进来的参数当做字符

假设其中存在转义字符，就直接忽略，会被直接转义；

10.6、使用IDEA连接数据库

注意：用idea修改数据库数据后要点绿色的小箭头哦~

IDEA的数据库控制台

10.8、事务

要么都成功，要么都失败

ACID原则

原子性：要么全部完成，要么都不完成

一致性：总数不变

隔离性：多个进程互不干扰

持久性：一旦提交不可逆，持久化到数据库

隔离性的问题：

脏读：一个事务读取了另一个没有提交的事务的数据

不可重复读：在同一个事务内，重复读取表中的数据，表数据发生了改变

虚读（幻读）：在一个事务内，读取到了别人插入的数据，导致前后读取出来的结果不一致

事务举例

转账

package com.dh.lesson04;


import com.dh.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 connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;

        try {
            connection = JdbcUtils.getConnection();
            //1.关闭数据库自动提交事务，会自动开启事务
            connection.setAutoCommit(false);    //这里也叫开启事务（关闭自动提交事务）

            String sql1 = "update account set money = money-100 where name = 'A'";
            statement = connection.prepareStatement(sql1);
            statement.executeUpdate();
            String sql2 = "update account set money = money+100 where name = 'B'";
            statement = connection.prepareStatement(sql2);
            statement.executeUpdate();

            //业务完毕，提交事务
            connection.commit();
            System.out.println("转账操作成功！");

        } catch (SQLException e) {
            try {
                //默认状态下失败就会回滚事务
                connection.rollback();      //如果失败就回滚事务
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        } finally {
            JdbcUtils.release(connection,statement,resultSet);
        }

    }
}

10.9、数据库连接池

数据库连接---执行完毕---释放

连接----->释放 十分浪费系统资源

池化技术：准备一些预先的资源，过来就连接预先准备好的

• 最小连接数
• 最大连接数
• 等待超时

编写连接池，实现一个接口DataSource

开源数据源实现

DBCP

C3P0

Druid：阿里巴巴

使用了这些数据库连接池之后，我们在项目开发中就不需要编写连接数据库的代码了！

DBCP

需要用到的jar包

• commons-dbcp-1.4.jar
• commons-pool-1.6.jar

dbcpconfig.properties

#连接设置
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcStudy?useSSL=true&useUnicode=true&characterEncoding=UTF-8
username=root
password=123456

#<!-- 初始化连接 -->
initialSize=10

#最大连接数量
maxActive=50

#<!-- 最大空闲连接 -->
maxIdle=20

#<!-- 最小空闲连接 -->
minIdle=5

#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
maxWait=60000
#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;]
#注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=UTF8

#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true

#driver default 指定由连接池所创建的连接的只读（read-only）状态。
#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
defaultReadOnly=

#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_UNCOMMITTED

JdbcUtils_DBCP工具类

package com.dh.lesson05.utils;

import org.apache.commons.dbcp.BasicDataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class JdbcUtils_DBCP {
    //提升作用域到全局
    private static DataSource dataSource = null;

    static {
        try {
            InputStream resourceAsStream = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
            Properties properties = new Properties();
            properties.load(resourceAsStream);

            //创建数据源，工厂模式-->创建对象
            dataSource = BasicDataSourceFactory.createDataSource(properties);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //获取连接
    public static Connection getConnection() throws SQLException {
        //return DriverManager.getConnection(url, username, password);  //这是之前的方式
        return dataSource.getConnection();      //从数据源中获取连接

    }

    //释放连接资源
    public static void release(Connection connection, Statement statement, ResultSet resultSet){
        //关闭resultSet
        if (resultSet!=null){
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        //关闭statement
        if (statement!=null){
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        //关闭connection
        if (connection!=null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }
}

TestDBCP类

package com.dh.lesson05;

import com.dh.lesson02.utils.JdbcUtils;
import com.dh.lesson05.utils.JdbcUtils_DBCP;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

public class TestDBCP {
    public static void main(String[] args) {

        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;

        try {
            connection = JdbcUtils_DBCP.getConnection(); //获取数据库连接
            //区别来了
            //statement = connection.createStatement();   //获得SQL的执行对象
            //使用?占位符代替参数
            String sql = "INSERT INTO users(`id`, `NAME`,`PASSWORD`,`email`, `birthday`) VALUES(?,?,?,?,?)";
            statement = connection.prepareStatement(sql); //预编译的SQL，先写SQL，但是不执行
            //手动给参数赋值
            statement.setInt(1,4);          //id
            statement.setString(2,"彭于晏");
            statement.setString(3,"123456");
            statement.setString(4,"9999@163.com");

            //注意点:  sql.Date            数据库
            //         util.Date           Java     new Date().getTime()获得时间戳
            statement.setDate(5,new java.sql.Date(new Date().getTime()));//用当前时间作为生日

            //执行
            int i = statement.executeUpdate();
            if (i > 0){
                System.out.println("插入成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils_DBCP.release(connection,statement,resultSet);
        }
    }
}

本质是和自己写的连接数据库的工具类没有区别，只不过这个连接数据库的工具类实现了一个接口DataSource，用到了工厂模式。

C3P0

需要用到的jar包

• c3p0-0.9.5.5.jar
• mchange-commons-java-0.2.20.jar

c3p0-config.xml

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

<c3p0-config>
    <!--
    c3p0的缺省（默认）配置
    如果在代码中"ComboPooledDataSource ds=new ComboPooledDataSource();"这样写就表示使用的是c3p0的缺省（默认）
    -->
    <default-config>
        <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcStudy?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8</property>
        <property name="user">root</property>
        <property name="password">123456</property>

        <property name="acquireIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </default-config>
    <!--
    c3p0的命令配置
    如果在代码中"ComboPooledDataSource ds=new ComboPooledDataSource(MySQL);"这样写就表示使用的是name-config name="MySQL"的数据源
    -->
    <name-config name="MySQL">
        <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcStudy?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8</property>
        <property name="user">root</property>
        <property name="password">123456</property>

        <property name="acquiredIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </name-config>
</c3p0-config>

JdbcUtils_C3P0工具类

package com.dh.lesson05.utils;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

public class JdbcUtils_C3P0 {
    //提升作用域到全局
    private static ComboPooledDataSource dataSource = null;

    static {
        try {
            //代码版配置
//            dataSource = new ComboPooledDataSource();
//            dataSource.setDriverClass();
//            dataSource.setUser();
//            dataSource.setPassword();
//            dataSource.setJdbcUrl();
//
//            dataSource.setMaxPoolSize();
//            dataSource.setMinPoolSize();
            //可以像上面代码版配置去配置连接池大小，但是不建议这样，我们直接通过配置文件就好了

            //创建数据源，工厂模式-->创建对象
            dataSource = new ComboPooledDataSource("MySQL");  //配置文件的写法

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //获取连接
    public static Connection getConnection() throws SQLException {
        //return DriverManager.getConnection(url, username, password);  //这是之前的方式
        return dataSource.getConnection();      //从数据源中获取连接

    }

    //释放连接资源
    public static void release(Connection connection, Statement statement, ResultSet resultSet){
        //关闭resultSet
        if (resultSet!=null){
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        //关闭statement
        if (statement!=null){
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        //关闭connection
        if (connection!=null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }
}

TestC3P0类

package com.dh.lesson05;

import com.dh.lesson05.utils.JdbcUtils_C3P0;
import com.dh.lesson05.utils.JdbcUtils_DBCP;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

public class TestC3P0 {
    public static void main(String[] args) {

        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;

        try {
            connection = JdbcUtils_C3P0.getConnection(); //原来是自己实现的连接数据库，现在用别人实现的
            //区别
            //使用?占位符代替参数
            String sql = "INSERT INTO users(`id`, `NAME`,`PASSWORD`,`email`, `birthday`) VALUES(?,?,?,?,?)";
            statement = connection.prepareStatement(sql); //预编译的SQL，先写SQL，但是不执行
            //手动给参数赋值
            statement.setInt(1,5);          //id
            statement.setString(2,"周润发");
            statement.setString(3,"123456");
            statement.setString(4,"8888@163.com");

            //注意点:  sql.Date            数据库
            //         util.Date           Java     new Date().getTime()获得时间戳
            statement.setDate(5,new java.sql.Date(new Date().getTime()));//用当前时间作为生日

            //执行
            int i = statement.executeUpdate();
            if (i > 0){
                System.out.println("插入成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils_DBCP.release(connection,statement,resultSet);
        }
    }
}

结论

无论使用什么数据源，本质还是一样的，DataSource接口不会变，方法就不会变

Druid（德鲁伊）

这个Druid后面会学阿里巴巴的Druid。