1.MySQL，JDBC

已于 2022-05-20 11:52:38 修改
阅读量359 收藏
点赞数 1
分类专栏： mysql 文章标签： mysql 数据库 database
于 2022-05-20 11:51:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56121715/article/details/124880694
版权

MySQL

MySQL，JDBC
内容所需要的所有依赖文件：在以下路径 嘿嘿~

https://download.csdn.net/download/weixin_56121715/85411373#

文章目录

1、初识MySQL

1.1、为什么学习数据库

  • 岗位需求
  • 现在的世界，大数据时代
  • 被迫需求，存数据
  • 数据库是所有软件体系中最核心的存在 DBA

1.2、什么是数据库

数据库：（DB，DataBase）

概念：数据仓库，软件，安装在操作系统之上的，SQL，可以存储大量的数据，500万！

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

DBMS

DBMS：数据库管理系统(DataBase Management System)

数据库管理软件，科学组织和存储数据，高效地获取和维护数据

image-20220422200858629

1.3、数据库分类

关系型数据库：（SQL）

  • MySQL，Oracle，Sql Server，DB2，SQLite
  • 通过表和表之间，行和列之间的关系进行数据的存储

非关系型数据库：（NoSQL）

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

1.4、MySQL 简介

image-20220422200944638

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 文件image-20220421224426193

6、管理员模式启动cmd 去到mysql\bin目录下运行 mysqld -installimage-20220421224131522

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、连接上测试以下结果就安装好了

image-20220422202724964

1.6、SQLyog

图形化管理MySQL数据库的软件工具

特点：简洁，易用，图形化

image-20220423163810180

使用SQLyog管理工具自己完成以下操作：

  • 连接本地MySQL数据库
  • 新建School数据库
    • 数据库名称School
    • 新建数据库表 student
    • 字段
      • id
      • name
      • age

image-20220423164421109

image-20220423165435974

在历史记录中可以看到相对应的数据库操作的语句

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 早些年使用的
*/
MYISAMINNODB
事务支持不支持支持
数据行锁定不支持支持
外键约束不支持支持
全文索引不支持支持
表空间的大小较小较大，约2倍

常规的使用操作：

  • MYISAM 节约空间，速度较快
  • INNODB 安全性高，事务的处理，多表多用户操作

在物理空间存在的位置

所有的数据库文件都存在 data 目录下
本质还是文件的存储

MySQL引擎在屋里文件上的区别

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

image-20220424163537440

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

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 表时，发现报错

image-20220424194029819

注意：在删除具有主外键关系的表时，要先删除子表，后删主表

由于每次都需要这样麻烦的删除，所以不推荐使用外键

-- 删除外键
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=6false
<> !=不等于5<>6true
>大于5>6false
<小于5<6true
>=大于等于5>=6false
<=小于等于5<=6true
between在某个范围之间between 5 and 10[5,10]
and与5>1 and 1>2false
or或5>1 or 1>2true
-- 更新年级信息，不加条件则修改所有数据
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即使左表中没有匹配，也从右表中返回所有的列数据

image-20220429145323425

inner join 查询俩个表中的结果集中的交集

image-20220429144738414

-- 查询所有员工的编号和姓名，薪水
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

会读取左边数据表的全部数据，即便右边表无对应数据

image-20220429144852840

-- 使用左外连查询
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

会读取右边数据表的全部数据，即使左边的表无对应数据

image-20220429145053026

-- 使用右外连查询
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 保存点名 -- 撤销保存点

事务的处理过程

image-20220514165425896

模拟转账

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 -- 恢复自动提交

