1.MySQL，JDBC
MySQL
MySQL，JDBC
内容所需要的所有依赖文件：在以下路径 嘿嘿~
https://download.csdn.net/download/weixin_56121715/85411373#
文章目录
- MySQL
- 1、初识MySQL
-
- 1.1、为什么学习数据库
- 1.2、什么是数据库
- 1.3、数据库分类
- 1.4、MySQL 简介
- 1.5、安装MySQL
- 1.6、SQLyog
- 2、操作数据库
-
- 2.1、操作数据库
- 2.2、数据库的列类型
- 2.3、数据库的字段属性
- 2.4、创建数据库
- 2.5、数据表的类型
- 2.6、修改删除表
- 3、MySQL数据管理
-
- 3.1、外键
- 3.2、DML语言
- 3.3、插入数据 insert
- 3.4、更新数据 update
- 3.5、删除数据 delete
- 4、使用DQL查询数据（重点）
-
- 4.1、DQL 语言
- 4.2、指定查询字段
- 4.3、where 条件语句
- 4.4、连接查询
- 4.5、排序和分页
- 4.6、子查询
- 5、MySQL 函数
-
- 5.1、常用函数
- 5.2、聚合函数
- 5.3、分组函数
- 5.4、拓展md5加密
- 6、事务
-
- 6.1、概述
- 6.2、执行事务
- 7、索引
-
- 7.1、索引的分类
- 7.2、测试索引
- 7.3、索引原则
- 8、权限管理和备份
-
- 8.1、用户管理
- 8.2、MySQL 备份
- 9、规范数据库设计
-
- 9.1、为什么需要设计
- 9.2、三大范式
- 10、JDBC（重点）
-
- 10.1、数据库驱动
- 10.2、JDBC
- 10.3、第一个JDBC程序
- 10.4、JDBC中的对象解释
- 10.5、statement 对象
- 10.6、SQL 注入问题
- 10.7、prepareStatement 对象
- 10.8、使用Idea 连接数据库
- 10.9、操作事务
- 10.10、数据库连接池
1、初识MySQL
1.1、为什么学习数据库
- 岗位需求
- 现在的世界，大数据时代
- 被迫需求，存数据
- 数据库是所有软件体系中最核心的存在 DBA
1.2、什么是数据库
数据库：（DB，DataBase）
概念：数据仓库，软件，安装在操作系统之上的，SQL，可以存储大量的数据，500万！
作用：存储数据，管理数据
DBMS
DBMS：数据库管理系统(DataBase Management System)
数据库管理软件，科学组织和存储数据，高效地获取和维护数据
1.3、数据库分类
关系型数据库：（SQL）
- MySQL，Oracle，Sql Server，DB2，SQLite
- 通过表和表之间，行和列之间的关系进行数据的存储
非关系型数据库：（NoSQL）
- Redis，MongDB
- 非关系型数据库，对象存储，通过对象的自身的属性来决定
1.4、MySQL 简介
MySQL是一个**关系型数据库管理系统**
前世：瑞典[MySQL AB](https://baike.baidu.com/item/MySQL AB/2620844) 公司开发
今生：属于 Oracle 旗下产品
- MySQL 是最流行的关系型数据库管理系统之一
- 是开源的数据库软件
- 由于其体积小、速度快、总体拥有成本低，尤其是开放源码这一特点，一般中小型，或者大型网站的开发都选择 MySQL 作为网站数据库。
官网：MySQL :: Download MySQL Community Server
安装建议：
- 尽量不要使用 exe，注册表
- 尽可能的使用压缩包安装
1.5、安装MySQL
1、把这个包放在自己的电脑环境目录里
2、解压
3、配置环境变量 我的电脑–> 属性–> 高级系统设置 --> 高级–> 环境变量–> 系统变量–>Path --> 添加属性 (mysql目录\bin)
4、新建 mysql 配置文件 my.ini
5、配置 my.ini 文件
6、管理员模式启动cmd 去到mysql\bin目录下运行 mysqld -install
7、再次输入 mysqld --initialize-insecure --user=mysql 初始化数据文件 生成data文件
8、然后启动mysql 使用命令 mysql -u root -p 进入mysql管理界面（密码可为空）
9、进入页面后更改root密码
update mysql.user
set authentication_string=password('123456')
where user='root' and host='localhost';
10、刷新权限
flush privileges;
11、修改 my.ini 文件删除最后一句 skip-grant-tables
12、重新启动mysql即可正常使用
net stop mysql; --停止mysql服务
net start mysql; --开启服务
13、连接上测试以下结果就安装好了
1.6、SQLyog
图形化管理MySQL数据库的软件工具
特点：简洁，易用，图形化
使用SQLyog管理工具自己完成以下操作：
- 连接本地MySQL数据库
- 新建School数据库
- 数据库名称School
- 新建数据库表 student
- 字段
- id
- name
- age
在历史记录中可以看到相对应的数据库操作的语句
2、操作数据库
结构化查询语句分类
| 名称 | 解释 | 命令 |
|---|---|---|
| DDL（数据定义语言） | 定义和管理数据对象，如数据库，数据表 | create，drop，alter |
| DML（数据操作语言） | 用于操作数据库对象中所包含的数据 | create，drop，alter |
| DQL（数据查询语言） | 用于查询数据库数据 | select |
| DCL（数据控制语言） | 用于查询数据库数据 select DCL，用于管理数据库语言，包括管理权限及数据更改 | grant，commit，rollback |
操作数据库 > 操作数据库中的表 > 操作表中的字段
2.1、操作数据库
命令行操作数据库
| 数据库操作 | 语句 |
|---|---|
| 创建数据库 | create database [if not exists] 数据库名; |
| 删除数据库 | drop database [if exists] 数据库名; |
| 查询数据库 | show databases; |
| 使用数据库 | use 数据库名 |
-- 如果你的表名或者字段名是一个特殊字符，就需要使用 `` 包裹
use `数据库名`
2.2、数据库的列类型
数值
- tinyint 十分小的数据 1个字节
- smailint 较小的数据 2个字节
- mediumint 中等大小的数据 3个字节
- int 标准的整数 4个字节 （常用）
- bigint 较大的数据 8个字节
- float 浮点数 4个字节
- double 浮点数 8个字节（精度问题）
- decimal 字符串形式的浮点数 金融计算的时候，一般是使用decimal
字符串
- char 字符串固定大小的 0~255
- varchar 可变长字符串 0~65535 （常用）
- tinytext 微型文本 2^8-1
- text 文本串 2^16-1 保存大文本
时间日期
- data YYYY-MM-DD ， 日期格式
- time HH：mm：ss ， 时间格式
- datetime YYYY-MM-DD HH：mm：ss 最常用的时间格式
- timestamp 时间戳 ， 1970.1.1 到现在的毫秒数！也较为常用
- year 年份表示
null
- 没有值，未知
- 注意：不要使用 null 进行运算，结果为 null
2.3、数据库的字段属性
Unsigned：
- 无符号的整数
- 声明了该列不能声明为负数
zerofill：
- 0填充的
- 不足的位数，使用 0 来填充， int(3) ，1-----001
自增：
- 通常理解为自增，自动在上一条的记录的基础上 +1
- 通常用来设计唯一的主键 – index，必须是整数类型
- 可以自定义设计主键自增的起始值和步长
非空：
- 如果设置为 not null，如果不给它赋值，就会报错
- null，如果不填写，默认就为 null
默认：
- 设置默认的值
- 如果不指定该列的值，则会有默认的值
拓展：（每一个表必须有以下 5 个字段，表示一个记录存在意义）
/*
id 主键
`version` 乐观锁
is_dalete 伪删除
gmt_create 创建时间
gmt_update 修改时间
*/
2.4、创建数据库
SQL创建数据库
目标：创建一个school数据库
创建学生表（列，字段）使用SQL创建
学号 int 登录密码varchar(20) 姓名，性别varchar(2) ，出生如期（datatime），家庭住址，email
注意点：
-- 使用英文（），表的名称 和 字段的 尽量使用 `` 包裹起来
-- auto_increment 自增
-- 字符串使用 单引号包裹起来
-- 所有的语句后面加 英文的逗号，最后一个不需要加
-- primary key 主键，一般一个表只有一个唯一的主键
CREATE DATABASE school; -- 创建数据库
USE school; -- 进入数据库
CREATE TABLE IF NOT EXISTS student(
`id` INT(4) NOT NULL 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
DESC student; -- 查询表结构
SHOW CREATE TABLE student; -- 显示创建表的sql
格式
create table [if not exists] 表名(
`字段名` 列类型 [属性] [索引] [注释],
`字段名` 列类型 [属性] [索引] [注释],
.......
`字段名` 列类型 [属性] [索引] [注释]
)[表类型][表的字符集][注释]
2.5、数据表的类型
-- 关于数据库引擎
/*
INNODB 默认使用
MYISAM 早些年使用的
*/
| MYISAM | INNODB | |
|---|---|---|
| 事务支持 | 不支持 | 支持 |
| 数据行锁定 | 不支持 | 支持 |
| 外键约束 | 不支持 | 支持 |
| 全文索引 | 不支持 | 支持 |
| 表空间的大小 | 较小 | 较大，约2倍 |
常规的使用操作：
- MYISAM 节约空间，速度较快
- INNODB 安全性高，事务的处理，多表多用户操作
在物理空间存在的位置
所有的数据库文件都存在 data 目录下
本质还是文件的存储
MySQL引擎在屋里文件上的区别
- InnoDB 在数据库表中只有一个 *.frm 文件，以及上级目录下的 ibdata1 文件
- MYISAM 对应文件
- *.frm 表结构的定义文件
- *.MYD 数据文件（data）
- *.MYI 索引文件（index）
设置数据库表的字符集编码
charset = utf8
不设置的话，会是 mysql 默认的字符集编码（不支持中文）
MySQL 的默认编码是 Latin1，不支持中文
在 my.ini 中配置默认的编码
character-set-server=utf8
推荐每次创建时都设置编码格式
2.6、修改删除表
修改和删除表
-- 修改表名：alter table 旧表名 rename as 新表名;
ALTER TABLE `student` RENAME AS `student1`;
-- 增加表的字段：alter table 表名 add 字段名 列类型;
ALTER TABLE `student1` ADD `height` DOUBLE;
-- 修改表的字段（重命名，修改约束）
-- 修改约束：alter table 表名 modify 字段名 列类型;
ALTER TABLE `student1` MODIFY `pwd` VARCHAR(15); -- 修改约束
-- 字段重命名 alter table 表名 change 旧字段名 新字段名 列类型;
ALTER TABLE `student1` CHANGE `pwd` `password` INT(6); -- 字段重命名
-- 删除表的字段
-- 删除表字段：alter table 表名 drop 字段;
ALTER TABLE `student1` DROP `height`;
-- 删除表 （如果存在就删除）
DROP TABLE IF EXISTS `student1`;
所有的创建和删除操作尽量加上判断，以免报错（IF EXISTS）（IF EXISTS）
注意点：
- `` 字段名，使用这个包裹
- 注释 – /**/
- sql 关键字大小写不敏感，尽量使用小写
- 所有的符号全部用英文
3、MySQL数据管理
3.1、外键
外键理解即可，实际不推荐使用
概念
外键表示了两个关系之间的相关联系。以另一个关系的外键作主关键字的表被称为主表，具有此外键的表被称为主表的从表。
在实际操作中，将一个表的值放入第二个表来表示关联，所使用的值是第一个表的主键值（在必要时可包括复合主键值），
此时，第二个表中保存的这些值的属性称为外键 (foreign key)
作用
保持数据的一致性，完整性，主要目的是控制存储在外链表中的数据约束。
使俩张表形成关联，外键只能引用外表中的列的值或使用空值
创建方式：
- 建表时指定外键约束
- 建表后添加外键
-- 创建外键方式一：建表时创建外键
-- 创建年级表
CREATE TABLE `garde`(
`garde_id` INT(10) NOT NULL AUTO_INCREMENT COMMENT'年级id',
`garde_name` VARCHAR(20) NOT NULL COMMENT'年级名称',
PRIMARY KEY(`garde_id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8
-- 创建学生表
CREATE TABLE `student`(
`id` INT(10) NOT NULL AUTO_INCREMENT COMMENT'学生id',
`name` VARCHAR(20) NOT NULL COMMENT '学生名字',
`sex` VARCHAR(3) NOT NULL DEFAULT'女' COMMENT'学生性别',
`garde_id` INT(10) NOT NULL COMMENT'年级',
PRIMARY KEY(`id`),
KEY `FK_garde`(`garde_id`),
CONSTRAINT `FK_garde` FOREIGN KEY(`garde_id`) REFERENCES `garde`(`garde_id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8
-- 创建方法二：创建表之后添加外键
ALTER TABLE `student`
ADD CONSTRAINT `FK_garde` FOREIGN KEY (`garde_id`) REFERENCES `garde`(`garde_id`);
操作：删除 grade 表时，发现报错
注意：在删除具有主外键关系的表时，要先删除子表，后删主表
由于每次都需要这样麻烦的删除，所以不推荐使用外键
-- 删除外键
ALTER TABLE student DROP FOREIGN KEY FK_garde;
-- 发现执行完上面的，索引还在，所以还要删除索引
-- 注：这个索引是建立外键的时候默认生成的
ALTER TABLE student DROP INDEX FK_garde;
3.2、DML语言
DML（Data Manipulation Language）
数据操作语言，使用户能够查询数据库以及操作已有数据库中的数据的的计算机语言
- 包括：
- insert 插入数据语句
- update 更新数据语句
- delete 删除数据语句
3.3、插入数据 insert
-- 语法
insert into `表名`[(字段1),(字段2),(字段3)....] values('值1','值2','值3'...)
注意：
- 字段或值之间用英文逗号隔开
- 字段这部分可以省略，但添加的值必须与表结构，数据列，顺序相对应，且数量一致
- 可同时插入多条数据，values 后用英文逗号隔开
-- 一次插入一条数据
INSERT INTO garde(`garde_name`)VALUES('大一')
INSERT INTO garde(`garde_name`)VALUES('大二')
-- 一次性添加多条数据
INSERT INTO garde(`garde_name`)VALUES('大三'),('大四'),('研究生')
-- 主键自增，是否可以省略？ 不可以省略，会报错，如果没有填写字段，数据就要与表结构一一对应
INSERT INTO garde VALUES('没了')
3.4、更新数据 update
-- 语法
update `表名` set column_name=value[,column_name2=value2][where condition]
- 注意：
- column_name 为要更改的数据列
- value 为修改后的数据，可以为变量，具体指，表达式或者嵌套的select结果
- condition 为筛选条件，如果不指定则修改该表的所有列数据
where 条件
可以理解为筛选条件（返回的bool值）
| 运算符 | 含义 | 范围 | 结果 |
|---|---|---|---|
| = | 等于 | 5=6 | false |
| <> != | 不等于 | 5<>6 | true |
| > | 大于 | 5>6 | false |
| < | 小于 | 5<6 | true |
| >= | 大于等于 | 5>=6 | false |
| <= | 小于等于 | 5<=6 | true |
| between | 在某个范围之间 | between 5 and 10 | [5,10] |
| and | 与 | 5>1 and 1>2 | false |
| or | 或 | 5>1 or 1>2 | true |
-- 更新年级信息，不加条件则修改所有数据
UPDATE `garde`
SET `garde_name`='初中'
WHERE `garde_id`=1;
3.5、删除数据 delete
-- 语法
delete from `表名` [where condition];
注意：condition 为 条件
-- 删除最后一个数据，不加筛选条件则删除该表的所有数据
DELETE FROM `garde` WHERE `garde_id`=1;
-- 删除了所有数据
DELETE FROM `garde`;
truncate 命令
作用：用于完全清空表数据，但表结构，索引，约束等不变
-- 语法
truncate [table] table_name;
-- 清空 garde 表
TRUNCATE TABLE `garde`;
truncate 和 delete 命令的区别
相同：都能删除表数据，不删除表结构，但 truncate 速度更快
不同：
- delete ：自增当前值依然从原来的基础上进行，会记录日志
- truncate：自增当前值会恢复到初始值重新开始，不会记录日志
4、使用DQL查询数据（重点）
4.1、DQL 语言
DQL（Data Query Language 数据查询语言）
- 查询数据库数据，select 语句
- 简单的单表查询或多表的复杂查询和嵌套查询
- 是数据库语言中最核心，最重要的语句
- 使用频率最高的语句
-- select 语法
select [all | distinct]
{* | table.* | [table.field1 [as alias1]][,table.field2 [as alias2]]}
from table_name [as table_alias]
[left | right | inner join table_name2] -- 联合查询
[where ...] -- 指定结果需满足的条件
[group by ...] -- 指定结果按照哪几个字段来分组
[having] -- 过滤分组的记录必须满足的次要条件
[order by ...] -- 指定查询记录按一个或多个条件排序
[limit{[offset,]row_count | row_countOFFSET offset }]; -- 指定查询的记录从哪条至哪条
注意：[] 括号代表可选的，{}括号代表必选的
操作数据：
SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for stu
-- ----------------------------
DROP TABLE IF EXISTS `stu`;
CREATE TABLE `stu` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`stu_num` INT(11) DEFAULT NULL,
`stu_name` VARCHAR(255) CHARACTER SET utf8 COLLATE utf8_unicode_ci DEFAULT NULL,
`age` INT(11) DEFAULT NULL,
`gender` VARCHAR(255) CHARACTER SET utf8 COLLATE utf8_unicode_ci DEFAULT NULL,
`birthday` DATE DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=22 DEFAULT CHARSET=latin1;
-- ----------------------------
-- Records of stu
-- ----------------------------
INSERT INTO `stu` VALUES ('1', '2020001', 'Jack', '18', '男', '2020-09-18');
INSERT INTO `stu` VALUES ('2', '2020002', '杰克', '18', '男', '2020-09-18');
INSERT INTO `stu` VALUES ('3', '2020003', 'Jack', '18', '女', '2020-09-18');
INSERT INTO `stu` VALUES ('4', '2020004', '杰克', '18', '女', '2020-09-18');
INSERT INTO `stu` VALUES ('5', '2020005', 'Jack', '28', '男', '2020-09-18');
INSERT INTO `stu` VALUES ('6', '2020006', '杰克', '28', '男', '2020-09-18');
INSERT INTO `stu` VALUES ('7', '2020007', 'Jack', '28', '女', '2020-09-18');
INSERT INTO `stu` VALUES ('8', '2020008', '杰克', '28', '女', '2020-09-18');
INSERT INTO `stu` VALUES ('9', '2020009', 'Jack', '38', '男', '2019-09-18');
INSERT INTO `stu` VALUES ('10', '2020010', '杰克', '38', '男', '2018-08-18');
INSERT INTO `stu` VALUES ('11', '2020011', 'Jack', '38', '女', '2019-09-18');
INSERT INTO `stu` VALUES ('12', '2020012', '杰克', '38', '女', '2018-08-18');
INSERT INTO `stu` VALUES ('13', '2020013', '马可', '17', '男', '2020-09-22');
INSERT INTO `stu` VALUES ('14', '202014', '伽罗', '63', '女', '2020-09-23');
INSERT INTO `stu` VALUES ('15', '2020015', 'maria', '25', '女', '2020-09-02');
INSERT INTO `stu` VALUES ('16', '2020016', 'Maria', '21', '男', '2020-03-20');
INSERT INTO `stu` VALUES ('17', '2020017', 'mara', '62', '男', '2020-07-26');
INSERT INTO `stu` VALUES ('18', '2020018', 'mary', '23', '女', '2020-05-20');
INSERT INTO `stu` VALUES ('19', '2020019', 'sara', '100', '男', '2020-06-17');
INSERT INTO `stu` VALUES ('20', '2020020', 'Naruto', '999', '男', '2020-11-11');
4.2、指定查询字段
基础查询
-- 查询所有学生信息，用*代表查询所有，不推荐，效率低
SELECT * FROM `stu`;
-- 为表起别名
SELECT `stu_num` AS '学号', `stu_name` AS '姓名' FROM stu AS s;
给字段或表起一个新的名字
-- 起别名（as 关键字可以省略）
SELECT `stu_num` AS '学号' FROM stu AS s;
distinct 去重
-- distinct 去除重复项
SELECT DISTINCT `stu_name` FROM `stu`;
4.3、where 条件语句
where 作用：筛选符合条件的记录
简单查询
-- 查询所有男性同学的姓名
SELECT DISTINCT `stu_name`,`gender` FROM `stu`
WHERE `gender`='男';
-- 查询姓名为马可的同学的信息
SELECT * FROM `stu`
WHERE `stu_name`='马可';
模糊查询
like 操作符用于在 where 子句中搜索列中的指定模式
/*
like 匹配/模糊查询，会与 % 和 _ 结合使用
'%a' 以a结尾的数据
'a%' 以a开头的数据
'%a%' 含有a的数据
'_a_' 三位且中间的字符是a的
'_a' 俩位且结尾字母是a 的
'a_' 俩位且开头字母是a 的
*/
-- 查询姓名以 马 开头的同学的信息
SELECT * FROM `stu`
WHERE `stu_name` LIKE '马%';
-- 查询姓名中包含 杰 的同学的信息
SELECT * FROM `stu`
WHERE `stu_name` LIKE '%杰%';
-- 查询姓名中以 k 结尾的同学的信息
SELECT * FROM `stu`
WHERE `stu_name` LIKE '%k';
-- 查询俩位名字以 克 结尾的同学的信息
SELECT * FROM `stu`
WHERE `stu_name` LIKE '_克';
in 操作符允许在 where 子句中规定多个值
-- 查询姓名为 maria mary 同学的学号
SELECT `stu_num`,`stu_name` FROM `stu`
WHERE `stu_name` IN ('maria','mary');
null 值代表遗漏的未知数据，在查询时不能直接写 =null，要用 isnull
-- 查询没有填写出生日期的同学 (这里没有)
SELECT `stu_name` FROM `stu`
WHERE `birthday` IS NULL;
-- 查询填写出生日期的同学 is not null(是不为空的)
SELECT `stu_name` FROM `stu`
WHERE `birthday` IS NOT NULL;
4.4、连接查询
连接查询（join）用于把来自俩个或多个表的列结合起来
这里需要多表查询，所以导入多个表数据
(https://blog.csdn.net/weixin_44012722/article/details/107974662)
join 对比
| 操作符名称 | 描述 |
|---|---|
| inner join | 如果表中有至少一个匹配，则放回列数据 |
| left join | 即使右表中没有匹配，也从左表中返回所有的列数据 |
| right join | 即使左表中没有匹配，也从右表中返回所有的列数据 |
inner join 查询俩个表中的结果集中的交集
-- 查询所有员工的编号和姓名，薪水
SELECT e.`emp_no`,`first_name`,`last_name`,`salary`
FROM `employees` AS e
INNER JOIN `salaries` AS s
ON e.`emp_no` = s.`emp_no`;
-- 查询指定员工的编号，姓名与薪水(注意语句顺序，on 必须放在 where 前面)
SELECT e.`emp_no`,`first_name`,`last_name`,`salary`
FROM `employees` AS e
INNER JOIN `salaries` AS s
ON e.`emp_no` = s.`emp_no`
WHERE e.`emp_no` = 10101
左外连接 left join
会读取左边数据表的全部数据，即便右边表无对应数据
-- 使用左外连查询
SELECT e.`emp_no`,`first_name`,`last_name`,`salary`
FROM `employees` AS e
LEFT JOIN `salaries` AS s
ON e.`emp_no` = s.`emp_no`
WHERE e.`emp_no` = 10101
右外连接 right join
会读取右边数据表的全部数据，即使左边的表无对应数据
-- 使用右外连查询
SELECT e.`emp_no`,`first_name`,`last_name`,`salary`
FROM `employees` AS e
RIGHT JOIN `salaries` AS s
ON e.`emp_no` = s.`emp_no`
WHERE e.`emp_no` = 10101
4.5、排序和分页
order by 子句用来设定你想按哪个字段哪种方式来进行排序，再返回结果
-- order by 语句默认按照 asc 升序对记录进行排序 asc 升序 desc 降序
SELECT `emp_no`,`first_name`,`last_name`
FROM `employees`
ORDER BY `emp_no` DESC
limit 子句可以被用于强制 select 语句返回指定的记录数
-- limit 接受一个或俩个数字参数
-- 检索第 7 个记录行
SELECT `emp_no`,`first_name`,`last_name`
FROM `employees`
LIMIT 7
-- 检索第 7 - 17 的记录行
SELECT `emp_no`,`first_name`,`last_name`
FROM `employees`
LIMIT 7,17
-- 查询 10位 薪水最高的员工的姓名，编号
-- 注意：先排序 再 分页
SELECT e.`emp_no`,`first_name`,`last_name`,`salary`
FROM `employees` AS e
INNER JOIN `salaries` AS s
ON e.`emp_no` = s.`emp_no`
ORDER BY `salary` DESC
LIMIT 10
4.6、子查询
在查询语句中的 where 条件子句中，又嵌套了另一个查询语句
嵌套查询可以由多个子查询组成，求解的方式是由里及外
子查询返回的结果一般都是集合，故而建议使用 in 关键字
-- 查询 23 位 员工 43624，47978 的编号，姓名与薪水,并且查看其中最高薪水的员工
-- 方法一：使用连接查询
SELECT e.`emp_no`,`first_name`,`last_name`,`salary`
FROM `employees` AS e
INNER JOIN `salaries` AS s
ON e.`emp_no` = s.`emp_no`
WHERE e.`emp_no` IN (43588,47978)
ORDER BY s.`salary` DESC
LIMIT 23
-- 方法二：使用子查询
SELECT e.`emp_no`,`first_name`,`last_name`,`salary`
FROM `employees` AS e
INNER JOIN `salaries` AS s
ON e.`emp_no` = s.`emp_no`
WHERE e.`emp_no` IN (
SELECT `emp_no` FROM `salaries`
WHERE `emp_no` IN (43588,47978)
)
ORDER BY s.`salary` DESC
LIMIT 23
5、MySQL 函数
MySQL 有很多内置的函数
可以参考：(https://dev.mysql.com/doc/refman/8.0/en/built-in-function-reference.html)
- 字符串函数
- 数字函数
- 日期函数
- …
5.1、常用函数
字符串函数
-- concat(s1,s2,..sn) 将多个字符串合并为一个字符串
SELECT CONCAT('中','国') -- 输出：中国
-- 从字符串第一个位置开始的6个字符替换为 abc insert()
SELECT INSERT('mysql.com',1,6,"ABC")
数字函数
-- 绝对值 abs()
SELECT ABS(-10);
-- 随机数，返回一个0-1之间的随机数
SELECT RAND();
日期函数
-- 获取当前日期和时间
SELECT NOW()
-- 计算起始日期 d 加上 n 天的日期
SELECT ADDDATE(NOW(),INTERVAL 10 DAY) -- 输出 本地时间加上了10天
5.2、聚合函数
| 函数名称 | 描述 |
|---|---|
| count() | 返回满足select条件的记录总和数，如select count() [不建议使用，效率低] |
| sum() | 返回数字字段或表达式列做统计，返回一列的总和 |
| avg() | 通常为数值字段或表达式列做统计，返回一列的平均值 |
| max() | 可以为数值字段，字符字段或表达式列做统计，返回最大的值 |
| min() | 可以为数值字段，字符字段或表达式列做统计，返回最小的值 |
-- 查询`employees`表的所有数量
SELECT COUNT(`emp_no`) FROM `employees` -- count(字段) 会忽略所有的null值
SELECT COUNT(*) FROM `employees` -- 不会忽略所有的null值，本质 计算行数
SELECT COUNT(1) FROM`employees` -- 推荐 不会忽略所有的null值，本质 计算行数
-- 查询`salaries`表中工资收入最高的，最低的，计算总和和平均收入
SELECT MAX(`salary`) AS 最大收入 FROM `salaries`
SELECT MIN(`salary`) AS 最小收入 FROM `salaries`
SELECT SUM(`salary`) AS 总收入 FROM `salaries`
SELECT AVG(`salary`) AS 平均收入 FROM `salaries`
5.3、分组函数
group by 语句根据一个或多个列对结果集进行分组（分组过滤）
-- 按照标题分组查询个数大于100000的标题
SELECT COUNT(1),`title`
FROM `titles`
GROUP BY `title`
HAVING COUNT(1) > 100000 -- 进行条件过滤
5.4、拓展md5加密
什么是MD5？
MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。
主要增强算法复杂度和不可逆性
MD5 不可逆，具体的值的 md5 是一样的
MD5 破解网站的原理，背后有一个字典，校验加密后的值，加密前的值
-- 测试 MD5 加密
CREATE TABLE IF NOT EXISTS `testmd5`(
`id` INT(10) 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,'zhangsan','123456'),(2,'lisi','123456'),(3,'wangwu','123456')
SELECT * FROM `testmd5`
-- 加密密码 一条
UPDATE `testmd5` SET `pwd`= MD5(`pwd`) WHERE `id`=1
UPDATE `testmd5` SET `pwd`= MD5(`pwd`) -- 加密全部
-- 插入时加密
INSERT INTO `testmd5` VALUES(4,'zhaoliu',MD5('123456'))
-- 如何校验：将用户传递的传递进来的密码，进行md5加密，然后比对加密后的值
SELECT * FROM `testmd5` WHERE `name` = 'zhaoliu' AND `pwd` = MD5('123456')
select小结
-- select 语法
select [all | distinct]
{* | table.* | [table.field1 [as alias1]][,table.field2 [as alias2]]}
from table_name [as table_alias]
[left | right | inner join table_name2] -- 联合查询
[where ...] -- 指定结果需满足的条件
[group by ...] -- 指定结果按照哪几个字段来分组
[having] -- 过滤分组的记录必须满足的次要条件
[order by ...] -- 指定查询记录按一个或多个条件排序
[limit{[offset,]row_count | row_countOFFSET offset }]; -- 指定查询的记录从哪条至哪条
6、事务
6.1、概述
1、什么是事务？
- 数据库中的事务是指对数据库执行一批操作，在同一个事务当中，这些操作最终要么全部执行成功，要么全部失败，不会存在部分成功的情况。
- MySQL 事务主要用于处理操作量大，复杂度高的数据
2、事务的特性(ACID)
- 原子性（Atomicity ， 或称不可分割性）
- 要么全部完成，要么全部失败
- 一致性（Consistency）
- 在事务开始之前和事务结束以后，数据库的完整性没有被破坏
- 隔离性（Isolation，又称独立性）
- 防止多个事务并发执行时由于交叉执行而导致数据不一致
- 持久性（Durability） – 事务提交
- 事务处理结束后，对数据的修改就是永久的
隔离 所导致的一些问题
- 脏读：一个事务读取了另外一个事务未提交的数据
- 不可重复读：在一个事务内读取表中的某一行数据，多次读取结果不同。（这个不一定是错误，只是某些场合不对）
- 虚读 (幻读)：是指在一个事务内读取到了别的事务插入的数据，导致前后读取不一致
6.2、执行事务
执行事务
-- ------------------事务----------------------
-- mysql 是默认开启事务的自动提交的
SET autocommit = 0 -- 关闭
SET autocommit = 1 -- （默认）开启
-- 手动处理事务
SET autocommit = 0
-- 开启事务
START TRANSACTION -- 标记一个事务的开始，从这个之后的 sql 都在同一个事务当中
-- 这里是需要执行的任务
INSERT INTO xx ....
UPDATE SET ...
-- 提交，持久化（成功）
COMMIT
-- 回滚，回到原来的样子（失败）
ROLLBACK
-- 事务结束
SET autocommit = 1 -- 开启自动提交
-- 了解 （这个保存点可以理解为游戏中的存档）
SAVEPOINT 保存点名 -- 设置一个事务的保存点
ROLLBACK TO SAVEPOINT 保存点名 -- 回滚到保存点
RELEASE SAVEPOINT 保存点名 -- 撤销保存点
事务的处理过程
模拟转账
CREATE DATABASE shop CHARACTER SET utf8 COLLATE utf8_general_ci
USE shop
CREATE TABLE `account`(
`id` INT(3) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(20) NOT NULL,
`money` DECIMAL(9,2) NOT NULL,
PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO `account`
VALUES (1,'A',2000.00),(2,'B',1500)
-- 模拟转账
SET autocommit = 0 -- 关闭自动提交
START TRANSACTION -- 开启事务
UPDATE `account` SET `money` = `money` -1000 WHERE `name` = 'A'
UPDATE `account` SET `money` = `money` + 1000 WHERE `name` = 'B'
COMMIT -- 提交事务，持久化
ROLLBACK -- 回滚,恢复之前的数据
SET autocommit = 1 -- 恢复自动提交
7、索引
什么是索引？
索引是为了加速对表中数据行的检索而创建的一种分散的存储结构。索引是针对表而建立的，它是由数据页面以外的索引页面组成的，每个索引页面中的行都会含有逻辑指针，以便加速检索物理数据。
7.1、索引的分类
-
主键索引（primary key）
- 唯一的标识，主键不可以重复，只能有一个列作为主键
-
唯一索引（unique key）
- 避免重复的列的出现，唯一索引可以重复，多个列都可以标识为 唯一索引
-
常规索引（key / index）
- 默认的，index，key关键字来设置
-
全文索引（fulltext）
- 在特定的数据库引擎下才有，MyISAM
- 快速定位数据
基础语法
-- 索引的使用
-- 1、在创建表的时候给字段增加索引
-- 2、创建完毕后，增加索引
-- 显示所有的索引信息
SHOW INDEX FROM `testmd5`
-- 增加一个全文索引（索引名）列名
ALTER TABLE `testmd5` ADD FULLTEXT INDEX `name`(`name`)
-- explain 分析sql执行的状况
EXPLAIN SELECT * FROM `testmd5` -- 非全文索引
EXPLAIN SELECT * FROM `testmd5` WHERE MATCH(`name`) AGAINST('A')
7.2、测试索引
创建100万条数据测试索引
-- 创建一个app用户表
CREATE TABLE `app`(
`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：女）',
`pwd` VARCHAR(100) NOT NULL COMMENT'密码',
`age` TINYINT(4) DEFAULT'0' COMMENT'年龄',
`create_time` DATETIME DEFAULT CURRENT_TIMESTAMP,
`update_time` TIMESTAMP NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8mb4 COMMENT'app用户表'
-- 插入100万条数据
DELIMITER $$ -- 写函数之前必须要写的，标志
CREATE FUNCTION mock_data()
RETURNS INT
BEGIN
DECLARE num INT DEFAULT 1000000;
DECLARE i INT DEFAULT 0;
WHILE i<num DO
-- 插入语句
INSERT INTO app(`name`,`email`,`phone`,`gender`,`pwd`,`age`)VALUES (CONCAT('用户',i),'[email protected]',CONCAT('18',FLOOR(RAND()*((999999999-100000000)+100000000))),FLOOR(RAND()*2),UUID(),FLOOR(RAND()*100));
SET i=i+1;
END WHILE;
RETURN i;
END;
SELECT mock_data();
DELIMITER ;
SELECT * FROM `app`
SELECT * FROM `app` WHERE `name`='用户99999' -- 查了三次的用时 0.871 sec 0.896 sec 0.954 sec
EXPLAIN SELECT * FROM `app` WHERE `name`='用户99999'
-- 创建索引测试
-- id_表名_字段名
CREATE INDEX id_app_name ON `app`(`name`)
SELECT * FROM `app` WHERE `name`='用户99999' -- 0.002 sec
EXPLAIN SELECT * FROM `app` WHERE `name`='用户99999'
-- 删除索引
DROP INDEX id_app_name ON `app`
对比查询的个数
索引在小数据量的时候，用处不大，但是在大数据的时候，区别会十分明显
7.3、索引原则
- 索引不是越多越好
- 不要对经常变动的数据加索引
- 小数据量的表不需要索引
- 索引一般加在常用来查询的字段上
索引的数据结构
Hash 类型的索引
Btree：InnoDB 的默认数据结构
这里看大佬的文章：CodingLabs - MySQL索引背后的数据结构及算法原理
8、权限管理和备份
8.1、用户管理
SQL yog 可视化管理
SQL 命令操作
-- 其实只是在对 mysql库下的user表做操作
-- 创建用户 create user '用户名' identified by '密码'
CREATE USER fusu IDENTIFIED BY '123456'
-- 修改密码 (修改当前用户密码)
SET PASSWORD = PASSWORD('123456')
-- 修改密码（修改指定用户密码）
SET PASSWORD FOR fusu = PASSWORD('111111')
-- 重命名 rename user 原名称 to 新名称
RENAME USER fusu TO fusu2
-- 用户授权 all privileges 全部的权限，库.表
-- all privileges 除了给别人授权不行，其他都可以
GRANT ALL PRIVILEGES ON *.* TO fusu2
-- 查询权限
SHOW GRANTS FOR fusu2 -- 查看指定用户的权限
SHOW GRANTS FOR root@localhost
-- root用户的权限 GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' WITH GRANT OPTION
-- 撤销权限
REVOKE ALL PRIVILEGES ON *.* FROM fusu2
8.2、MySQL 备份
为什么要备份：
- 保证重要的数据不丢失
- 数据转移
MySQL 数据库备份的方式：
-
直接拷贝物理文件
-
可视化工具手动导出
-
右键表或库 --> 备份/到处 --> 备份表作为SQL转储
-
-
命令行导出
# mysqldump -h 主机名 -u 用户 -p 密码 数据库 数据表 > 导出的位置 mysqldump -hlocalhost -uroot -p123456 shop account > E:/a.sql # mysqldump -h 主机名 -u 用户 -p 密码 数据库 数据表1 表2 ... > 导出的位置 mysqldump -hlocalhost -uroot -p123456 school garde stu > E:/a.sql # mysqldump -h 主机名 -u 用户 -p 密码 数据库> 导出的位置 mysqldump -hlocalhost -uroot -p123456 school > E:/a.sql # 导入 # 登录的情况下，切换到指定的数据库 # source 备份文件 source e:/sql.sql # 没登陆的情况 mysql -u用户名 -p密码 库名 < 备份文件备份数据库，防止数据丢失！
9、规范数据库设计
9.1、为什么需要设计
当数据库比较复杂的时候，我们就需要设计了
糟糕的数据库设计：
- 数据冗余，浪费空间
- 数据库插入和删除都会麻烦，异常（屏蔽使用物理外键）
- 程序的性能差
良好的数据库设计：
- 节省内存空间
- 保证数据库的完整性
- 方便我们开发系统
软件开发中，关于数据库的设计
- 分析需求，分析业务和需要处理的数据库的需求
- 概要设计：设计关系图 E-R 图
设计数据库的步骤：
- 收集信息，分析需求
- 标识主体（把需求落地到每个字段）
- 标识实体之间的关系
9.2、三大范式
为什么需要数据规范化？
- 信息重复
- 更新异常
- 插入异常
- 无法正常显示信息
- 删除异常
- 丢失有效的信息
三大范式
第一范式（1NF）
原子性：保证每一列不可再分
第二范式（2NF）
前提：满足第一范式
每张表只描述一件事情
第三范式（3NF）
前提：满足第一和第二范式
第三范式需要确保数据表中的每一列数据都和主键直接相关，而不能间接相关
（规范数据库的设计）
规范性 和 性能的问题
关联查询的表不得超过三张
- 考虑商业化的需求和目标，（成本，用户体验！）数据库的性能更加重要
- 在规范性能的问题的时候，需要适当的考虑一下 规范性
- 故意给某些表增加一些冗余的字段。（从多表查询中变为单表查询）
- 故意增加一些计算列（从大数据量降为小数据量的查询：索引）
10、JDBC（重点）
10.1、数据库驱动
驱动：声卡，显卡…
我们的程序会通过数据库驱动，和数据库打交道
10.2、JDBC
SUN 公司为了简化 开发人员的（对数据库的统一）操作，提供了一个（Java操作数据库的）规范，称为 JDBC
这些规范的实现由具体的厂商去做
对于开发人员来说，我们只需要掌握JDBC接口的操作即可
java.sql
javax.sql
还需要导入一个数据库驱动包
10.3、第一个JDBC程序
创建项目
创建一个lib包，导入数据库驱动，添加到项目库中
编写测试代码
package com.fusu;
import java.sql.*;
public class JdbcFirstDemo {
public static void main(String[] args) {
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;
try {
// 1.加载驱动
Class.forName("com.mysql.jdbc.Driver");
// 2.用户信息和url
String url = "jdbc:mysql://localhost:3306/school?useUnicode=true&characterEncoding=utf8&useSSL=true";
String username = "root";
String password = "123456";
// 3.连接成功，数据库对象
connection = DriverManager.getConnection(url, username, password);
// 4.执行SQL对象
statement = connection.createStatement();
// 5.SQL对象执行 sql，可能存在结果，查看返回结果
String sql = "select * from stu";
resultSet = statement.executeQuery(sql);
while (resultSet.next()){
System.out.println("id " + resultSet.getObject("id"));
System.out.println("stu_num " + resultSet.getObject("stu_num"));
System.out.println("stu_name " + resultSet.getObject("stu_name"));
System.out.println("age " + resultSet.getObject("age"));
System.out.println("gender " + resultSet.getObject("gender"));
System.out.println("birthday " + resultSet.getObject("birthday"));
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
} finally {
// 6.释放连接
try {
resultSet.close();
statement.close();
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
步骤总结：
- 加载驱动
- 连接数据库 DriverManager
- 获得执行sql的对象 statement
- 获得返回的结果集
- 释放连接
10.4、JDBC中的对象解释
DriverManager
// DriverManager.registerDriver(new com.mysql.jdbc.Driver()); 原写法
Class.forName("com.mysql.jdbc.Driver"); // 固定写法，加载驱动
URL
String url = "jdbc:mysql://localhost:3306/school?useUnicode=true&characterEncoding=utf8&useSSL=true";
// mysql 端口 3306
// 协议://主机地址：端口/数据库？参数1&参数2&参数3
// oralce 1521
// jdbc:oracle:thin:@localhost:1521:sid
Statement 执行SQL的对象 prepareStatement 执行SQL的对象
String sql = "select * from stu"; // 编写sql
statement.execute(); // 执行任何sql
statement.executeQuery(); // 执行查询sql 返回一个数据集resultSet
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(); // 移动到指定行
释放资源
resultSet.close();
statement.close();
connection.close(); // 耗资源，用完关掉
10.5、statement 对象
jdbc 中的 statement 对象用于向数据库发送sql语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可
statement 对象的 executeUpdate() 方法，用于向数据库发送增、删、改的sql语句，executeUpdate()执行完成后，将会返回一个整数（即sql语句导致了数据库中的数据受影响的行数）
statement.executeQuery() 方法用于向数据库发送查询语句，executeQuery() 方法会返回代表查询结果的 ResultSet对象
创建几个工具类
使用文件连接
package com.lesson1.utils;
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 getConnection() throws SQLException {
return DriverManager.getConnection(url,username,password);
}
// 释放连接
public static void release(Connection cnn, 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 (cnn!=null){
try {
cnn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
curd - insert
package com.lesson1.utils;
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 cnn = null;
Statement st = null;
ResultSet rs = null;
try {
cnn = JDBCUtils.getConnection();
st = cnn.createStatement();
String sql = "INSERT INTO `garde`(`garde_name`) VALUES(\"赵六\")";
if (st.executeUpdate(sql)>0){
System.out.println("插入成功");
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
JDBCUtils.release(cnn,st,rs);
}
}
}
curd - update
package com.lesson1.utils;
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.getConnection();
st = conn.createStatement();
String sql = "UPDATE `garde` SET `garde_name` = \"七七\" WHERE `garde_id` = 2";
if (st.executeUpdate(sql)>0){
System.out.println("更新成功");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtils.release(conn,st,rs);
}
}
}
curd - delete
package com.lesson1.utils;
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 cnn = null;
Statement st = null;
ResultSet rs = null;
try {
cnn = JDBCUtils.getConnection();
st = cnn.createStatement();
String sql = "DELETE FROM `garde` WHERE `garde_id` = 2";
if (st.executeUpdate(sql)>0){
System.out.println("删除成功");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtils.release(cnn,st,rs);
}
}
}
curd - select
package com.lesson1.utils;
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 cnn = null;
Statement st = null;
ResultSet rs = null;
try {
cnn = JDBCUtils.getConnection();
st = cnn.createStatement();
String sql = "SELECT * FROM `garde`";
rs = st.executeQuery(sql);
while (rs.next()){
System.out.println("garde_id " + rs.getInt("garde_id"));
System.out.println("garde_name " + rs.getString("garde_name"));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtils.release(cnn,st,rs);
}
}
}
10.6、SQL 注入问题
SQL存在漏洞，会被攻击，导致数据泄露 SQL会被拼接 or
示例登录业务
package com.lesson1.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class SQLProblem {
public static void main(String[] args) {
// 正常登录
// login("qiqi","123456");
// 因为sql会被拼接
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.getConnection();
st = conn.createStatement();
String sql = "SELECT * FROM `testmd5` WHERE `name`= '"+ username +"' AND `pwd`= '"+ password +"'";
rs = st.executeQuery(sql);
while (rs.next()){
System.out.println(rs.getString("name"));
System.out.println(rs.getString("pwd"));
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
JDBCUtils.release(conn,st,rs);
}
}
}
10.7、prepareStatement 对象
prepareStatement 可以防止SQL注入，效率更好！
由于之前的工具类存在sql注入问题，所以这里使用prepareStatement优化代码
insert
package com.lesson2;
import java.sql.*;
public class TestInsert {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
conn = JDBCUtils.getConnection();
// 使用 ? 占位符 代替参数
String sql = "INSERT INTO `testmd5` VALUES(?,?,?)";
// 区别
st = conn.prepareStatement(sql); // 预编译SQL，先写SQL,然后不执行
// 手动给参数赋值
// st.setInt(参数位数,参数值);
st.setInt(1,7);
st.setString(2,"laoliu");
st.setString(3,"123456");
if (st.executeUpdate()>0){
System.out.println("插入成功");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtils.release(conn,st,rs);
}
}
}
update
package com.lesson2;
import java.sql.*;
public class TestUpdate {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
conn = JDBCUtils.getConnection();
String sql = "UPDATE `testmd5` SET `name` = ? WHERE `id`= ?";
st = conn.prepareStatement(sql);
st.setString(1,"小明");
st.setInt(2,1);
if (st.executeUpdate()>0){
System.out.println("更新成功");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtils.release(conn,st,rs);
}
}
}
delete
package com.lesson2;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class TestDelete {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
conn = JDBCUtils.getConnection();
String sql = "DELETE FROM `testmd5` WHERE id = ?";
st = conn.prepareStatement(sql);
st.setInt(1,1);
if (st.executeUpdate()>0){
System.out.println("删除成功");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtils.release(conn,st,rs);
}
}
}
select
package com.lesson2;
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.getConnection();
String sql = "SELECT * FROM `testmd5`WHERE id=?";
st = conn.prepareStatement(sql);
st.setInt(1,5);
rs = st.executeQuery();
while (rs.next()){
System.out.println("id " + rs.getInt("id"));
System.out.println("name " + rs.getString("name"));
System.out.println("pwd " + rs.getString("pwd"));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtils.release(conn,st,rs);
}
}
}
这里再次测试 sql 注入问题
package com.lesson2;
import java.sql.*;
public class SQLProblem {
public static void main(String[] args) {
// 正常登录是可以的
// login("qiqi","123456");
login("'or'1=1","'or' 1=1");
}
// 登录业务
public static void login(String username,String password){
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
conn = JDBCUtils.getConnection();
// prepareStatement 防止SQL注入的本质：把传递进来的参数当作字符
// 假设其中存在转义字符，比如 ' 会被直接转义
String sql = "SELECT * FROM `testmd5` WHERE `name`= ? AND `pwd`= ?";
st = conn.prepareStatement(sql);
st.setString(1,username);
st.setString(2,password);
rs = st.executeQuery();
while (rs.next()){
System.out.println("id " + rs.getInt("id"));
System.out.println("name " + rs.getString("name"));
System.out.println("pwd " + rs.getString("pwd"));
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
JDBCUtils.release(conn,st,rs);
}
}
}
运行结果
10.8、使用Idea 连接数据库
-- 插入语句测试
create table account(
`id` int(10) not null auto_increment,
`name` varchar(20) not null comment '用户名',
`money` decimal(9,2) not null comment '钱币',
primary key (id)
)engine=innodb default charset=utf8;
insert into account(name,money) values ('A',1000);
insert into account(name,money) values ('B',2000);
10.9、操作事务
回顾事务
要么成功，要么失败
ACID 原则
原子性：要么全部失败，要么全部成功
一致性：总数不变
隔离性：多个进程互不干扰
持久性：一旦提交不可逆，持久化到数据库中
隔离性的问题：
- 脏读：一个事务读取了另一个没有提交的事务
- 不可重复读：在同一个事务内，重复读取表中数据，表数据发生了改变
- 虚读（幻读）：在一个事务内，读取了别人插入的数据，导致前后读取不一致
package com.lesson3;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class TestTransaction {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
// 连接数据库
conn = JDBCUtils.getConnection();
// 关闭数据库自动提交 开启事务
conn.setAutoCommit(false);
// 执行语句
String sql1 = "update account set money = money-500 where `name`='A'";
st = conn.prepareStatement(sql1);
st.executeUpdate();
int x = 1/0;
String sql2 = "update account set money = money+500 where `name`='B'";
st = conn.prepareStatement(sql2);
st.executeUpdate();
// 业务完毕
// 提交
conn.commit();
} catch (SQLException e) {
// 如果失败，默认回滚 这里不写语句，默认也是自动回滚事务
try {
// 如果失败 回滚
conn.rollback();
} catch (SQLException ex) {
ex.printStackTrace();
}
e.printStackTrace();
} finally {
JDBCUtils.release(conn,st,rs);
}
}
}
运行结果：
步骤总结
- 关闭自动提交，开启事务 conn.setAutoCommit(false);
- 一组业务执行完毕，提交事务
- 可以在catch 语句中显示的定义 回滚语句，但默认失败就会回滚
10.10、数据库连接池
数据库连接 – 执行完毕 – 释放
连接 – 释放 十分浪费系统资源
池化技术：准备一些预先的资源，过来就连接预先准备好的
最小连接数：10
最大连接数：15
等待超时：100ms
编写连接池，实现一个接口 DataSource
开源数据实现
DBCP
C3P0
Druid：阿里巴巴
使用了这些数据库连接池之后，我们在项目开发中就不需要编写连接数据库的代码了
DBCP
需要用的 jar 包
commons-pool2-2.11.1.jar
commons-dbcp2-2.1.1.jar
commons-logging-1.2.jar
增加配置文件
package com.lesson4;
import org.apache.commons.dbcp2.BasicDataSource;
import org.apache.commons.dbcp2.BasicDataSourceFactory;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
public class JDBCUtils_DBCP {
private static BasicDataSource dataSource = null;
static {
try{
InputStream in = JDBCUtils_DBCP.class.getClassLoader().getResourceAsStream("db.properties");
Properties properties = new Properties();
properties.load(in);
// 创建数据源 工厂模式 --> 创建
dataSource = BasicDataSourceFactory.createDataSource(properties);
} catch (Exception e) {
e.printStackTrace();
}
}
// 获得连接
public static Connection getConnection() throws SQLException {
return dataSource.getConnection(); // 从数据源中获取连接
}
// 释放连接
public static void release(Connection cnn, 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 (cnn!=null){
try {
cnn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
测试连接
package com.lesson4;
import com.lesson2.JDBCUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class TestDBCP {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
conn = JDBCUtils_DBCP.getConnection();
// 使用 ? 占位符 代替参数
String sql = "INSERT INTO `testmd5` VALUES(?,?,?)";
// 区别
st = conn.prepareStatement(sql); // 预编译SQL，先写SQL,然后不执行
// 手动给参数赋值
// st.setInt(参数位数,参数值);
st.setInt(1,8);
st.setString(2,"laoliu");
st.setString(3,"123456");
if (st.executeUpdate()>0){
System.out.println("插入成功");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtils_DBCP.release(conn,st,rs);
}
}
}
C3P0
mchange-commons-java-0.2.19.jar
c3p0-0.9.5.5.jar
增加配置文件
package com.lesson4;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class JDBCUtil_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 dataSource.getConnection(); // 从数据源中获取连接
}
// 释放连接
public static void release(Connection cnn, 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 (cnn!=null){
try {
cnn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
package com.lesson4;
import com.lesson2.JDBCUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class TestC3P0 {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
conn = JDBCUtil_C3P0.getConnection(); // 原来是自己实现的，现在用别人实现的
// 使用 ? 占位符 代替参数
String sql = "INSERT INTO `testmd5` VALUES(?,?,?)";
// 区别
st = conn.prepareStatement(sql); // 预编译SQL，先写SQL,然后不执行
// 手动给参数赋值
// st.setInt(参数位数,参数值);
st.setInt(1,12);
st.setString(2,"laoliu");
st.setString(3,"123456");
if (st.executeUpdate()>0){
System.out.println("插入成功");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtil_C3P0.release(conn,st,rs);
}
}
}
结论
无论使用什么数据源，本质还是一样的， DataSource接口不会变，方法就不会变
ment;
public class JDBCUtil_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 dataSource.getConnection(); // 从数据源中获取连接
}
// 释放连接
public static void release(Connection cnn, 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 (cnn!=null){
try {
cnn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
```java
package com.lesson4;
import com.lesson2.JDBCUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class TestC3P0 {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
conn = JDBCUtil_C3P0.getConnection(); // 原来是自己实现的，现在用别人实现的
// 使用 ? 占位符 代替参数
String sql = "INSERT INTO `testmd5` VALUES(?,?,?)";
// 区别
st = conn.prepareStatement(sql); // 预编译SQL，先写SQL,然后不执行
// 手动给参数赋值
// st.setInt(参数位数,参数值);
st.setInt(1,12);
st.setString(2,"laoliu");
st.setString(3,"123456");
if (st.executeUpdate()>0){
System.out.println("插入成功");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtil_C3P0.release(conn,st,rs);
}
}
}
结论
无论使用什么数据源，本质还是一样的， DataSource接口不会变，方法就不会变