MySQL基础学习

阿宁又菜又爱玩2025-12-01 18:25

MySQL基础学习

一、初识MySQL

  • JavaEE：企业级Java开发 Web
  • 前端（页面：展示 数据）
  • 后台（连接点：连接数据库JDBC，连接前端（控制，控制视图跳转，和给前端传递数据））
  • 数据库（存数据，Txt，Excel，Word）

1.1 为什么学习数据库

  1. 岗位需求
  2. 数据库是所有软件体系中最核心的存在

1.2 什么是数据库

  • 数据库（DB，database）
  • 概念：数据仓库，软件，安装在操作系统之上（Windows，Linux，Mac。。。） SQL，可以存储大量的数据
  • 作用：存储数据，管理数据

1.3 数据库分类

  • 关系型数据库（SQL）

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

  • 非关系型数据库（NoSQL，Not Only SQL）

    • Redis、MongDB
    • 对象存储，通过对象自身的属性来决定。

  • DBMS（数据库管理系统）

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

1.4 MySQL简介

  • MySQL是一个关系型数据管理系统
  • 开源
  • 体积小，速度快，总体拥有成本低

1.5 安装MySQL

VSCode的安装及配置MySQL数据源_vscode mysql-CSDN博客

  • 一些注意事项：

    • 新建的my.ini配置文件中不要放skip-grant-tables，MySQL会启动不成功
    • 要用管理员模式启动cmd
    • 启动mysql时，在C:\WINDOWS\system32下，即初始目录直接 net start mysql即可
    • 命令一定要分号结尾，不然mysql不会运行
    • 登录： mysql -u root -p
    • 清空服务：sc delete mysql

1.6 安装Navicat

【2025版】超详细Navicat+MySQL安装保姆级教程，永久免费使用，数据库环境配置和使用指南，看完这一篇就够了_navicat免费版-CSDN博客

  1. 新建一个数据库school

    • ctrl+L调出历史记录

  2. 添加表和记录

1.8 连接数据库

  • 命令行连接

    mysql 复制代码 
    mysql -uroot -p123456    -- 连接数据库

--------------------------------------
-- 所有语句都使用分号结尾
show database;  -- 查看所有的数据库

mysql> use school
Database changed    -- 切换数据库 use 数据库名

show tables;    -- 查看数据库中所有的表
describe student;  -- 显示数据库中所有的表的信息

create database westos; -- 创建一个数据库

exit;  -- 退出连接

# 单行注释
-- 单行注释（SQL 原有的注释）
/*
sql的多行注释
*/

  • DDL 定义

  • DML 操作

  • DQL 查询

  • DCL 控制

二、操作数据库

2.1 操作数据库

  1. 创建数据库

    mysql 复制代码 
    CREATE DATABASES IF NOT EXISTS westos；

  2. 删除数据库

    mysql 复制代码 
    DROP DATABASE westos;

  3. 使用数据库

    mysql 复制代码 
    -- 如果你的表名或者字段是一个特殊字符，就需要带  ` `
USE `school`;

  4. 查看数据库

    mysql 复制代码 
    SHOW DATABASES; -- 查看所有的数据库

2.2 数据库的列数据

  • 数值

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

  • 字符串

    • char 字符串 固定大小的 0-255
    • varchar 可变字符串 0-65535 常用的变量 String
    • tinytext 微型文本 2^8-1
    • text 文本串 2^16-1 保存大文本

  • 时间日期

    java.util.Date

    • date YYYY-MM-DD 日期格式
    • time HH: mm: ss 时间格式
    • datetime YYYY-MM-DD HH: mm: ss 最常用的时间格式
    • timestamp 时间戳， 1970.1.1到现在的毫秒数！
    • year 年份表示

  • null

    • 没有值，未知
    • -- 注意 不要使用null进行运算，结果为null，无意义

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

Unsigned：

  • 无符号的整数
  • 不能声明为负数

zerofill：

  • 0填充的
  • 不足的位数，使用0来填充：int(3) , 5-->005

自增：

  • 通常理解为自增，自动在上一条记录的基础上+1（默认）
  • 通常用来设计唯一的主键 index，必须是整数类型
  • 可以自定义设计主键自增的初始值和步长

非空 NULL not NULL

  • 假设设置为 not null，如果不给他赋值，就会报错！
  • NULL， 如果不填写值，默认就是null！

默认：

  • 设置默认的值！
  • sex，默认值为 男，如果不指定该列的值，则会有默认的值。

拓展：

mysql 复制代码 
/*
每一个表都必须存在以下五个字段！
未来项目用，表示一个记录存在的意义！
id 主键
`version`			乐观锁
is_delete			伪删除
gmt_create		创建时间
gmt_update		修改时间
*/

2.4 创建数据库表（重点）

mysql 复制代码 
-- 目标 ：创建一个school数据库
-- 创建学生表（列，字段）  使用SQL创建
-- 学号int，登录密码varchar（20） 姓名，性别（2），出生日期（datetime），家庭住址，email
-- 注意点，使用英文括号，表的名称和字段，尽量使用``括起来

-- AUTO_INCREMENT 自增

-- 字符串使用单引号括起来
-- 所有的语句后面加英文逗号
-- PRIMARY KEY  主键，一个表只有唯一主键
CREATE DATABASE IF NOT EXISTS `school`;