image-20220515154117030

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),'123456879@qq.com',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`

对比查询的个数

image-20220515152841082

image-20220515152957030

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

7.3、索引原则

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

索引的数据结构

Hash 类型的索引

Btree：InnoDB 的默认数据结构

这里看大佬的文章：CodingLabs - MySQL索引背后的数据结构及算法原理

8、权限管理和备份

8.1、用户管理

SQL yog 可视化管理

image-20220515154823577

image-20220515154909031

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转储

      image-20220516185314270

  • 命令行导出

    # 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包，导入数据库驱动，添加到项目库中

image-20220516195420726

编写测试代码

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();
            }
        }

    }

}

步骤总结：

  1. 加载驱动
  2. 连接数据库 DriverManager
  3. 获得执行sql的对象 statement
  4. 获得返回的结果集
  5. 释放连接

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);
        }
    }
}

运行结果

image-20220518194410738

10.8、使用Idea 连接数据库

image-20220518195319736

image-20220518194820238

​ image-20220518201836479

image-20220518201929867

image-20220518202043451

-- 插入语句测试
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);
        }
    }
}

运行结果：

image-20220518205611687

步骤总结

  1. 关闭自动提交，开启事务 conn.setAutoCommit(false);
  2. 一组业务执行完毕，提交事务
  3. 可以在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接口不会变，方法就不会变

过来我的小熊
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
com.mysql.jdbc是什么,com.mysql.jdbc.Driver 和 com.mysql.cj.jdbc.Driver的区别
weixin_39613385的博客
04-01 2583
com.mysql.jdbc.Driver是 mysql-connector-java 5中的，com.mysql.cj.jdbc.Driver是 mysql-connector-java 6中的1、JDBC连接Mysql5com.mysql.jdbc.Driver:driverClassName=com.mysql.jdbc.Driverurl=jdbc:mysql://localhost...
已解决java.lang.ClassNotFoundException: com.mysql.jdbc.Driver
03-28 7万+
java.lang.ClassNotFoundException: com.mysql.jdbc.Driver 错误通常是由于缺少 MySQL 的 JDBC 驱动程序引起的。
com.mysql.jdbc.Driver 和 com.mysql.cj.jdbc.Driver的区别以及设定serverTimezone
热门推荐
Web3 & Basketball
12-06 24万+
如果未明确设置，MySQL 5.5.45+, 5.6.26+ and 5.7.6+版本默认要求建立SSL连接。如果你需要用SSL连接，就要为服务器证书验证提供信任库，并设置。是 mysql-connector-java 5中的，是 mysql-connector-java 6中的。不推荐不使用服务器身份验证来建立SSL连接。如果你不需要使用SSL连接，你需要通过设置。如果你有任何问题也可以私信我，看到后会回。为了符合当前不使用SSL连接的应用程序，但是你的driver用的还是。来显式禁用SSL连接。
com.mysql.jdbc.Driver和com.mysql.cj.jdbc.Driver的区别
Alice_799的博客
03-25 1万+
com.mysql.jdbc.Driver和com.mysql.cj.jdbc.Driver的区别
com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException异常解决方法
牧羊少年
05-05 14万+
在使用MySQL驱动进行JDBC时候出现了以下异常 Exception in thread "main" com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException: Could not create connection to database server. at sun.reflect.NativeConstru...
com.mysql.jdbc.Driver 和 com.mysql.cj.jdbc.Driver 的区别
hb1993的博客
05-13 2万+
概述：com.mysql.jdbc.Driver是mysql-connector-java 5中的，而com.mysql.cj.jdbc.Driver是mysql-connector-java 6中的。 1、JDBC连接Mysql5需用com.mysql.jdbc.Driver，例如： driverClassName=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding
com.mysql.cj.jdbc.Driver和com.mysql.jdbc.Driver区别
weixin_45980524的博客
06-01 1904
我在学习C3P0数据源时，在网上搜索一些解决方法是，经常遇到driverClass的值不一样，因为我对照着我的课本用的是比较老的mysql-connector-java5，所以经常看到com.mysql.cj.jdbc.Driver和com.mysql.jdbc.Driver，我就上网查询了一下。 com.mysql.jdbc.Driver驱动是mysql-connector-java 5中的 com.mysql.cj.jdbc.Driver驱动是mysql-connector-java 6以上版本的 1、
com.mysql.cj.jdbc.driver maven_com.mysql.jdbc.Driver和com.mysql.cj.jdbc.Driver的区别
weixin_31459571的博客
02-23 7901
概述：com.mysql.jdbc.Driver是mysql-connector-java 5中的，而com.mysql.cj.jdbc.Driver是mysql-connector-java 6中的。1、JDBC连接Mysql5需用com.mysql.jdbc.Driver，例如：driverClassName=com.mysql.jdbc.Driverurl=jdbc:mysql://loca...
com.mysql.jdbc.Driver与com.mysql.cj.jdbc.Driver区别
weixin_68107052的博客
08-19 2429
com.mysql.jdbc.Driver与com.mysql.cj.jdbc.Driver区别
com.mysql.jdbc.exceptions.jdbc4.CommunicationsException Communications link failure
爱因斯蛋的博客
10-21 1万+
老王一个错误改了一天,最后老师,我,老王一起改这个bug 一个bug解决了又一个bug,下面这个bug是我发现的,嘿嘿 有关数据库版本和URL安全的问题: 以下是报错.. com.mysql.jdbc.exceptions.jdbc4.CommunicationsException: Communications link failure The last packet successfully received from the server was 1,567 milliseconds ago. Th
解决Cause com.mysql.jdbc.exceptions.jdbc4.CommunicationsException
11-09
Cause com.mysql.jdbc.exceptions.jdbc4.CommunicationsException The last packet successfully received from the server was 47,795,922 milliseconds ago. The last packet sent successfully to the server was...
com.mysql.cj.jdbc.driver驱动下载
11-23
com.mysql.cj.jdbc.driver驱动下载
com.mysql.jdbc.Driver.zip
05-12
MySQL的JDBCjar包
com.springsource.com.mysql.jdbc-5.1.6.jar
03-03
jar包，官方版本，自测可用
在JPA项目启动时新增MySQL字段
VioletKiss
06-18 962
我用的方案1，如果你也是这种项目，那么我也推荐你用方案1，简单粗暴又方便；方案2是问了chatgpt得出来的答案，感觉不错，但是报错了又不想改；不建议使用 schema.sql 和 data.sql 对数据库结构及数据进行初始化，因为在每一次项目启动，这两个文件都必须执行一次，大大减慢了项目的启动速度，替代方案可以是使用 flyway 进行数据库版本控制。
mysqladmin——MySQL Server管理程序（二）
u011565038的博客
06-22 678
mysqladmin是一个命令行工具，用于执行简单的 MySQL 服务器管理任务，如检查服务器的状态、创建和删除数据库、重载权限等。
Mysql之GROUP BY与PARTITION BY区别
最新发布
m0_51014049的博客
06-22 240
PARTITION BY 是窗口函数的一部分，用于定义窗口（即数据分区），但是它不会改变结果集的行数。PARTITION BY 用于窗口函数内，将结果集划分为几个分区，计算聚合值或其他窗口函数。这个查询会返回每一行，并在每一行中增加一个列 totalAmount，它表示的是该 employee_id 内所有 amount 的总和。结果集：GROUP BY 改变结果集的行数，只返回每组一行。PARTITION BY 用于窗口函数，增加计算列，不改变结果集的结构。
MySQL-DML-约束
weixin_51788042的博客
06-18 624
创建表时，可以给表的字段添加约束，可以保证数据的完整性、有效性。以上的删除属于DML的方式删除，这种删除的数据是可以通过事务回滚的方式重新恢复的，但是删除的效率较低。另外还有一种删除表中数据的方式，但是这种方式不支持事务，不可以回滚，删了之后数据是永远也找不回来了。email字段设置为唯一性，唯一性的字段值是可以为NULL的。表名后面的小括号当中的字段名如果省略掉，表示自动将所有字段都列出来了，并且字段的顺序和建表时的顺序一致。注意：这个语句删除效率非常高，巨大的表，瞬间干掉所有数据。
com.mysql.jdbc.Driver 和 com.mysql.cj.jdbc.Driver
04-04
com.mysql.jdbc.Driver和com.mysql.cj.jdbc.Driver都是Java中用于连接MySQL数据库的驱动程序。 com.mysql.jdbc.Driver是旧版本的MySQL JDBC驱动程序，它是基于JDBC 3.0规范开发的。它提供了与MySQL数据库的连接和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值