CREATE TABLE IF NOT EXISTS `student`(
	`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
	`name` VARCHAR(30) NOT NULL DEFAULT '匿名' COMMENT '姓名',
	`pwd` VARCHAR(20) NOT NULL DEFAULT '123456' COMMENT '密码',
	`sex` VARCHAR(2) NOT NULL DEFAULT '男' COMMENT '性别',
	`birthday` DATETIME DEFAULT NULL COMMENT '出生日期',
	`address` VARCHAR(100) DEFAULT NULL COMMENT '家庭住址',
	`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
	PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8

格式

mysql 复制代码 
CREATE TABLE [IF NOT EXISTS] `表名`(
	`字段名` 列类型 [属性] [索引] [注释],
    ......
    `字段名` 列类型 [属性] [索引] [注释]
)[表类型][字符集设置][注释]

常用命令

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

2.5 数据表的类型

mysql 复制代码 
-- 关于数据库引擎
/*
INNODB 默认使用
MYISAM 早些年使用
*/
MYISAM INNODB
事务支持 不支持 支持
数据行锁定 不支持 支持
外键约束 不支持 支持
全文索引 支持 不支持

常规使用操作：

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

在物理空间存在的位置

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

  • 本质还是文件的存储！

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

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

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

mysql 复制代码 
CHARSET=utf8

  • 不设置的话，会是MySQL默认的字符集编码（不支持中文）

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

    mysql 复制代码 
    character-set-server=utf8

2.6 修改删除表

mysql 复制代码 
-- 修改表名
ALTER TABLE teacher RENAME AS teacher1;
-- 增加表的字段  ALTER TABLE 表名 ADD 字段名
ALTER TABLE teacher1 ADD age INT(11);
-- 修改表的字段 （重命名，修改约束）
-- ALTER TABLE 表名 MODIFY 字段名 列属性[];
ALTER TABLE teacher1 MODIFY age VARCHAR(11);  -- 修改约束
-- ALTER TABLE 表名 MODIFY 旧名字 新名字 列属性[];
ALTER TABLE teacher1 CHANGE age age1 INT(1);  -- 字段重命名


-- 删除表的字段
-- ALTER TABLE 表名 DROP 字段名;
ALTER TABLE teacher1 DROP age1;

-- 删除表（如果表存在再删除）
DROP TABLE IF EXISTS teacher1;

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

  • sql 关键字大小写不敏感，建议小写

  • 所有符号用英文

三、MySQL数据管理

3.1 外键（了解即可）

  • 方式一：在创建表的时候，增加约束（比较麻烦）

    mysql 复制代码 
    CREATE TABLE `grade`(
	`gradeid` INT(10) NOT NULL AUTO_INCREMENT COMMENT '年级id',
	`gradename` VARCHAR(5) NOT NULL COMMENT '年级名称',
	PRIMARY KEY(`gradeid`) 
)ENGINE=INNODB DEFAULT CHARSET=utf8


-- 学生表的gradeid 字段，要去引用年级表的gradeid
-- 定义外键key
-- 给这个外键添加约束
CREATE TABLE IF NOT EXISTS `student`(
	`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
	`name` VARCHAR(30) NOT NULL DEFAULT '匿名' COMMENT '姓名',
	`pwd` VARCHAR(20) NOT NULL DEFAULT '123456' COMMENT '密码',
	`sex` VARCHAR(2) NOT NULL DEFAULT '男' COMMENT '性别',
	`gradeid` INT(10) NOT NULL COMMENT '学生的年级',
	`birthday` DATETIME DEFAULT NULL COMMENT '出生日期',
	`address` VARCHAR(100) DEFAULT NULL COMMENT '家庭住址',
	`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
	PRIMARY KEY(`id`),
	KEY `FK_gradeid`(`gradeid`),
	CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade`(`gradeid`)
)ENGINE=INNODB DEFAULT CHARSET=utf8
    • 删除有外键关系的表的时候，必须要先删除引用别人的表（从表），再删除被引用的表（主表）

  • 方式二：创建表后添加外键约束

    mysql 复制代码 
    CREATE TABLE `grade`(
	`gradeid` INT(10) NOT NULL AUTO_INCREMENT COMMENT '年级id',
	`gradename` VARCHAR(5) NOT NULL COMMENT '年级名称',
	PRIMARY KEY(`gradeid`) 
)ENGINE=INNODB DEFAULT CHARSET=utf8


-- 学生表的gradeid 字段，要去引用年级表的gradeid
-- 定义外键key
-- 给这个外键添加约束
CREATE TABLE IF NOT EXISTS `student`(
	`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
	`name` VARCHAR(30) NOT NULL DEFAULT '匿名' COMMENT '姓名',
	`pwd` VARCHAR(20) NOT NULL DEFAULT '123456' COMMENT '密码',
	`sex` VARCHAR(2) NOT NULL DEFAULT '男' COMMENT '性别',
	`gradeid` INT(10) NOT NULL COMMENT '学生的年级',
	`birthday` DATETIME DEFAULT NULL COMMENT '出生日期',
	`address` VARCHAR(100) DEFAULT NULL COMMENT '家庭住址',
	`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
	PRIMARY KEY(`id`)
-- 	KEY `FK_gradeid`(`gradeid`),
-- 	CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade`(`gradeid`)
)ENGINE=INNODB DEFAULT CHARSET=utf8


-- 创建表的时候没有外键关系
ALTER TABLE `student`
ADD CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade`(`gradeid`);

  • 以上操作都是物理外键，数据库级别的外键，我们不建议使用，避免数据库过多造成困扰

  • 最佳实践：

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

3.2 DML语言（全部记住）

  • insert
  • update
  • delete

3.3 添加

mysql 复制代码 
-- 插入语句（添加）
-- inseart into 表名(`字段名1`) values('值1'),('值2'),('值3')
INSERT INTO `grade` (`gradename`) VALUES ('大四')


-- 由于主键自增，我们可以省略 （如果不写表的字段，他就会一一匹配）
INSERT INTO `grade` VALUES ('大三')  -- 报错

-- 一般写插入语句，我们一定要数据和字段一一对应

-- 插入多个字段
INSERT INTO `grade` (`gradename`) 
VALUES ('大一'), ('大二')

INSERT INTO `student` (`name`) VALUES ('张三')

INSERT INTO `student` (`name`,`pwd`,`sex`) 
VALUES ('李四','12321','女')

注意事项：

  • 字段和字段之间使用 英文逗号 隔开
  • 字段是可以省略的，但是后面的值必须要一一对应，不能少
  • 可以同时插入多条数据，values后面的值，需要使用逗号 , 隔开即可 ：VALUES (),()

3.4 修改

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

mysql 复制代码 
-- 修改学员名字
UPDATE `student` SET `name` = '托尼' WHERE id = 1;

-- 不指定条件的情况下，会改动所有表！
UPDATE `student` SET `name` = '斯塔克';


-- 语法
-- 	UPDATE 表名 SET column_name = value where[条件];

-- 修改多个属性，逗号隔开
UPDATE `student` SET `name` = '某某',`email` = '564789@qq.com' WHERE id = 1;
  • 条件， where 子句 运算符 id等于某个值，大于某个值，在某个区间内修改
mysql 复制代码 
-- 通过多个条件定位数据
UPDATE `student` SET `name` = 'xxx' WHERE `name` = '张三' AND sex = '女';

-- 语法
-- UPDATE 表名 SET column_name = value WHERE [条件];

注意：

  • column_name是数据库的列，尽量带上 ``
  • 条件筛选，如果没有指定，则会修改所有的列
  • value 可以是一个具体的值，也可以是一个变量
  • 多个设置的属性之间，使用英文逗号隔开

3.5 删除

mysql 复制代码 
-- 语法
-- delete from 表名 [where]

-- 全部删除数据
DELETE FROM `student`;

-- 删除指定数据
DELETE FROM `student` WHERE id = 1;

TRUNCATE 命令

  • 作用：完全清空一个数据库表，表的结构和索引约束不会变！
mysql 复制代码 
-- 清空 student 表
TRUNCATE `student`;
  • 相同点，都能删除数据，都不会删除表结构
  • 不同点：
    • TRUNCATE 重新设置 自增列，计数器会归零
    • TRUNCATE 不会影响事务

四、DQL查询数据（重点）

4.1 DQL

（Data Query LANGUAGE: 数据查询语言）

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

4.2 指定查询字段

mysql 复制代码 
-- 查询全部的学生
SELECT * FROM student;
SELECT * FROM result;

-- 查询指定字段
SELECT `studentno` , `studentname` FROM student;


-- 别名，给结果起一个名字  可以给字段起别名，也可以给表起别名
SELECT `studentno` AS 学号,`studentname` AS 学生姓名 FROM student AS s;

-- 函数  CONCAT(a,b)
SELECT CONCAT('姓名: ',studentname) AS 新名字 FROM student;

有时候，列的名字不是那么见名知意，我们起别名 AS 字段名 as 别名 表名 as 别名
去重 distinct

mysql 复制代码 
-- 查询一下有哪些同学参加了考试，成绩
SELECT * FROM result;  --  查询全部的考试成绩
-- 查询有哪些同学参加了考试
SELECT `studentno` from result;
-- 发现重复数据，去重
SELECT DISTINCT `studentno` FROM result;
  • 作用：去除select查询出来的结果中的重复的数据，重复的数据只显示一条

数据库的列（表达式）

mysql 复制代码 
SELECT VERSION();    -- 查询系统版本  （函数）
SELECT 100*3-1 as 计算结果; --  用于计算（表达式）
SELECT @@auto_increment_increment;    -- 查询自增的步长（变量）

-- 学员考试成绩+1分查看
SELECT `studentno`,`studentresult`+1 AS '提分后' FROM result;
  • 数据库中的表达式：文本值，列， null，函数，计算表达式，系统变量......

4.3 where 条件子句

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

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

mysql 复制代码 
-- 查询考试成绩在  95-100 分之间
SELECT studentno, `studentresult` FROM result WHERE studentresult>=95 and studentresult<=100;

-- and   &&
SELECT studentno,`studentresult` FROM result WHERE studentresult>80 && studentresult<100;

-- 模糊查询（区间）
SELECT studentno, `studentresult` FROM result WHERE studentresult BETWEEN 80 AND 100; 

-- !=   NOT
SELECT studentno, `studentresult` FROM result WHERE studentno!=1000;
-- WHERE NOT studentno = 1000;

模糊查询：本质是比较运算符

mysql 复制代码 
-- ========================  模糊查询 ====================
-- 查询姓刘的同学
-- like结合  % （代表0到任意个字符）     _（一个字符）
SELECT studentno,`studentname` FROM `student` WHERE `studentname` like '赵%';
SELECT studentno,`studentname` FROM `student` WHERE `studentname` like '赵_';

-- 查询名字中有强字的同学  %强%


-- ============ in ============
SELECT studentno,`studentname` FROM `student` WHERE studentno IN (1001,1002,1003);


-- 查询地址为空的学生  NUL ''
SELECT studentno, `studentname` FROM `student` WHERE address='' OR address IS NULL;
-- 不为空  IS NOT NULL

4.4 联表查询

mysql 复制代码 
/*
1. 分析需求，分析查询的字段来自哪些表
2. 确定使用哪种连接查询，确定交叉点（两表中，哪些数据相同）
3.判断的条件：学生表的中 studentno = 成绩表 studentno

*/

SELECT s.studentno,`studentname`,subjectno,studentresult
FROM student AS s
INNER JOIN result AS r
WHERE s.studentno = r.studentno;

-- RIGHT JOIN
SELECT s.studentno,`studentname`,subjectno,studentresult
FROM student AS s 
RIGHT JOIN result AS r
ON s.studentno = r.studentno;


-- LEFT JOIN
SELECT s.studentno,`studentname`,subjectno,studentresult
FROM student AS s 
LEFT JOIN result AS r
ON s.studentno = r.studentno;

-- 查询缺考的同学
SELECT s.studentno,`studentname`,subjectno,studentresult
FROM student AS s 
LEFT JOIN result AS r
ON s.studentno = r.studentno;
WHERE studentresult IS NULL
操作 描述
inner join 如果表中至少有一个匹配，就返回行
right join 会从右表中返回所有的值，即使右表中没有匹配
left join 会从左表中返回所有的值，即使左表中没有匹配
mysql 复制代码 
-- 思考题 查询了参加考试的同学信息：学号 姓名 科目名 分数
SELECT stu.studentno,`studentname`,`subjectname`,r.studentresult
FROM student AS stu
RIGHT JOIN result AS r
ON r.studentno = stu.studentno
INNER JOIN `subject` AS sub
ON r.subjectno = sub.subjectno;

自连接

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

  • 父类
categoryid categoryName
2 信息技术
3 软件开发
5 美术设计
  • 子类
pid categoryid categoryName
3 4 数据库
2 8 办公信息
3 6 web开发
5 7 美术设计

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

父类 子类
信息技术 办公信息
软件开发 数据库
软件开发 web开发
美术设计 美术设计
mysql 复制代码 
-- 查询父子信息
SELECT a.`categoryname` AS '父类',b.`categoryname` AS '子类'
FROM `category` AS a,`category` AS b
WHERE a.category = b.pid

4.5 分页和排序

排序

mysql 复制代码 
-- 排序 ： 升序 ASC  降序  DESC
-- ORDER BY 通过字段排序

SELECT s.studentno,`studentname`,`subjectname`,`studentresult`
FROM student AS stu
INNER JOIN `result` AS r
ON stu.studentno = r.studentno
INNER JOIN `subject` AS sub
ON r.subjectno = sub.subjectno
WHERE subjectname = '数据库结构-1'
ORDER BY studentresult ASC

分页

mysql 复制代码 
-- 为什么要分页
-- 缓解数据库压力，给人的体验更好

-- 分页，每页只显示五条数据
-- 语法：limit  起始值  页面的大小
SELECT s.studentno,`studentname`,`subjectname`,`studentresult`
FROM student AS stu
INNER JOIN `result` AS r
ON stu.studentno = r.studentno
INNER JOIN `subject` AS sub
ON r.subjectno = sub.subjectno
WHERE subjectname = '数据库结构-1'
ORDER BY studentresult ASC
LIMIT 0,5

-- 第一页  limit 0,5    (1-1)*5
-- 第二页  limit 5,5    (2-1)*5
-- 第三页  limit 10,5    (3-1)*5
-- 第n页  limit 0,5    (n-1)*pagesize, pagesize

-- pagesize: 页面大小
-- (n-1)*pagesize：起始值
-- n：当前页
-- 数据总数/页面大小 = 总页数

4.6 子查询

mysql 复制代码 
-- 1. 查询数据库结构-1 的所有考试结果（学号，科目编号，成绩），降序排序
-- 方式一： 使用连接查询
SELECT studentno，sub.subjectno,studentresult
FROM `result` AS r
INNER JOIN `subject` AS sub
ON r.subjectno = sub.subjectno
WHERE subjectname = '数据库结构-1'
ORDER BY studentresult DESC

-- 方式二：使用子查询
-- 查询所有数据库结构-1的学生学号
SELECT studentno,subjectno, `studentresult`
FROM `result`
WHERE subjectno = (
    SELECT subjectno FROM subject
	WHERE subjectname = '数据库结构-1'
)

-- 分数不小于80分的学生的学号和姓名
SELECT DISTINCT stu.studentno,`studentname`
FROM student AS stu
INNER JOIN result AS r
ON r.studentno = stu.studentno
WHERE `studentresult`>=80

-- 在这个基础上增加一个科目，高等数学-2
-- 查询 高等数学-2 的编号
SELECT DISTINCT stu.studentno,`studentname`
FROM student AS stu
INNER JOIN result AS r
ON r.studentno = stu.studentno
WHERE `studentresult`>=80 AND studentno = (
	SELECT subjectno FROM `subject`
    WHERE `subjectname` = '高等数学-2'
)

五、MySQL函数

5.1 常用函数

MySQL常用函数(总结)详细版_mysql字符函数大全-CSDN博客

5.2 聚合函数（常用）

函数名称 描述
COUNT() 计数
SUM() 求和
MAX() 平均值
MIN() 最大值
... 最小值
mysql 复制代码 
SELECT COUNT(studentname) FROM studednt; -- count(指定列) 会忽略所有的null值
SELECT COUNT(*) FROM student;   -- 不会忽略 null 包括所有列 计算行数
SELECT COUNT(1) FROM result;    -- 包括了忽略所有列 用1代表代码行 计算行数 不会忽略所有的null值
mysql 复制代码 
-- 分组和过滤
SELECT SUM(`studentresult`) AS 总和 FROM result;
SELECT AVG(`studentresult`) AS 平均分 FROM result;
SELECT MAX(`studentresult`) AS 最高分 FROM result;
SELECT MIN(`studentresult`) AS 最低分 FROM result;

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

select小结：

mysql 复制代码 
SELECT [ALL | DISTINCT]
{* | table.* | [table.field1[as alias1],[table.field2 [as alias2]][.....]]}
FROM table_name AS xxx 
LEFT|RIGHT|INNER| JOIN table_name2 -- 联合查询
WHERE ...    -- 指定结果需满足的条件
GROUP BY ...	-- 制定结果按照哪几个字段来分组
HAVING ...		-- 过滤分组的记录必须满足的次要条件
ORDER BY ...	-- 指定查询记录按一个或多个条件排序
LIMIT {[offset,]row_count | row_countOFFSET offset};
-- 指定查询的记录从哪条至哪条

六、事务

6.1 什么是事务

  • 确保一组操作要么都成功，要么都失败
    1. SQL 执行，A给B转账， A 1000 (转账200给 B) B 200
    2. SQL 执行，B收到A的钱 A 800 B 400
  • 将一组SQL放在一个批次中去执行

事务原则：ACID原则

  • **原子性：**针对同一事务，两个步骤要么一起成功，要么一起失败，不能只发生其中一个动作。
  • **一致性：**针对一个事务操作前与操作后的状态一致。
  • **隔离性：**针对多个用户同时操作，主要是排除其他事务对本次事务的影响。
    • 脏读：指一个事务读取了另一个事务未提交的数据
    • 不可重复度：在一个事务内读取表中的某一行数据，多次读取结果不同。不一定是错误，只是某些场合不对
    • 虚读（幻读）：是指在一个事务内读取到了别的事务插入的数据，导致前后读取不一致，一般是行影响。
  • **持久性：**表示事务结束后的数据不随着外界原因导致数据丢失。
    • 事务没有提交，恢复到原状
    • 事务已经提交，持久化到数据库

6.2 执行事务

mysql 复制代码 
-- mysql 是默认开启事务自动提交的
SET autocommit = 0; /* 关闭 */
SET autocommit = 1; /* 开启（默认） */
-- 手动处理事务
-- 事务开启
START TRANSACTION -- 标记一个事务的开始，从这个之后的额sql都在同一个事务内

INSERT XX;
INSERT XX;

-- 提交：持久化（成功）
COMMIT
-- 回滚：回到原来的样子（失败）
ROLLBACK
-- 事务结束
SET autocommit = 1； -- 开启自动提交

-- 了解
SAVEPOINT 保存点名  -- 设置一个事务的保存点
ROLLBACK TO SAVEPOINT 保存点名 -- 回滚到保存点
RELEASE SAVEPOINT 保存点名  --  撤销保存点

模拟场景

mysql 复制代码 
-- 转账
CREATE DATABASE shop CHARACTER SET utf8 COLLATE utf8_general_ci
USE shop

CREATE TABLE `account`(
	`id` INT(3) NOT NULL AUTO_INCREMENT,
    `name` VARCHAR(30) NOT NULL,
    `money` DECIMAL(9,2) NOT NULL,
    PRIMARY KEY(`id`)
)ENGIN=INNODB DEFAULT CHARSET=utf8

INSERT INTO account(`name`,`money`)
VALUES (`A`,2000.00),(`B`,10000.00);

-- 模拟转账：事务
SET autocommit = 0; -- 关闭自动提交
START TRANSACTION -- 开启一个事务
UPDATE account SET money=money-500 WHERE `name` = 'A'; -- A支出500
UPDATE account SET money=money+500 WHERE `name` = 'B'; -- B收入500
COMMIT; -- 提交事务，被持久化
ROLLBACK;  -- 回滚
SET autocommit = 1;  -- 恢复默认值

七、索引

MySQL官方对索引的定义为：索引（index）是帮助MySQL高效获取数据的数据结构，提取句子主干，就可以得到索引的本质：索引是数据结构。

7.1 索引的分类

  • 主键索引 PRIMARY KEY
    • 唯一的标识，主键不可重复，只能有一个列作为主键
  • 唯一索引 UNIQUE KEY
    • 避免重复的列出现，唯一索引可以重复，多个列都可以标识位 唯一索引
  • 常规索引 KEY/INDEX
    • 默认的，index key关键字来设置
  • 全文索引 FullText
    • 在特定的数据库引擎下才有 MyISAM
    • 快速定位数据
mysql 复制代码 
-- 索引的使用
-- 1. 创建表的时候给字段增加索引
-- 2. 创建完毕后，增加索引
-- 显示所有的索引信息
SHOW INDEX FROM student

-- 增加一个全文索引
ALTER TABLE school.student ADD FULLTEXT INDEX `studentname`(`studentname`);

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

SELECT * FROM student WHERE MATCH(studentname) AGAINST('张');

7.2 测试索引

插入一百万数据

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

SELECT mock_data();

索引查找

mysql 复制代码 
-- 直接查询很慢

-- id_表名_字段名
-- CREATE INDEX 索引名 on 表（字段）
CREATE INDEX id_app_user_name ON app_user(`name`);

SELECT * FROM app_user WHERE `name` = '用户9999';
EXPLAIN SELECT * FROM app_user WHERE `name` = '用户9999'; -- 秩序一行

7.3 索引原则

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

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

8.1 用户管理

8.2 SQL 命令操作

  • 用户表： mysql.user
    • 本质，对这张表进行增删改查
mysql 复制代码 
-- 创建用户 CREATE USER 用户名 INDENTIFIED BY 密码
CREATE USER xxx IDENTIFIED BY '123456';

-- 修改密码（修改当前用户密码）
SET PASSWORD ='111111'

-- 修改指定用户密码
SET PASSWORD FOR 'zcn'@'127.0.0.1' = '123456';
SET PASSWORD FOR 'xxx'@'%' = '123456';

-- 用户重命名
RENAME USER xxx TO xxx2;

-- 用户授权
-- ALL PRIVILEGES 除了给别人授权，其他都能干
GRANT ALL PRIVILEGES ON *.* TO xxx2;

-- 查询权限
SHOW GRANTS FOR xxx2;  -- 查看指定用户的权限
SHOW GRANTS FOR root@localhost;
-- root用户权限：GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' WITH GRANT OPTION

-- 撤销权限 REVOKE
REVOKE ALL PRIVILEGES ON *.* FROM xxx2;

-- 删除用户
DROP USER xxx2;

8.3 MySQL备份

  • 保证重要的数据不丢失
  • 数据转移

MySQL数据库备份的方式：

  • 直接拷贝物理文件

  • 在navicat这种可视化工具中手动导出

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

    bash 复制代码 
    # mysqldump -h 主机 -u 用户名 -p 密码  数据库 表名1 表名2 表名3 >  物理磁盘位置/文件名
mysqldump -hlocalhost -uroot -p123456 school student >D:/a.sql

# 导入
# 登录的情况下，切换到指定的数据库
source 备份文件

九、规范数据库设计

9.1 为什么需要设计

当数据库比较复杂时，需要设计

良好的数据库设计：

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

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

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

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

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

9.2 三大范式

为什么需要数据规范化？

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

三大范式

第一范式

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

第二范式

  • 前提：满足第一范式
  • 每张表只描述一件事情

第三范式

  • 前提：满足第一范式和第二范式
  • 第三范式需要保证数据表中的每一列数据都和主键直接相关，而不能间接相关。

规范性和性能问题

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

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

--- 业务级别 MySQL学习

十、JDBC（重点）

10.1 数据库驱动

  • 驱动：声卡，显卡，数据库
  • 我们的程序会通过数据库驱动，和数据库打交道

10.2 JDBC

  • SUN公司为了简化开发人员的（对数据库的统一）操作，提供了一个（Java操作数据库的）规范，俗称JDBC，这些规范的实现由具体的厂商去做~
  • 对于开发人员来说，我们只需要掌握JDBC接口的操作即可

10.3 第一个JDBC程序

mysql 复制代码 
CREATE DATABASE `jdbcStudy` CHARACTER SET utf8 COLLATE utf8_general_ci;

USE `jdbcStudy`;

CREATE TABLE `users`(
`id` INT PRIMARY KEY,
`NAME` VARCHAR(40),
`PASSWORD` VARCHAR(40),
`email` VARCHAR(60),
birthday DATE
);

INSERT INTO `users`(`id`,`NAME`,`PASSWORD`,`email`,`birthday`)
VALUES('1','zhangsan','123456','zs@sina.com','1980-12-04'),
('2','lisi','123456','lisi@sina.com','1981-12-04'),
('3','wangwu','123456','wangwu@sina.com','1979-12-04')

  1. 创建一个普通项目

  2. 导入数据库驱动

    • VScode在左侧找到Java Projects，有个Referecned Libraries，导入对应的数据库驱动文件（*.jar)

  3. 编写测试代码

java 复制代码 
package com.zcn.lesson01;

import java.sql.*;

public class Jdbc1stDemo {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // 1. 加载驱动
        Class.forName("com.mysql.cj.jdbc.Driver"); // 固定写法，加载驱动

        // 2. 用户 信息 url
        String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=UTC";
        String username = "root";
        String password = "123456";

        // 3. 连接成功，数据库对象 connection 代表数据库
        Connection connection = DriverManager.getConnection(url, username, password);

        // 4. 执行SQL的对象 statement 执行sql对象
        Statement statement = connection.createStatement();

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

        ResultSet resultSet = statement.executeQuery(sql); // 返回的结果集 结果集中封装了我们全部的查询出来的结果

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

        // 6. 释放连接
        resultSet.close();
        statement.close();
        connection.close();

    }
}
  • 步骤总结：
    1. 加载驱动
    2. 连接数据库DriverManager
    3. 获得执行sql的对象 Statement
    4. 获得返回的结果集
    5. 释放连接

DriverManager

java 复制代码 
// DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Class.forName("com.mysql.cj.jdbc.Driver"); // 固定写法，加载驱动


// connection代表数据库
// 数据库设置自动提交
Connection connection = DriverManager.getConnection(url, username, password);
// 事务提交
// 事务回滚

URL

java 复制代码 
String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=UTC";

// mysql 默认端口 3306
// 协议//localhost:3306/数据库名?参数1&参数2&参数3

// oralce  默认端口 1521
// jdbc:oracle:thin:@localhost:1521:sid

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

java 复制代码 
String sql = "SELECT * FROM users"; // 编写SQL

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

resultSet查询的结果集：封装了所有的查询结果

  • 获取数据类型
java 复制代码 
ResultSet resultSet = statement.executeQuery(sql); // 返回的结果集 结果集中封装了我们全部的查询出来的结果
resultSet.getObject();  // 在不知道列类型的情况下使用
resultSet.getString();
resultSet.getInt();
resultSet.getFloat();
resultSet.getDate();
......
  • 遍历
java 复制代码 
resultSet.beforeFirst();  // 移动到最前面
resultSet.afterLast();    // 移动到最后面
resultSet.next();         // 移动到下一个数据
resultSet.previous();     // 移动到前一行
resultSet.absolute(row);  // 移动到指定行

释放资源

java 复制代码 
// 6. 释放连接
resultSet.close();
statement.close();
connection.close();

10.4 statement 对象

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

CRUD操作-create

  • 使用executeUpdate（String sql）方法完成数据添加操作，示例：
java 复制代码 
Statement st = conn.createStatement();
String sql = "insert into user(...) values(...)";
int num = st.executeUpdate(sql);
if(num>0){
    System.out.println("插入成功！！！");
}

CRUD操作-read

  • 使用executeQuery(String sql)方法完成数据查询操作，示例操作：
java 复制代码 
Statement st = conn.createStatement();
String sql = "SELECT * FROM users WHERE id=1";
ResultSet rs = st.executeQuery(sql);
while(rs.next()){
    // 根据获取列的类型数据，分别调用rs的相应方法映射到java对象中
}

代码实现

  1. 提取工具类

    java 复制代码 
    driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC
username=root
password=123456
    java 复制代码 
    package com.zcn.lesson02.utils;

import java.util.Properties;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.io.IOException;

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

            // 1. 驱动只用加载一次
            Class.forName(driver);

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

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

    }

    // 释放连接
    public static void release(Connection conn, Statement st, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (st != null) {
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

}

  2. 编写增删改的方法，使用executeUpdate

    java 复制代码 
    package com.zcn.lesson02;

import com.zcn.lesson02.utils.JdbcUtils;
import java.sql.*;

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

        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection(); // 获取数据库连接
            st = conn.createStatement(); // 获取SQL执行对象
            String sql = "INSERT INTO users(id,`NAME`,`PASSWORD`,`email`,`birthday`)" +
                    "VALUES(4,'xxx','123456','99998888@qq.com','2025-11-28')";

            int i = st.executeUpdate(sql);
            if (i > 0) {
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

  3. 查询

    java 复制代码 
    package com.zcn.lesson02;

import java.sql.Statement;

import com.zcn.lesson02.utils.JdbcUtils;

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

public class TestSelect {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();
            st = conn.createStatement();

            // SQL
            String sql = "SELECT * FROM users WHERE id = 1";

            rs = st.executeQuery(sql);

            while (rs.next()) {
                System.out.println(rs.getString("NAME"));
            }

        } catch (SQLException E) {
            E.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

SQL注入的问题

  • SQL存在漏洞，会被攻击，导致数据泄露，SQL会被拼接 or
java 复制代码 
package com.zcn.lesson02;

import com.zcn.lesson02.utils.JdbcUtils;
import java.sql.*;

public class SQL注入 {
    public static void main(String[] args) {
        login("xxx", "123456");
        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();
            // SELECT * FROM users WHERE `NAME`= 'xxx' AND `password` = '123456';
            // SELECT * FROM users WHERE `NAME`= '' or '1=1' AND `password` = ''or'1=1';
            String sql = "SELECT * FROM users WHERE `NAME`= '" + username + "' AND `password` = '" + password + "'";
            rs = st.executeQuery(sql);
            while (rs.next()) {
                System.out.println(rs.getString("NAME"));
                System.out.println(rs.getString("password"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

10.5 PreparedStatement对象

  • PreparedStatement 可以防止SQL注入，效率更好！
  1. 新增
java 复制代码 
package com.zcn.lesson03;

import java.sql.Connection;
import java.util.Date;
import java.sql.PreparedStatement;
// import java.sql.ResultSet;
import java.sql.SQLException;
import com.zcn.lesson02.utils.JdbcUtils;

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 users(id,`NAME`,`PASSWORD`,`email`,`birthday`) values(?,?,?,?,?);";
            st = conn.prepareStatement(sql); // 预编译sql，先写sql，然后不执行

            // 手动给参数赋值
            st.setInt(1, 4);
            st.setString(2, "王五");
            st.setString(3, "666666");
            st.setString(4, "215484@qq.com");

            // 注意点： sql.Date 数据库 java.sql.Date()
            // util.Date Java new Date().getTime() 获得时间戳
            st.setDate(5, new java.sql.Date(new Date().getTime()));

            // 执行
            int i = st.executeUpdate();
            if (i > 0) {
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, null);
        }
    }
}
  1. 删除
java 复制代码 
package com.zcn.lesson03;

import java.sql.Connection;
import java.sql.PreparedStatement;
// import java.sql.ResultSet;
import java.sql.SQLException;
import com.zcn.lesson02.utils.JdbcUtils;

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 users WHERE id=?;";
            st = conn.prepareStatement(sql); // 预编译sql，先写sql，然后不执行

            // 手动给参数赋值
            st.setInt(1, 4);

            // 执行
            int i = st.executeUpdate();
            if (i > 0) {
                System.out.println("删除成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, null);
        }
    }
}
  1. 修改
java 复制代码 
package com.zcn.lesson03;

import java.sql.Connection;
import java.util.Date;
import java.sql.PreparedStatement;
// import java.sql.ResultSet;
import java.sql.SQLException;
import com.zcn.lesson02.utils.JdbcUtils;

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 users SET `NAME`=? WHERE id=?;";
            st = conn.prepareStatement(sql); // 预编译sql，先写sql，然后不执行

            // 手动给参数赋值
            st.setString(1, "某某");
            st.setInt(2, 1);
            // 执行
            int i = st.executeUpdate();
            if (i > 0) {
                System.out.println("修改成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, null);
        }
    }
}
  1. 查询
java 复制代码 
package com.zcn.lesson03;

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

import com.zcn.lesson02.utils.JdbcUtils;

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 users WHERE id=?;";

            st = conn.prepareStatement(sql);

            st.setInt(1, 2);

            rs = st.executeQuery();
            if (rs.next()) {
                System.out.println(rs.getString("NAME"));
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, null);
        }
    }
}

SQL注入

java 复制代码 
package com.zcn.lesson03;

import com.zcn.lesson02.utils.JdbcUtils;
import java.sql.*;

public class SQL注入 {
    public static void main(String[] args) {
        // login("某某", "123456");
        login("'' or 1=1", "123456");

    }

    // 登录业务
    public static void login(String username, String password) {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();

            // PreparedStatement 防止SQL注入的本质，把传递进来的参数当做字符
            // 假设其中存在转义字符，就直接忽略，比如 ' 会被直接转义
            String sql = "SELECT * FROM users WHERE `NAME`=? AND `password`=?;";

            st = conn.prepareStatement(sql);
            st.setString(1, username);
            st.setString(2, password);

            rs = st.executeQuery();
            while (rs.next()) {
                System.out.println(rs.getString("NAME"));
                System.out.println(rs.getString("password"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

10.6 使用VsCode连接数据库

10.7 事务

要么都成功，要么都失败

ACID原则：原子性，一致性，隔离性，持久性

隔离性的问题：

  • 脏读：一个事务读取了另一个没有提交的事务
  • 幻读：在一个事务内，读取到了别人插入的数据，导致前后读出来的结果不一致。
  • 不可重复读：在同一个事务内，重复读取表中的数据，表数据发生了改变

转账案例

mysql 复制代码 
CREATE TABLE account(
    id INT PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR(40),
    money FLOAT
);


INSERT INTO account(name,money) VALUES('A',1000);
INSERT INTO account(name,money) VALUES('B',1000);
INSERT INTO account(name,money) VALUES('C',1000);
java 复制代码 
package com.zcn.lesson04;

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

import com.zcn.lesson02.utils.JdbcUtils;

public class TestTransaction2 {
    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-1000 WHERE `NAME`='A';";
            st = conn.prepareStatement(sql1);
            st.executeUpdate();

            // int x = 1 / 0; // 报错

            String sql2 = "UPDATE account SET money = money+1000 WHERE `NAME`='B';";
            st = conn.prepareStatement(sql2);
            st.executeUpdate();

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

        } catch (SQLException e) {
            try {
                // 如果失败，自动回滚
                conn.rollback();
            } catch (SQLException e2) {
                e2.printStackTrace();
            }

        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

10.8 数据库连接池

  • 数据库 --- 执行完毕 --- 释放
  • 连接 -- 释放，十分浪费系统资源
  • 池化技术：准备一些预先的资源，过来就连接预先准备好的

案例

开门---业务员：等待---服务---关门

常用连接数：10 ----- 最小连接数：10

最大连接数：100 业务最高承载上上限

排队等待

等待超时：100ms

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

开源数据源实现

  • DBCP
  • C3P0
  • Druid：阿里巴巴

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

DBCP

  • 需要用到的jar包
    • commons-dbcp
    • commons-pool
    • commons-logging 必须要，否则不能初始化数据源
properties 复制代码 
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC
username=root
password=123456

initialSize=5
maxTotal=20
maxIdle=10
minIdle=5
maxWaitMillis=60000

connectionProperties=useUnicode=true;characterEncoding=utf8
defaultAutoCommit=true
defaultTransactionIsolation=READ_COMMITTED
java 复制代码 
package com.zcn.lesson05.utils;

import java.util.Properties;
import javax.sql.DataSource;
import org.apache.commons.dbcp2.BasicDataSourceFactory;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JdbcUtils_DBCP {
    private static DataSource dataSource = null;

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

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

        } catch (Exception e) {
            e.printStackTrace(); // 从数据源中获取连接
            throw new ExceptionInInitializerError(e);
        }
    }

    // 获取连接
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();

    }

    // 释放连接
    public static void release(Connection conn, Statement st, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (st != null) {
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

}
java 复制代码 
package com.zcn.lesson05;

import java.sql.Connection;
import java.util.Date;
import java.sql.PreparedStatement;
// import java.sql.ResultSet;
import java.sql.SQLException;
import com.zcn.lesson05.utils.JdbcUtils_DBCP;

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 users(id,`NAME`,`PASSWORD`,`email`,`birthday`) values(?,?,?,?,?);";
            st = conn.prepareStatement(sql); // 预编译sql，先写sql，然后不执行

            // 手动给参数赋值
            st.setInt(1, 5);
            st.setString(2, "王liu");
            st.setString(3, "666666");
            st.setString(4, "215484@qq.com");

            // 注意点： sql.Date 数据库 java.sql.Date()
            // util.Date Java new Date().getTime() 获得时间戳
            st.setDate(5, new java.sql.Date(new Date().getTime()));

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

C3P0

  • 需要用到的jar包：
    • c3p0
    • mchange-commons-java
xml 复制代码 
<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <!--
    c3p0 的缺省（默认）配置
    如果在代码中：ComboPooledDataSource ds = new ComboPooledDataSource();
    就会使用这里的 default-config
    -->
    <default-config>
        <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
        <property name="jdbcUrl">
            jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false&amp;serverTimezone=UTC
        </property>
        <property name="user">root</property>
        <property name="password">123456</property>

        <property name="acquireIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </default-config>
</c3p0-config>
java 复制代码 
package com.zcn.lesson05.utils;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JdbcUtils_C3P0 {
    private static ComboPooledDataSource dataSource = null;

    static {
        try {

            // // 代码版配置
            // dataSource = new ComboPooledDataSource();
            // dataSource.setDriverClass(null);
            // dataSource.setUser(null);
            // dataSource.setPassword(null);
            // dataSource.setJdbcUrl(null);

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

        } catch (Exception e) {
            e.printStackTrace(); // 从数据源中获取连接
            throw new ExceptionInInitializerError(e);
        }
    }

    // 获取连接
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();

    }

    // 释放连接
    public static void release(Connection conn, Statement st, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (st != null) {
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

}
java 复制代码 
package com.zcn.lesson05;

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

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

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

        Connection conn = null;
        PreparedStatement st = null;
        // ResultSet rs = null;

        try {
            conn = JdbcUtils_C3P0.getConnection();
            // 原来是自己实现的，现在用别人实现的

            // 区别
            // 使用 ? 占位符替代参数
            String sql = "insert into users(id,`NAME`,`PASSWORD`,`email`,`birthday`) values(?,?,?,?,?);";
            st = conn.prepareStatement(sql); // 预编译sql，先写sql，然后不执行

            // 手动给参数赋值
            st.setInt(1, 7);
            st.setString(2, "王liu");
            st.setString(3, "666666");
            st.setString(4, "215484@qq.com");

            // 注意点： sql.Date 数据库 java.sql.Date()
            // util.Date Java new Date().getTime() 获得时间戳
            st.setDate(5, new java.sql.Date(new Date().getTime()));

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

结论

  • 无论使用什么数据源，本质都是一样，DataSource接口不会变，方法就不会变
相关推荐
qq_571099351 小时前
学习周报二十四
学习
零匠学堂20251 小时前
移动学习平台与在线学习平台是什么？主要有哪些功能？
java·spring boot·学习
3***89191 小时前
sql实战解析-sum()over(partition by xx order by xx)
数据库·sql
Data_agent1 小时前
1688获得1688公司档案信息API，python请求示例
开发语言·数据库·python
q***01771 小时前
Spring.factories
java·数据库·spring
u***B7921 小时前
Navicat for MySQL下载安装教程
数据库·mysql
白日做梦Q2 小时前
Navicat for MySQL 详细使用指南：命令行操作与界面操作双视角全解析
大数据·mysql·adb·数据库开发
周杰伦fans2 小时前
C# 中 SQL Server 数据库调优指南（小白友好版）
开发语言·数据库·c#
李小星同志2 小时前
HTTM: Head-wise Temporal Token Merging for Faster VGGT论文学习
学习
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03BongoCat - 跨平台键盘猫动画工具04安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）05Linux下V2Ray安装配置指南06【保姆级教程】免费使用Gemini3的5种方法！免翻墙/国内直连07本地部署阿里最新开源的Z-Image0846个Nano-banana 精选提示词，持续更新中09Meta第三代“分割一切”模型——SAM 3本地部署教程：首支持文本提示分割，400万概念、30毫秒响应，检测分割追踪一网打尽10Labelme从安装到标注：零基础完整指南