【数据库】MySQL入门
文章目录
- 1. 初识MySQL
- 1.1、为什么学习数据库
- 1.2、什么是数据库
- 1.3、数据库分类
- 1.4、MySQL简介
- 1.5、安装MySQL(简单)
- 1.6、安装Navicate
- 1.7、连接数据库
- 2.操作数据库
- 2.1、操作数据库
- 2.2、数据库的列类型
- 2.3、数据库的字段属性
- 2.4、创建数据表
- 2.5、数据表的类型
- 2.6、修改和删除表
- 3.MySQL数据管理
- 3.1、外键(了解即可)
- 3.2、DML语言(全部记住)
- 3.3、添加 INSERT
- 3.4、修改 UPDATE
- 3.5、删除 DELETE
- 4. DQL查询数据(重点)
- 4.1、DQL
- 4.2、指定查询字段
- 4.3、where条件子句
- 4.4、连表查询
- 4.5、分页和排序
- 4.6、子查询
- 4.7、分组和过滤
- 5.MySQL函数
- 5.1、常用函数
- 5.2、聚合函数(常用)
- 5.3 数据库级别的MD5加密(扩展)
- 6.事物
- 6.1、什么是事物
- 7.索引
- 7.1、索引的分类
- 7.2、测试索引
- 7.3、索引原则
- 8.权限管理
- 8.1、用户管理
- 8.2、数据库备份
- 9.规范数据库设计
- 9.1、为什么需要设计
- 9.2、三大范式
- 10.JDBC(重点)
- 10.1、数据库驱动
- 10.2、JDBC
- 10.3、第一个JDBC程序
- MySQL8.0及其以上连接语句
- 10.4、JDBC中对象解释
- 10.5、statement对象
- 1.代码实现
- 1.1、增加
- 1.2、删除
- 1.3、修改
- 1.4、查询
- 2.SQL注入问题
- 10.6、PreparedStatement对象
- 1.增加
- 2.删除
- 3.修改
- 4.查询
- 5.防止SQL注入
- 10.7、事物
- 10.8、数据库连接池
1. 初识MySQL
JavaEE:企业Java开发 Web
前端(页面:展示,数据!)
后台(连接点:连接数据库JDBC,连接前端(控制、控制视图跳转,和给前端传递数据))
数据库(存数据)
1.1、为什么学习数据库
- 岗位需求
- 被迫需求:存数据
数据库是所有软件体系中最核心的存在
DBA
1.2、什么是数据库
数据库(DB DataBase)
概念:数据仓库、软件、安装在操作系统(Windows、Linux、max…)之上
作用:存储数据,管理数据
1.3、数据库分类
关系型数据库:excel
- MySQL、Oracle、Sql Server、DB2、SQLlite
- 通过表之间,行列之间的关系进行数据的存储
非关系型数据库:(key:value)
- Redis、MongDB
- 非关系型数据库,对象存储,通过对象自身的属性来决定
DBMS(数据库管理系统)
- 数据库管理软件,能够科学有效的管理我们的数据,维护和获取数据
- MySQL,数据库管理系统
1.4、MySQL简介
MySQL是一个关系型数据库管理系统,MySQL是最好的 RDBMS(Relational Database Management System,关系数据库管理系统) 应用软件之一。
体积小、速度快、总体拥有成本低,尤其是开放源码这一特点,一般中小型和大型网站的开发都选择 MySQL 作为网站数据库。
安装建议:
- 尽量不要使用exe,注册表
- 尽可能使用压缩包安装
官网:https://www.mysql.com/
官网下载地址:MySQL :: Download MySQL Community Server
1.5、安装MySQL(简单)
这里只做简单的说明,详细的大家可以自行去网站搜索教程,我这里是以MySQL 8.0.30作为例子,安装都大同小异
解压
配置环境变量
D:\Program Files\mysql-8.0.30\bin
新建mysql配置文件my.ini
[mysqld] # 设置3306端口 port = 3306 # 设置mysql的安装目录 basedir = D:\Program Files\mysql-8.0.30\ # 设置mysql数据库的数据的存放目录 datadir = D:\Program Files\mysql-8.0.30\data\ #跳过密码验证 #skip-grant-tables
以管理员身份打开CMD,并将路径切换至bin目录下然后输入mysqld -install
cd D:\Program Files\mysql-8.0.30\bin
进行初始化mysql。
mysqld --initialize-insecure --user=mysql
再次启动mysql,然后使用命令进入mysql管理界面(密码可为空)
net start mysql mysql -uroot -p Enter password://直接回车
进入界面后修改密码
alter user 'root'@'localhost' identified by '123456'; //刷新权限 FLUSH PRIVILEGES; //退出 exit
如果有需要的话评论区留言,我会再专门写一篇较为详细的图文安装教程
1.6、安装Navicate
需要破解,篇幅原因暂且不表,有需要的话后期我会再出教程
1.7、连接数据库
命令行连接
mysql -uroot -p123456 --连接数据库update mysql set authentication_string=password('123456') where user='root' and Host = 'localhost'; --修改密码FLUSH PRIVILEGES; --刷新权限-------------------------------------show databases; --查询所有数据库
use 数据库名; --切换数据库show tables; --查询所有表
desc 表名; --查看表结构create databases westos; -- 创建一个新的数据库
exit; --退出-- + 空格 单行注释
/*
多行注释
*/
数据库xxx语言
DDL 定义
DML 操作
DQL 查询
DCL 控制
2.操作数据库
操作数据库>操作数据库中的表>操作数据库中表的数据
mysql关键字不区分大小写
2.1、操作数据库
- 创建数据库
CREATE DATABASE IF NOT EXISTS westos
- 删除数据库
DROP DATABASE IF EXISTS hello
- 使用数据库
-- 特殊字段需要带 ` `
USE `school`
- 查看数据库
show databases; -- 查看所有数据库
2.2、数据库的列类型
数值
tinyint 十分小的数据 1字节
smallint 较小的数据 2字节
midiumint 中等大小的数据 3个数据
int 标准的整数 4字节 常用
big 较大的数据 8个字节
float 浮点数 4个字节
double 浮点数 8个字节(精度问题)
decimal 字符串形式浮点数 金融计算一般使用decimal
字符串
- char 字符串固定大小 0~255
- vchar 可变字符串 0~65535 常用的 String
- tingtext 微型文本 2^8-1
- text 文本串 2^16-1 保存大文本
时间日期
java.util.Date
- date YY-MM-DD,日期
- time HH:mm:ss,时间格式
- datetime YYYY-MM-DD HH:mm:ss 最常用的时间格式
- timestamp 时间戳, 1970.1.1 到现在的毫秒数 也较为常用
- year 表示年份
null
- 没有值,位置
- 不要使用NULL值进行运算
2.3、数据库的字段属性
- Unsigned
- 无符号的整数
- 声明该列不能为负数
- zerofill
- 填充0
- 不足的位数,用0来填充
- 自增
- 在上一条的基础上+1
- 一般用在唯一主键
- 非空
- 不赋值的话会报错,反之亦然
- 默认
- 设置默认值
- 若不设置值,则使用默认值
2.4、创建数据表
-- 注意:使用英文(),表的名称和字段尽量使用``括起来
-- 字符串使用''括起来
-- 所有的语句用英文,结尾,最后一个不用加
DROP TABLE IF EXISTS `student`;
CREATE TABLE `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`) USING BTREE)ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;
格式
CREATE TABLE [ IF NOT EXISTS ] `表名` (`字段名` 列类型 [属性] [索引] [注释],`字段名` 列类型 [属性] [索引] [注释],......`字段名` 列类型 [属性] [索引] [注释])[表类型][字符集设置][注释]
常用命令
SHOW CREATE DATABASE school;-- 查看school数据库的定义语句SHOW CREATE TABLE student;-- 查看student数据表的定义语句desc student;
2.5、数据表的类型
关于数据库引擎
INNODB 默认使用
MYISAM 早些年使用的
MYISAM | INNODB | |
---|---|---|
事物支持 | 不支持 | 支持 |
数据进行锁定 | 不支持 | 支持 |
外键约束 | 不支持 | 支持 |
全文索引 | 支持 | 不支持 |
表空间的大小 | 较小 | 较大约为MYISAM的两倍 |
常规使用操作:
- MYISAM 节约空间,速度较快
- INNODB 安全性高,事物的处理,多表多用户操作
在物理存在的位置
所有数据库文件都存在date目录下
本质还是文件的存储
MySQL引擎在物理文件的区别
- InnoDB 在数据库表中只有一个*.ibd文件,以及上级目录下的ibdata1文件
设置数据库表的字符集编码
CHARSET=utf8mb4
MySQL的默认编码是Latin1,不支持中文
2.6、修改和删除表
修改
-- 修改表名
ALTER TABLE student RENAME AS teacher
-- 增加表的字段
ALTER TABLE teacher ADD age INT(11)-- 修改表的字段 (重命名,修改约束)
ALTER TABLE teacher MODIFY age VARCHAR(11) -- 修改约束ALTER TABLE teacher CHANGE age age2 VARCHAR(11) -- 修改约束-- 删除表的字段
ALTER TABLE teacher DROP age2
删除
-- 删除表
DROP TABLE IF EXISTS teacher
所有的创建和删除操作尽量加上判断,以免报错
注意:
- ``字段名 使用这个包裹
- 注释 – /**/
- sql关键字大小写不敏感,建议小写
- 所有符号都用英文
3.MySQL数据管理
3.1、外键(了解即可)
方式一、在创建表的时候,增加约束(麻烦,比较复杂)
CREATE TABLE `grade`(
`gradeid` INT(10) NOT NULL auto_increment COMMENT '年级id',
`gradename` VARCHAR(50) NOT NULL COMMENT '年级名称',
PRIMARY KEY (`gradeid`)
)ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;-- 学生表的gradeid字段要去引用年级表的gradeid
-- 定义外键key
-- 给这个外键添加约束(执行引用) references 引用
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (`id` INT (4) NOT NULL AUTO_INCREMENT COMMENT '学号',`name` VARCHAR (30) NOT NULL DEFAULT('匿名') COMMENT '姓名',`pwd` VARCHAR (20) NOT NULL DEFAULT('123456') COMMENT '密码' ,`sex` VARCHAR(2) NOT NULL DEFAULT('男') COMMENT '性别',`birthday` datetime DEFAULT NULL COMMENT '出生日期',`gradeid` INT(10) NOT NULL COMMENT '学生年级',`address` VARCHAR(100) DEFAULT NULL COMMENT '家庭住址',`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',PRIMARY KEY(`id`) USING BTREE,KEY `FK_gradeid`(`gradeid`),CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade` (`gradeid`))ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;
方式二、创建表成功后添加约束
CREATE TABLE `grade`(
`gradeid` INT(10) NOT NULL auto_increment COMMENT '年级id',
`gradename` VARCHAR(50) NOT NULL COMMENT '年级名称',
PRIMARY KEY (`gradeid`)
)ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;-- 学生表的gradeid字段要去引用年级表的gradeid
-- 定义外键key
-- 给这个外键添加约束(执行引用) references 引用
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (`id` INT (4) NOT NULL AUTO_INCREMENT COMMENT '学号',`name` VARCHAR (30) NOT NULL DEFAULT('匿名') COMMENT '姓名',`pwd` VARCHAR (20) NOT NULL DEFAULT('123456') COMMENT '密码' ,`sex` VARCHAR(2) NOT NULL DEFAULT('男') COMMENT '性别',`birthday` datetime DEFAULT NULL COMMENT '出生日期',`gradeid` INT(10) NOT NULL COMMENT '学生年级',`address` VARCHAR(100) DEFAULT NULL COMMENT '家庭住址',`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',PRIMARY KEY(`id`) USING BTREE)ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;-- 创建表的时候没有外键关系ALTER TABLE `student`ADD CONSTRAINT `FK_gradeid` FOREIGN KEY(`gradeid`) REFERENCES `grade`(`gradeid`);-- ALTER TABLE 表 ADD CONSTRAINT 约束名 FOREIGN KEY(作为外键的列) REFERENCES 哪个表(哪个字段)
以上操作都是物理外键,数据库级别的外键,不建议使用!(避免数据库过多造成困扰,这里了解即可)
最佳实践
- 数据库就是单纯的表,只用了存数据,只有行(数据)列(字段)
- 我们想使用多张表的数据,想使用外键(程序去使用)
3.2、DML语言(全部记住)
数据库意义:数据存储,数据管理
DML语言:数据操作语言
- insert
- 修改
- 删除
3.3、添加 INSERT
-- 插入语句(添加)
-- INSERT INTO 表名([字段名1,字段名2,字段名3])values('值1','值2','值1')...
INSERT INTO `grade`(`gradename`) VALUES('大四')-- 由于主键自增我们可以忽略,如果不具体写字段,就会按照顺序匹配
INSERT INTO `grade` VALUES('大三')-- 一般写插入语句,字段和类型要与数据一一对应-- 插入多个字段
INSERT INTO `grade`(`gradename`)
VALUES('大一'),('大二')
语法:INSERT INTO 表名([字段名1,字段名2,字段名3])values('值1','值2','值1')...
注意事项:
- 字段和字段之间使用 英文逗号 隔开
- 字段是可以省略的,但是后面的值必须一一对应不能少
- 可以同时插入多条数据,BALUES后面的值,需要使用,隔开即可
VALUSE(),()
3.4、修改 UPDATE
update 修改谁(条件) set原来的值
-- 修改学员名字 更改的表 哪个字段 修改的内容 修改哪条记录
UPDATE `teacher`
SET `name` = 'Genius Sue'
WHERE id='1'
语法:
UPDATE 表名
SET colnum_name = value ,[colnum_name = value]…
WHERE [条件] [AND [条件]]
初学者可以这样使用三段式,比较不容易遗忘,若要设置多个属性记得用逗号隔开
条件:where子句 运算符,id等于某个值,大于某个值,在某个区间修改
操作符 | 意义 | 结果 | 返回值 |
---|---|---|---|
= | 等于 | 5=6 | false |
<>或!= | 不等于 | true | |
> | |||
< | |||
<= | |||
>= | |||
between…and… | 在某个范围内 | between 2 and 5 | |
AND | && | 5>1 AND 1>2 | false |
OR | || | 5>1 OR 1>2 | true |
注意
value可以是一个具体的值,也可以是一个变量
UPDATE `teacher` SET `birthday` = CURRENT_DATE WHERE `name` = 'Genius Sue'
3.5、删除 DELETE
delete
语法: delete from 表名 [where 条件]
-- 删除指定记录
DELETE FROM `teacher`
WHERE `id`='1'
TRUNCATE
作用:完全清空一个表,表的结构和索引约束不会改变
-- 清空student表
TRUNCATE `student`
delete 和 TRUNCATE 区别
- 相同点:都能删除数据,但是不会删除表机构
- 不同
- TRUNCATE 重新设置自增列,会清除计数器
- TRUNCATE 不会影响事物
4. DQL查询数据(重点)
4.1、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}];-- 指定查询的记录从哪条至哪条
注意:[]括号代表可选的,{}括号代表必选的
建表语句
DROP DATABASE IF EXISTS `school`;
-- 创建一个school数据库
CREATE DATABASE IF NOT EXISTS `school`;
-- 使用school数据库
USE `school`;
-- 创建学生表
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student`(`student_no` INT(4) NOT NULL COMMENT '学号',`login_pwd` VARCHAR(20) DEFAULT NULL,`student_name` VARCHAR(20) DEFAULT NULL COMMENT '学生姓名',`sex` TINYINT(1) DEFAULT NULL COMMENT '性别,0或1',`grade_id` INT(11) DEFAULT NULL COMMENT '年级编号',`phone` VARCHAR(50) NOT NULL COMMENT '联系电话',`address` VARCHAR(255) NOT NULL COMMENT '地址',`born_date` DATETIME DEFAULT NULL COMMENT '出生时间',`email` VARCHAR (50) NOT NULL COMMENT '邮箱账号',`identity_card` VARCHAR(18) DEFAULT NULL COMMENT '身份证号',PRIMARY KEY (`student_no`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;-- 创建年级表
DROP TABLE IF EXISTS `grade`;
CREATE TABLE `grade`(`grade_id` INT(11) NOT NULL AUTO_INCREMENT COMMENT '年级编号',`grade_name` VARCHAR(50) NOT NULL COMMENT '年级名称',PRIMARY KEY (`grade_id`)
) ENGINE=INNODB DEFAULT CHARSET = utf8;-- 创建科目表
DROP TABLE IF EXISTS `subject`;
CREATE TABLE `subject`(`subject_no`INT(11) NOT NULL AUTO_INCREMENT COMMENT '课程编号',`subject_name` VARCHAR(50) DEFAULT NULL COMMENT '课程名称',`class_hour` INT(4) DEFAULT NULL COMMENT '学时',`grade_id` INT(4) DEFAULT NULL COMMENT '年级编号',PRIMARY KEY (`subject_no`)
)ENGINE = INNODB DEFAULT CHARSET = utf8;-- 创建成绩表
DROP TABLE IF EXISTS `result`;
CREATE TABLE `result`(`student_no` INT(4) NOT NULL COMMENT '学号',`subject_no` INT(4) NOT NULL COMMENT '课程编号',`exam_date` DATETIME NOT NULL COMMENT '考试日期',`student_result` INT (4) NOT NULL COMMENT '考试成绩')ENGINE = INNODB DEFAULT CHARSET = utf8;-- 插入学生数据 其余自行添加 这里只添加了2行
INSERT INTO `student` (`student_no`,`login_pwd`,`student_name`,`sex`,`grade_id`,`phone`,`address`,`born_date`,`email`,`identity_card`)
VALUES
(1000,'123456','张伟',0,2,'13800001234','北京朝阳','1980-1-1','text123@qq.com','123456198001011234'),
(1001,'123456','赵强',1,3,'13800002222','广东深圳','1990-1-1','text111@qq.com','123456199001011233');-- 插入年级数据
INSERT INTO `grade` (`grade_id`,`grade_name`) VALUES(1,'大一'),(2,'大二'),(3,'大三'),(4,'大四'),(5,'预科班');-- 插入科目数据
INSERT INTO `subject`(`subject_no`,`subject_name`,`class_hour`,`grade_id`)VALUES
(1,'高等数学-1',110,1),
(2,'高等数学-2',110,2),
(3,'高等数学-3',100,3),
(4,'高等数学-4',130,4),
(5,'C语言-1',110,1),
(6,'C语言-2',110,2),
(7,'C语言-3',100,3),
(8,'C语言-4',130,4),
(9,'Java程序设计-1',110,1),
(10,'Java程序设计-2',110,2),
(11,'Java程序设计-3',100,3),
(12,'Java程序设计-4',130,4),
(13,'数据库结构-1',110,1),
(14,'数据库结构-2',110,2),
(15,'数据库结构-3',100,3),
(16,'数据库结构-4',130,4),
(17,'C#基础',130,1);-- 插入成绩数据 这里仅插入了一组,其余自行添加
INSERT INTO `result`(`student_no`,`subject_no`,`exam_date`,`student_result`)
VALUES
(1000,1,'2013-11-11 16:00:00',85),
(1000,2,'2013-11-12 16:00:00',70),
(1000,3,'2013-11-11 09:00:00',68),
(1000,4,'2013-11-13 16:00:00',98),
(1000,5,'2013-11-14 16:00:00',58);
4.2、指定查询字段
-- 查询全部的学生 SELECT 字段 FROM 表名;SELECT * FROM student;-- 查询指定字段SELECT student_name, student_no FROM student;-- 别名,给结果起一个名字 AS 可以给字段起别名,也可以给表起别名SELECT student_name AS '学号', student_no AS '姓名' FROM student;-- 函数 concat(a,b) 拼接字符串SELECT CONCAT('姓名:', student_no) AS '新姓名' FROM student;
拼接字符串
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uRkFfJI9-1662530230532)(C:\Users\Genius Sue\AppData\Roaming\Typora\typora-user-images\image-20220906094918954.png)]
有的时候,列表名不是那么见名知意,我们可以起别名
4.3、where条件子句
作用:检索数据中符合条件
的值
搜索的条件由一个或者多个表达式组成,结果布尔值
逻辑运算符
运算符 | 语法 | 描述 |
---|---|---|
and && | a and b a&&b | 逻辑与 |
or || | a orb a||b | 逻辑或 |
not ! | not a !a | 逻辑非 |
尽量使用英文字母
-- 查询考试成绩在 95 ~ 100分之间SELECT student_no,student_result FROM result;-- and
SELECT student_no,student_result FROM result
WHERE student_result>95 AND student_result<=100;
-- &&
SELECT student_no,student_result FROM result
WHERE student_result>95 && student_result<=100;-- 模糊查询(区间)
SELECT student_no,student_result FROM result
WHERE student_result BETWEEN 95 AND 100;-- 除了1000号学生之外的学生的成绩
-- !=
SELECT student_no,student_result FROM result
WHERE student_no != 1000;
-- not
SELECT student_no,student_result FROM result
WHERE NOT student_no = 1000;
模糊查询:比较运算符
运算符 | 语法 | 描述 |
---|---|---|
IS NULL | a is null | 如果操作符为null,结果为真 |
IS NOT NULL | a is not null | 如果操作符不为null,结果为真 |
BWTWEEN…AND… | a between b and c | 若a在b和c之间,则结果为真 |
LIKE | a like b | SQL匹配,如果a匹配b,则结果为真 |
IN | a in (a1,a2,a3,…) | 假设a在a1或者a2或者a3,…其中的某一个,则结果为真 |
-- 查询姓刘的同学-- like 结合
-- %(代表0到任意个字符)
-- _(代表1)-- 查询姓刘的同学
SELECT `student_no`,`student_name` FROM `student`
WHERE student_name LIKE '刘%';-- 查询姓刘的同学,名字后面只有一个字的
SELECT `student_no`,`student_name` FROM `student`
WHERE student_name LIKE '刘_';-- 查询姓刘的同学,名字后面有两个字的
SELECT `student_no`,`student_name` FROM `student`
WHERE student_name LIKE '刘__';-- 查询名字中间有嘉字的同学
SELECT `student_no`,`student_name` FROM `student`
WHERE student_name LIKE '%%嘉%';-- in (具体的一个或者多个值)
-- 查询学号1001,1002,1003号学号
SELECT `student_no`,`student_name` FROM `student`
WHERE student_no IN ('1001','1002','1003');
-- 查询在北京的学生
SELECT `student_no`,`student_name` FROM `student`
WHERE address IN ('北京');-- null
-- 查询地址为空的学生
SELECT `student_no`,`student_name` FROM `student`
WHERE address = '' OR address IS NULL;-- not null
-- 查询有出生日期的同学 不为空
SELECT `student_no`,`student_name` FROM `student`
WHERE born_date IS NOT NULL;-- 查询没有出生日期的同学 为空
SELECT `student_no`,`student_name` FROM `student`
WHERE born_date IS NULL;
注意:这里的空值条件为 字段名 IS NULL,不能写成 字段名=NULL
4.4、连表查询
JOIN对比
-- =========连表查询==================-- 查询参加了考试的同学(学号,姓名,科目编号,分数)
SELECT * FROM student;
SELECT * FROM result;-- join on 连接查询
-- where 等值查询-- inner join
SELECT st.`student_no`,st.`student_name`,re.`subject_no`,re.`student_result`
FROM student AS st
INNER JOIN result AS re ON
st.`student_no`=re.`student_no`;-- right join
SELECT st.`student_no`,st.`student_name`,re.`subject_no`,re.`student_result`
FROM student st
RIGHT JOIN result re ON
st.`student_no`=re.`student_no`;-- left join
SELECT st.`student_no`,st.`student_name`,re.`subject_no`,re.`student_result`
FROM student st
LEFT JOIN result re ON
st.`student_no`=re.`student_no`;-- 查询缺考的同学
SELECT st.`student_no`,st.`student_name`,re.`subject_no`,re.`student_result`
FROM student st
LEFT JOIN result re ON
st.`student_no`=re.`student_no`
WHERE re.`student_result` IS NULL;-- 查询了参加考试的同学信息(学号,学生姓名,科目名称,分数)
SELECT stu.`student_no`,stu.`student_name`,sub.`subject_name`,res.`student_result`
FROM `student` stu
RIGHT JOIN `result` res
ON res.`student_no`=stu.`student_no`
INNER JOIN `subject` sub
ON res.`subject_no`=sub.`subject_no`;-- 查询学员所属的年级(学号,学生的姓名,年级名称)
SELECT `student_no`,`student_name`,`grade_name`
FROM student stu
INNER JOIN `grade` gra
ON stu.`grade_id`=gra.`grade_id`;-- 查询了参加数据结构-1考试的同学信息(学号,学生姓名,科目名称,分数)
SELECT stu.`student_no`,stu.`student_name`,sub.`subject_name`,res.`student_result`
FROM student stu
INNER JOIN `result` res
ON stu.`student_no` = res.`student_no`
INNER JOIN `subject` sub
ON res.`subject_no`=sub.`subject_no`
WHERE sub.`subject_name`='数据结构-1';-- 别名可以不加AS-- 我要查询哪些数据 select ...
-- 从哪几个表中查 from 表 XXX join 连接的表 on 交叉条件
-- 假设存在一种多张表查询,慢慢来,先查询两张表然后再慢慢增加
操作 | 描述 |
---|---|
inner join | 如果表中至少有一个匹配,就返回行 |
left join | 会从左表中返回所有的值,即使右表中没有匹配 |
right join | 会从右表中返回所有的值,即使左表中没有匹配 |
注意:两个表进行外连接查询时,以主表为基准(将主表的数据全部显示),从表显示与主表对应的数据,如果对应的没有,则以null补齐,若从表为bit类型,则用0填充
- LEFT JOIN(左连接):返回左边表中的所有记录和右表中与连接字段相等的记录。(左边是主表)
- RIGHT JOIN(右连接):返回右边表中的所有记录和左表中与连接字段相等的记录。(右边是主表)
- 当JOIN关键词放在FROM语句中时,应有关键词ON与之对应,表示连接的条件
自连接
自己的表和自己的表连接,核心:一张表拆为两张一样的表即可
-- 创建表
-- unsigned 无符号
-- auto_increment=9 自增的起始值
DROP TABLE IF EXISTS `category` ;
CREATE TABLE `category` (`category_id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '主题id',`pid` INT(10) NOT NULL COMMENT '父id',`category_name` VARCHAR(50) NOT NULL COMMENT '主题名字',PRIMARY KEY (`category_id`)
) ENGINE=INNODB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;-- 插入值
INSERT INTO `category`(`category_id`,`pid`,`category_name`)
VALUES('2','1','信息技术'),
('3','1','软件开发'),
('4','3','数据库'),
('5','1','美术设计'),
('6','3','web开发'),
('7','5','ps技术'),
('8','2','办公信息');SELECT * FROM `category`;
父类
pid | category_id | category_name |
---|---|---|
1 | 2 | 信息技术 |
1 | 3 | 软件开发 |
1 | 5 | 美术设计 |
子类
pid | category_id | category_name |
---|---|---|
3 | 4 | 数据库 |
2 | 8 | 办公信息 |
3 | 6 | web开发 |
5 | 7 | ps技术 |
操作:查询父类对应的子类关系
父类 | 子类 |
---|---|
信息技术 | 办公信息 |
软件开发 | 数据库 |
软件开发 | web开发 |
美术设计 | ps技术 |
-- 查询父子信息,把一张表看为两个一模一样的表
SELECT a.`category_name` AS '父科目',b.`category_name` AS '子科目'
FROM `category` AS a, `category` AS b
WHERE a.`category_id`=b.`pid`;
4.5、分页和排序
排序 ORDER BY
ASC 升序
DESC 降序
-- 排序: 升序 ASC 降序 DESC
-- ORDER BY 通过那个字段排序,怎么排
-- 查询的结果根据成绩降序 排序
SELECT stu.`student_no`,stu.`student_name`,sub.`subject_name`,res.`student_result`
FROM student stu
INNER JOIN `result` res
ON stu.`student_no` = res.`student_no`
INNER JOIN `subject` sub
ON res.`subject_no`=sub.`subject_no`
WHERE sub.`subject_name`='数据结构-1'
ORDER BY `student_result` DESC;
注意:排序默认为asc升序
分页 LIMIT
-- 为什么要分页?
-- 缓解数据库压力,给人更好的体验 瀑布流
-- 分页,每页只显示五条数据
-- 语法 : limit 起始值,页面的大小
-- 网页应用:当前页,总的页数,每页大小
-- LIMIT 0,5 1~5
-- LIMIT 1,5 2~6
-- LIMIT 6,5
SELECT stu.`student_no`,stu.`student_name`,sub.`subject_name`,res.`student_result`
FROM student stu
INNER JOIN `result` res
ON stu.`student_no` = res.`student_no`
INNER JOIN `subject` sub
ON res.`subject_no`=sub.`subject_no`
WHERE sub.`subject_name`='数据结构-1'
ORDER BY `student_result` DESC
LIMIT 1,5;
-- 第一页 limit 0,5 (1-1)*5
-- 第二页 limit 5,5 (2-1)*5
-- 第三页 limit 10,5 (3-1)*5
-- 第N页 limit 10,5 (n-1)*pageSize,pageSize
-- pageSize,页面大小
-- (n-1)*pageSize,起始值
-- n,当前页
-- 总页数 = (数据总数%页面大小==0)? (数据总数/页面大小) : (数据总数/页面大小 + 1)-- 查询科目高等数学-2,课程成绩排名前十的学生,并且分数要大于60的学生信息(学号,姓名,课程名称,分数)
SELECT stu.`student_no`,stu.`student_name`,sub.`subject_name`,res.`student_result`
FROM student stu
INNER JOIN `subject` sub
ON stu.`grade_id`=sub.`grade_id`
INNER JOIN `result` res
ON sub.`subject_no`=res.`subject_no`
WHERE sub.`subject_name`='高等数学-2'
AND res.`student_result`>60
ORDER BY res.`student_result`
LIMIT 0,10;
语法: limit (查询起始下标,页面大小)
4.6、子查询
where(这个值是计算出来的)
本质:在where语句中嵌套一个子查询语句
-- 1.查询数据库结构-1的所有考试结果(学号,科目名,成绩),降序排列
-- 方式1:使用连接查询
SELECT res.`student_no`,res.`subject_no`,res.`student_result`
FROM `result` res
INNER JOIN `subject` sub
ON res.`subject_no`=sub.`subject_no`
WHERE sub.`subject_name`='高等数学-2'
ORDER BY res.`student_result` DESC-- 使用子查询(由里及外)
SELECT res.`student_no`,res.`subject_no`,res.`student_result`
FROM `result` res
WHERE res.`subject_no` = (SELECT sub.`subject_no`FROM `subject` subWHERE sub.`subject_name`='高等数学-2'
)
ORDER BY res.`student_result` DESC-- 分数不小于80分的学生的学号和姓名SELECT DISTINCT stu.`student_no`,stu.`student_name`
FROM student stu
INNER JOIN result res
ON stu.`student_no`=res.`student_no`
WHERE res.`student_result` > 80-- 在这个基础上增加一个科目,查询课程为高等数学-2,且分数不小于80分的学生的学号和姓名
SELECT DISTINCT stu.`student_no`,stu.`student_name`
FROM student stu
INNER JOIN result res
ON stu.`student_no`=res.`student_no`
WHERE res.`student_result` > 80
AND res.`subject_no`=(
SELECT sub.`subject_no` FROM `subject` sub
WHERE sub.`subject_name`='高等数学-2'
)SELECT DISTINCT stu.`student_no`,stu.`student_name`
FROM student stu
INNER JOIN result res
ON stu.`student_no`=res.`student_no`
INNER JOIN `subject` sub
ON res.`subject_no`=sub.`subject_no`
WHERE sub.`subject_name`='高等数学-2'
AND res.`student_result` > 80;-- 再次改造(由里及外)
SELECT DISTINCT `student_no`,`student_name` FROM student WHERE student_no IN (SELECT student_no FROM result WHERE `student_result` > 80 AND subject_no = (SELECT subject_no FROM `subject` WHERE `subject_name`='高等数学-2')
)
4.7、分组和过滤
-- 查询不同课程的平均分,最高分,最低分
SELECT sub.subject_name AS '课程',
AVG(res.student_result) AS '平均分',
MAX(res.student_result) AS '最高分',
MIN(res.student_result) AS '最低分'
FROM result res
INNER JOIN `subject` sub
ON res.`subject_no`=sub.`subject_no`
GROUP BY res.`subject_no` -- 通过什么字段来分组
HAVING AVG(res.student_result) >80;
5.MySQL函数
官网:参考手册
5.1、常用函数
-- 数学运算
SELECT ABS(-8) -- 绝对值
SELECT CEILING(9.4) -- 向上取整
SELECT FLOOR(9.4)-- 向下取整
SELECT RAND() -- 返回一个0~1之间的随机数
SELECT SIGN(-10) -- 判断一个数的符号,0 返回0 负数返回-1 正数返回1-- 字符串函数
SELECT CHAR_LENGTH('及时再小的帆也能远航') -- 字符串长度
SELECT CONCAT('我','爱','你') -- 拼接字符串
SELECT INSERT('我爱编程helloworld',1,2,'超级热爱') -- 插入,替换,从某个位置开始替换某个长度
SELECT LOWER('Genius Sue') -- 小写字母
SELECT UPPER('Genius Sue') -- 大写字母
SELECT INSTR('Genius Sue','s') -- 返回第一次出现的子串的索引
SELECT REPLACE('坚持就能成功','坚持','努力') -- 替换出现的指定字符串
SELECT SUBSTR('坚持就能成功', 5, 2) -- 返回指定的子字符串(源字符串,截取的位置,截取的长度)
SELECT REVERSE('清晨我上马') -- 反转-- 时间和日期函数(记住!)
SELECT CURRENT_DATE() -- 获取当前日期
SELECT CURDATE() -- 获取当前日期
SELECT NOW() -- 获取当前的时间
SELECT LOCALTIME() -- 获取本地时间
SELECT SYSDATE() -- 获取系统时间SELECT YEAR(NOW()) -- 年
SELECT MONTH(NOW()) -- 月
SELECT DAY(NOW()) -- 日
SELECT HOUR(NOW()) -- 时
SELECT MINUTE(NOW()) -- 分
SELECT SECOND(NOW()) -- 秒-- 系统
SELECT SYSTEM_USER()
SELECT USER()
SELECT VERSION()
5.2、聚合函数(常用)
函数名称 | 描述 |
---|---|
count() | 计数 |
sum() | 求和 |
avg() | 平均值 |
max() | 最大值 |
min() | 最小值 |
-- 聚合函数
-- 都能统计 表中数据-- count(字段) 会忽略所有的null值(想查询一个表中有多少个记录,就使用这个count())
SELECT COUNT(student_name) FROM student;
-- COUNT(*) 不会忽略所有的null值 本质计算行数
SELECT COUNT(*) FROM student;
-- COUNT(1) 不会忽略所有的null值 本质计算行数
SELECT COUNT(1) FROM student;SELECT SUM(student_result) AS '总和'
FROM resultSELECT AVG(student_result) AS '平均分'
FROM resultSELECT MAX(student_result) AS '最高分'
FROM resultSELECT MIN(student_result) AS '最低分'
FROM result
5.3 数据库级别的MD5加密(扩展)
什么是MD5?
主要增加算法复杂度和不可逆性。
MD5不可逆,具体的值的md5是一样的
MD5破解网站的原理,背后有一个字典,MD5加密后的值,加密前的值
CREATE TABLE `testmd5`(`id` INT(4) NOT NULL,`name` VARCHAR(20) NOT NULL,`pwd` VARCHAR(50) NOT NULL,PRIMARY KEY (`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;-- 明文密码
INSERT INTO `testmd5`(`id`,`name`,`pwd`)
VALUES(1,'张三','123456'),(2,'李四','123456'),(3,'王五','123456')SELECT *
FROM `testmd5`-- 加密
UPDATE testmd5 SET pwd=MD5(pwd) WHERE id=2
UPDATE testmd5 SET pwd=MD5(pwd) -- 加密全部的密码-- 插入的时候加密
INSERT INTO `testmd5`(`id`,`name`,`pwd`)
VALUES(4,'小明',MD5('123456'))-- 如何校验,将用户传递进来的密码,进行MD5加密,然后比对加密后的值SELECT *
FROM `testmd5`
WHERE `name`='小明' AND pwd = MD5('123456')
6.事物
6.1、什么是事物
要么都成功,要么都失败
将一组sql放到一个批次中取执行
事务原则:ACID原则 -> 原子性 、一致性、隔离性、持久性 (脏读,幻读。。。)
参考博客链接:事务ACID理解
原子性(Atomicity)
要么不做,要么都做,就算完成了部分,有部分未完成,那么完成的部分也要被取消
一致性(Consistency)
数据库从一个一致性转变到另一个一致性
隔离性(Isolation)
事务的隔离性是多个用户并发访问数据库时,数据库为每一个用户开启的事务,不能被其他事务的操作数据所干扰,多个并发事务之间要相互隔离。
持久性(Durability)
事务一旦提交不可逆,被持久化到数据库中,就算数据库因故障被破坏,DBMS也应该能够恢复
隔离所导致的一些问题
- 脏读(污读):
- 在事务A执行过程中,事务A对数据资源进行了修改,事务B读取了事务A修改后的数据。
- 由于某些原因,事务A并没有完成提交,发生了RollBack操作,则事务B读取的数据就是脏数据。
这种读取到另一个事务未提交的数据的现象就是脏读(Dirty Read)。
- 不可重复读:
事务B读取了两次数据资源,在这两次读取的过程中事务A修改了数据,导致事务B在这两次读取出来的数据不一致。
这种在同一个事务中,前后两次读取的数据不一致的现象就是不可重复读(Nonrepeatable Read)。
- 虚读(幻读)
事务B前后两次读取同一个范围的数据,在事务B两次读取的过程中事务A新增了数据,导致事务B后一次读取到前一次查询没有看到的行。
幻读和不可重复读有些类似,但是幻读强调的是集合的增减,而不是单条数据的更新。
执行事物
-- 事务
-- mysql 是默认开启事务自动提交-- 关闭
SET autocommit = 0;
-- 开启(默认的)
SET autocommit = 1;-- 手动处理事务SET autocommit = 0; -- 关闭自动提交-- 事务开启
START TRANSACTION; -- 标记一个事务的开始,从这个之后的sql都在同一个事务内INSERT XX
INSERT XX-- 提交 : 持久化(成功)
COMMIT;
-- 回滚 : 回到的原来的样子(失败)
ROLLBACK;-- 事务结束
SET autocommit = 1; -- 开启自动提交-- 了解
SAVEPOINT -- 保存点名 -- 设置一个事务的保存点
ROLLBACK TO SAVEPOINT -- 保存点名 -- 回滚到保存点
RELEASE SAVEPOINT -- 保存点名 -- 撤销(删除)保存点
模拟场景
-- 转账-- 创建数据库
CREATE DATABASE shop CHARACTER SET utf8 COLLATE utf8_general_ci-- 使用shop数据库
USER `shop`-- 建表
CREATE TABLE `account`(`id` INT(3) NOT NULL AUTO_INCREMENT,`name` VARCHAR(100) NOT NULL,`money` DECIMAL(9,2) NOT NULL,PRIMARY KEY (`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8-- 初始化数据
INSERT INTO account(`name`,`money`)
VALUES('A',2000.00),
('B',10000.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加500COMMIT -- 提交事务,就会被持久化了ROLLBACK -- 回滚SET autocommit = 1 -- 恢复自动提交
7.索引
Msql官方对索引的定义为:索引(index)是帮助MySQL高效获取数据的数据结构。
提取句子主干,就可以得到索引的本质:索引是数据结构。
【MySQL优化】——看懂explain_漫漫长途,终有回转;余味苦涩,终有回甘-CSDN博客_explain
7.1、索引的分类
在一个表中,主键索引只能有一个,唯一索引可以有多个
- 主键索引(primary key)
- 唯一的标识,主键不可重复,只能有一个列作为主键
- 唯一索引 (unique key)
- 避免重复的列出现,可以重复,多个列都可以标示为唯一索引
- 常规索引(key/index)
- 默认的 index 或者key关键字来设置
- 全文索引(FullText)
- 在特定的数据库引擎下才有,myisam
- 快速定位数据
基础语法
-- 索引的使用-- 1.在创建表的时候给字段增加索引
-- 2.创建完毕后,增加索引-- 显示所有的索引信息
SHOW INDEX FROM student-- 新增一个索引 (索引名) 列名ALTER TABLE `student` ADD UNIQUE KEY `UK_IDENTITY_CARD` (`identity_card`)
ALTER TABLE `student` ADD KEY `K_STUDENT_NAME`(`student_name`)ALTER TABLE `student` ADD FULLTEXT INDEX `FI_PHONE` (`phone`)-- explain 分析sql执行的状况EXPLAIN SELECT * FROM student -- 非全文索引EXPLAIN SELECT * FROM student WHERE MATCH(`phone`) AGAINST('138') -- 全文索引
7.2、测试索引
CREATE TABLE app_user (`id` BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT 'ID',`name` VARCHAR(50) DEFAULT '' COMMENT '用户昵称',`email` VARCHAR(50) NOT NULL COMMENT '用户邮箱',`phone` VARCHAR(20) DEFAULT '' COMMENT '手机号',`gender` TINYINT(4) UNSIGNED DEFAULT '0' COMMENT '性别(0:男 1:女)',`password` VARCHAR(100) NOT NULL COMMENT '密码',`age` TINYINT(4) DEFAULT '0' COMMENT '年龄',`create_time` DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',`update_time` TIMESTAMP NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8mb4 COMMENT='app用户表'-- 插入100万数据b (函数)DELIMITER $$ -- 写函数之前必须要写,标志
CREATE FUNCTION mock_data()
RETURNS INT DETERMINISTIC
BEGINDECLARE num INT DEFAULT 1000000;DECLARE i INT DEFAULT 0;WHILE i<num DO-- 插入语句INSERT INTO app_user(`name`,`email`,`phone`,`gender`,`password`,`age`)VALUES(CONCAT('用户',i),'123345@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();SELECT * FROM app_user;-- 函数中间的插入脚本
/*
INSERT INTO app_user(`name`,`email`,`phone`,`gender`,`password`,`age`)
VALUES(CONCAT('用户X'),'123345@qq.com',CONCAT('18',FLOOR(RAND()*((999999999-100000000)+100000000))),
FLOOR(RAND()*2),UUID(),FLOOR(RAND()*100));
*/-- 测试-- 加索引前
SELECT * FROM app_user WHERE `name` = '用户9999'; -- 0.440 sec
EXPLAIN SELECT * FROM app_user WHERE `name` = '用户9999';-- 创建索引
-- id_表名_字段名 索引名
-- CREATE INDEX 索引名 ON 表名(`字段名`);
CREATE INDEX id_app_user_name ON app_user(`name`);-- 加索引后
SELECT * FROM app_user WHERE `name` = '用户9999'; -- 0.002 sec
EXPLAIN SELECT * FROM app_user WHERE `name` = '用户9999';
索引在小数据量的时候,用处不大,但是再大数据的时候,区分十分明显
7.3、索引原则
- 索引不是越多越好
- 不要对经常变动的数据加索引
- 小数据量的表不需要加索引
- 索引一般加载常用来查询的字段上
索引的数据结构
Hash类型的索引
ref :innodb的默认数据结构
CodingLabs - MySQL索引背后的数据结构及算法原理
8.权限管理
8.1、用户管理
可视化管理
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NMxO7wYJ-1662530230535)(C:\Users\Genius Sue\AppData\Roaming\Typora\typora-user-images\image-20220906155014746.png)]
sql 命令操作
用户表:mysql.user
本质:读这张表进行增删改查
-- 创建用户
CREATE USER Genius IDENTIFIED BY '123456';-- 修改密码(修改当前用户密码)
SET PASSWORD = PASSWORD('123456');-- 修改密码(修改指定用户密码)
SET PASSWORD FOR Genius = PASSWORD('123456');-- 重命名 RENAME 原名字 Genius TO 新名字;
RENAME USER Genius TO newGenius;-- 用户授权 ALL PRIVILEGES 全部的权限,库,表-- ALL PRIVILEGES 除了给别人授权不行,其他都能干GRANT ALL PRIVILEGES ON *.* TO newGenius;-- 查询权限SHOW GRANTS FOR newGenius; -- 查看指定用户的权限SHOW GRANTS FOR root@localhost; -- 查看root用户的权限-- 撤销权限 REVOKE哪些权限,在哪个库,给谁撤销
REVOKE ALL PRIVILEGES ON *.* FROM newGenius;-- 删除用户
DROP USER newGenius
8.2、数据库备份
为什么要备份?
- 保证重要的数据不丢失
- 数据转移
mysql数据库备份的方式
直接拷贝物理文件 data
在Navicate这种可视化工具中手动导出
- 在想要导出的表或者库中,右键,
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qhZHfc41-1662530230537)(C:\Users\Genius Sue\AppData\Roaming\Typora\typora-user-images\image-20220906160326963.png)]
使用命令行导出 mysqldump 命令行使用
# 一张表 mysqldump -h主机 -u用户名 -p密码 数据库 表名 >物理磁盘位置/文件名 mysqldump -hlocalhost -uroot -p123456 school student >D:/a.sql# 多张表 mysqldump -h主机 -u用户名 -p密码 数据库 表名1 表名2 >物理磁盘位置/文件名 mysqldump -hlocalhost -uroot -p123456 school student result >D:/a.sql# 数据库 mysqldump -h主机 -u用户名 -p密码 数据库 >物理磁盘位置/文件名 mysqldump -hlocalhost -uroot -p123456 school >D:/a.sql# 导入 # 登录的情况下,切换到指定的数据库 # source 备份文件 # 也可以这样 mysql -u用户名 -p密码 库名<备份文件
9.规范数据库设计
9.1、为什么需要设计
当数据库比较复杂的时候,我们就需要设计了
糟糕的数据库设计
- 数据冗余,浪费空间
- 数据库插入和删除都会麻烦、异常【屏蔽使用物理外键】
- 程序的性能差
良好的数据库设计
- 节省内存空间
- 保证数据库的完整性
- 方便我们开发系统
软件开发中,关于数据库的设计
- 分析需求,分析业务和需要处理的数据库的需求
- 概要设计:设计关系图E-R图
设计数据库的步骤(个人博客)
收集信息,分析需求
用户表(用户登录注销,用户的个人信息,写博客,创建分类)
分类表(文章分类,谁创建的)
文章表(文章信息)
评论表
友链表(友情链接信息)
自定义表(系统信息,某个关键的字,或者一些主字段)
key:value
关注表(粉丝数)
说说表(发表心情, id…content…create_time)
标识实体(把需求落到每个字段)
标识实体之间的关系
- 写博客:user --> blog
- 创建分类:user --> category
- 关注:user --> user
- 友链:links
- 评论:user --> user --> blog
9.2、三大范式
为什么需要数据规范化?
- 信息重复
- 更新异常
- 插入异常
- 无法正常显示信息
- 删除异常
- 丢失有效的信息
三大范式
第一范式(1NF)
原子性:保证每一列不可再分
第二范式(2NF)
前提:满足第一范式
第二范式需要确保数据库表中的每一列都和主键相关,而不能只与主键的某一部分相关(主要针对联合主键而言)。
每张表只描述一件事情
第三范式(3NF)
前提:满足第一范式和第二范式
第三范式需要确保数据表中的每一列数据都和主键直接相关,而不能间接相关。
规范数据库的设计
规范性和性能的问题
关联查询的表不得超过三张表
- 考虑商业化的需求和目标(成本,用户体验)数据库的性能更加重要
- 在规范性能的问题的时候,需要适当的考虑一下规范性
- 故意给某些表增加一些冗余的字段。(从多表查询中变为单表查询)
- 故意增加一些计算列(从大数据库降低为小数据量的查询:索引)
10.JDBC(重点)
10.1、数据库驱动
驱动:声卡,显卡,数据库
我们的程序会通过数据库驱动,和数据库打交道!
10.2、JDBC
SUN公司为了简化开发人员的(对数据库的统一)操作,提供了一个(java操作数据库的)规范,俗称JDBC
这些规范的实现由具体的厂商去做~
对于开发人员来说,我们只需要掌握JDBC接口的操作即可!
还需要导入一个数据库驱动包 mysql-connector-java-8.0.30.jar
MySQL :: Download Connector/J
10.3、第一个JDBC程序
创建测试数据库
CREATE DATABASE jdbcstudy CHARACTER SET utf8 COLLATE utf8_general_ci;USER 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,'张三','123456','zs@sina.com','1980-12-04'),
(2,'李四','123456','lisi@sina.com','1981-12-04'),
(3,'王五','123456','wangwu@sina.com','1982-12-04');
创建一个普通项目
导入数据库驱动(jar包)
- 编写测试代码
MySQL8.0及其以上连接语句
jdbc.driver=com.mysql.cj.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/数据库名称?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
注:GMT%2B8是解决时差问题,北京时间与格林威治时间相差8个小时jdbc.username=数据库连接名称jdbc.password=数据库连接密码
package com.Kuang.lesson01;import java.sql.*;/**
* Created with IntelliJ IDEA.
*
* @author : Genius Sue
* @version : 1.0
* @Project : JDBC
* @Package : com.Kuang.lesson01
* @ClassName : .java
* @createTime : 2022/9/6 16:55
* @Email : 1420779618@qq.com
* @公众号 :
* @Website :
* @Description :
*/
public class JdbcFirstDemo {public static void main(String[] args) throws ClassNotFoundException, SQLException {//1.加载驱动,my8.0要加时区和.cjClass.forName("com.mysql.cj.jdbc.Driver");//2.用户信息和URL// useSSL=true可能会报错,改成false即可String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=GMT%2B8";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("p assword="+resultSet.getObject("password"));System.out.println("email="+resultSet.getObject("email"));System.out.println("birthday="+resultSet.getObject("birthday"));System.out.println("===============================");}//6.释放连接resultSet.close();statement.close();connection.close();}}
步骤总结:
1. 加载驱动2. 连接数据库DriverManager3. 获取执行SQL的对象 Statement4. 获得返回的结果集5. 释放连接
10.4、JDBC中对象解释
DriverManager
//1.加载驱动
//DriverManager.registerDriver(new com.mysql.jdbc.Driver());
//推荐这种写法加载驱动
Class.forName("com.mysql.jdbc.Driver");Connection connection = DriverManager.getConnection(url, userName, passWord);
// connection代表数据库
// 数据库设置自动提交
// 事务提交
// 事务回滚
connection.setAutoCommit(true);
connection.commit();
connection.rollback();
URL
String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false";// mysql默认端口3306
// 协议://主机地址:端口号/数据库名?参数1&参数2&参数3
// oracle默认端口1521
// jdbc:oracle:thin:@localhost:1521:sid
Statement 执行sql对象 、 PreparedStatement 执行sql对象
String sql = "SELECT * FROM users";//编写SQLstatement.executeQuery();//执行查询 返回ResultSet
statement.executeUpdate();//新增,删除,修改,都用这个,返回受影响的行数
statement.execute();//执行任何SQL
ResultSet 查询的结果集,封装了所有的查询结果
获得指定的数据类型
//在不知道列类型的情况下使用
resultSet.getObject();
//如果知道列类型,就使用指定的类型
resultSet.getString();
resultSet.getInt();
resultSet.getDouble();
resultSet.getBigDecimal();
resultSet.getFloat();
resultSet.getDate();
//...
遍历,指针
resultSet.beforeFirst();//移动到最前面
resultSet.afterLast();//移动到最后面
resultSet.next();//移动到下一个数据
resultSet.previous();//移动到前一行
resultSet.absolute(row);//移动到指定行
释放资源
resultSet.close();
statement.close();
connection.close();//消耗资源
10.5、statement对象
jdbc中的statement对象用于向数据库发送SQL语句,想完成对数据库的增删改查,只需要通过这个对象向数据库发送增删改查语句即可。
Statement对象的executeUpdate方法,用于向数据库发送增、删、改的SQL语句,executeUpdate执行完后,将会返回一个整数(即增删改语句导致了数据库几行数据发送了变化)。
Statement.executeQuery方法用于向数据库发送查询语句,executeQuery方法返回代表查询结果的ResultSet对象。
CRUD操作-create
使用executeUpdate(String sql)方法完成数据添加操作,示例操作:
Statement statement = connection.createStatement();
String sql = "insert into user(...) values(...)";
int num = statement.executeUpdate(sql);
if (num > 0) {System.out.println("插入成功~");
}
CRUD操作-delete
Statement statement = connection.createStatement();
String sql = "delete from user where id=1";
int num = statement.executeUpdate(sql);
if (num > 0) {System.out.println("删除成功~");
}
CRUD操作-update
Statement statement = connection.createStatement();
String sql = "update user set name='' where name =''";
int num = statement.executeUpdate(sql);
if (num > 0) {System.out.println("修改成功~");
}
CRUD操作-read
Statement statement = connection.createStatement();
String sql = "SELECT * FROM users";
ResultSet resultSet = statement.executeQuery(sql);
while (resultSet.next()) {//根据获取列的数据类型,分别调用resultSet的相应方法映射到java对象中
}
1.代码实现
1、提取工具类
package com.Kuang.lesson02.utils;import java.io.IOException; import java.io.InputStream; import java.sql.*; import java.util.Properties;public class JdbcUtils {private static String driver = null;private static String url = null;private static String username = null;private static String password = null;static {try {InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");Properties properties = new Properties();properties.load(in);driver = properties.getProperty("driver");url = properties.getProperty("url");username = properties.getProperty("username");password = properties.getProperty("password");//1.驱动只用加载一次Class.forName(driver);} catch (Exception e) {throw new RuntimeException(e);}}//获取连接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();}}} }
配置文件db.properties
driver=com.mysql.cj.jdbc.Driver
url = jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=GMT%2B8
username = root
password = 123456
1.1、增加
package com.Kuang.lesson02;import com.Kuang.lesson02.utils.JdbcUtils;import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;public class TestInsert {public static void main(String[] args) {Connection conn = null;Statement st = null;ResultSet rs = null;try {conn = JdbcUtils.getConnection();st = conn.createStatement();String sql ="INSERT INTO users(`id`,`name`,`password`,`email`,`birthday`)" +"VALUES (15,'Genius Sue','123456','GeniusSue@sina.com','2000-01-01')";int i = st.executeUpdate(sql);if(i>0){System.out.println("插入成功");}} catch (SQLException e) {e.printStackTrace();}finally {JdbcUtils.release(conn, st, rs);}}}
1.2、删除
package com.Kuang.lesson02;import com.Kuang.lesson02.utils.JdbcUtils;import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;public class TestDelete {public static void main(String[] args) {Connection conn = null;Statement st = null;ResultSet rs = null;try {conn = JdbcUtils.getConnection();st = conn.createStatement();String sql ="DELETE FROM users WHERE `id`=8";int i = st.executeUpdate(sql);if(i>0){System.out.println("删除成功");}} catch (SQLException e) {e.printStackTrace();}finally {JdbcUtils.release(conn, st, rs);}}
}
1.3、修改
package com.Kuang.lesson02;import com.Kuang.lesson02.utils.JdbcUtils;import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;public class TestUpdate {public static void main(String[] args) {Connection conn = null;Statement st = null;ResultSet rs = null;try {conn = JdbcUtils.getConnection();st = conn.createStatement();String sql ="UPDATE users SET birthday='1990-12-01' WHERE id=1";int i = st.executeUpdate(sql);if(i>0){System.out.println("更新成功");}} catch (SQLException e) {e.printStackTrace();}finally {JdbcUtils.release(conn, st, rs);}}
}
1.4、查询
package com.Kuang.lesson02;import com.Kuang.lesson02.utils.JdbcUtils;import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;public class Select {public static void main(String[] args) {Connection conn = null;Statement st = null;ResultSet rs = null;try {conn = JdbcUtils.getConnection();st = conn.createStatement();//SQLString sql = "SELECT * FROM users where id = 1";rs = st.executeQuery(sql);//查询完毕会返回一个结果集while (rs.next()) {System.out.println("id="+rs.getInt("id"));System.out.println("name="+rs.getString("name"));}} catch (SQLException e) {throw new RuntimeException(e);}finally {JdbcUtils.release(conn,st,rs);}}
}
2.SQL注入问题
sql存在漏洞,会被攻击导致数据泄露,SQL会被拼接
package com.Kuang.lesson02;import com.Kuang.lesson02.utils.JdbcUtils;import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;/*** Created with IntelliJ IDEA.** @author : Genius Sue* @version : 1.0* @Project : JDBC* @Package : com.Kuang.lesson02* @ClassName : .java* @createTime : 2022/9/7 8:55* @Email : 1420779618@qq.com* @公众号 :* @Website :* @Description :*/
public class SQL {public static void main(String[] args) {// 正常登录
// login("张三","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();//SQLString sql = "SELECT * FROM users where `name` = '"+username+"'AND `pass word` = '" + password + "'";rs = st.executeQuery(sql);//查询完毕会返回一个结果集while (rs.next()) {System.out.println("id="+rs.getInt("id"));System.out.println("name="+rs.getString("name"));}} catch (SQLException e) {throw new RuntimeException(e);}finally {JdbcUtils.release(conn,st,rs);}}
}
导致结果:错误的用户名或者密码可以获取到全部的用户信息
10.6、PreparedStatement对象
PreparedStatement可以防止SQL注入,并且效率更高!
1.增加
package com.Kuang.lesson03;import com.Kuang.lesson02.utils.JdbcUtils;import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;/*** Created with IntelliJ IDEA.** @author : Genius Sue* @version : 1.0* @Project : JDBC* @Package : com.Kuang.lesson03* @ClassName : .java* @createTime : 2022/9/7 9:09* @Email : 1420779618@qq.com* @公众号 :* @Website :* @Description :*/
public class TestInsert {public static void main(String[] args) {Connection conn = null;PreparedStatement pstmt =null;ResultSet rs = null;try {conn = JdbcUtils.getConnection();//与Statement的区别//使用?占位符代替参数String sql ="INSERT INTO users(`id`,`name`,`password`,`email`,`birthday`) VALUES(?,?,?,?,?)";pstmt = conn.prepareStatement(sql);//预编译sql,先写sql,不执行//手动给参数赋值pstmt.setInt(1, 4);pstmt.setString(2, "Genius Sue");pstmt.setString(3, "123456");pstmt.setString(4, "123456@qq.com");//注意点:sql.Date 数据库 new java.sql.Date()// util.Date java new Date().getTime()pstmt.setDate(5, new java.sql.Date(new Date().getTime()));//执行int i = pstmt.executeUpdate();if (i>0){System.out.println("插入成功");}} catch (SQLException e) {throw new RuntimeException(e);}finally {JdbcUtils.release(conn, pstmt, rs);}}
}
2.删除
package com.Kuang.lesson03;import com.Kuang.lesson02.utils.JdbcUtils;import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;/*** Created with IntelliJ IDEA.** @author : Genius Sue* @version : 1.0* @Project : JDBC* @Package : com.Kuang.lesson03* @ClassName : .java* @createTime : 2022/9/7 9:45* @Email : 1420779618@qq.com* @公众号 :* @Website :* @Description :*/
public class TestDelete {public static void main(String[] args) {Connection conn = null;PreparedStatement pstmt =null;ResultSet rs = null;try {conn = JdbcUtils.getConnection();String sql ="DELETE FROM users WHERE id = ?";pstmt = conn.prepareStatement(sql);pstmt.setInt(1, 4);int i = pstmt.executeUpdate();if (i>0){System.out.println("删除成功");}} catch (SQLException e) {throw new RuntimeException(e);}finally {JdbcUtils.release(conn, pstmt, rs);}}}
3.修改
package com.Kuang.lesson03;import com.Kuang.lesson02.utils.JdbcUtils;import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;/*** Created with IntelliJ IDEA.** @author : Genius Sue* @version : 1.0* @Project : JDBC* @Package : com.Kuang.lesson03* @ClassName : .java* @createTime : 2022/9/7 9:45* @Email : 1420779618@qq.com* @公众号 :* @Website :* @Description :*/
public class TestUpdate {public static void main(String[] args) {Connection conn = null;PreparedStatement pstmt =null;ResultSet rs = null;try {conn = JdbcUtils.getConnection();String sql ="update users set `name` = ? where id=?";pstmt = conn.prepareStatement(sql);pstmt.setString(1, "天才");pstmt.setInt(2,3);int i = pstmt.executeUpdate();if (i>0){System.out.println("更新成功");}} catch (SQLException e) {throw new RuntimeException(e);}finally {JdbcUtils.release(conn, pstmt, rs);}}
}
4.查询
package com.Kuang.lesson03;import com.Kuang.lesson02.utils.JdbcUtils;import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;/*** Created with IntelliJ IDEA.** @author : Genius Sue* @version : 1.0* @Project : JDBC* @Package : com.Kuang.lesson03* @ClassName : .java* @createTime : 2022/9/7 9:54* @Email : 1420779618@qq.com* @公众号 :* @Website :* @Description :*/
public class TestSelect {public static void main(String[] args) {Connection conn =null;PreparedStatement pstm = null;ResultSet rs = null;try {conn = JdbcUtils.getConnection();String sql ="select * from users where id = ?";pstm = conn.prepareStatement(sql);pstm.setInt(1, 3);rs = pstm.executeQuery();if (rs.next()){System.out.println(rs.getString("NAME"));}} catch (SQLException e) {throw new RuntimeException(e);}finally {JdbcUtils.release(conn, pstm, rs);}}
}
5.防止SQL注入
package com.Kuang.lesson03;import com.Kuang.lesson02.utils.JdbcUtils;import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;/*** Created with IntelliJ IDEA.** @author : Genius Sue* @version : 1.0* @Project : JDBC* @Package : com.Kuang.lesson03* @ClassName : .java* @createTime : 2022/9/7 9:54* @Email : 1420779618@qq.com* @公众号 :* @Website :* @Description :*/
public class TestSelect {public static void main(String[] args) {Connection conn =null;PreparedStatement pstm = null;ResultSet rs = null;try {conn = JdbcUtils.getConnection();String sql ="select * from users where id = ?";pstm = conn.prepareStatement(sql);pstm.setInt(1, 3);rs = pstm.executeQuery();if (rs.next()){System.out.println(rs.getString("NAME"));}} catch (SQLException e) {throw new RuntimeException(e);}finally {JdbcUtils.release(conn, pstm, rs);}}
}
10.7、事物
ACID原则
原子性:要么都做,要么都不做
一致性:总数不变
隔离性:多个进程互不干扰
持久性:一旦提交不可逆,持久化到数据库了
隔离性的问题:
脏读:一个事务读取了另外一个没有提交的事务
不可重复读:在同一个事务内,重复读取表中数据,表数据发生了改变
幻读:在一个事务内,读取到了别人插入的数据,导致前后读出来的结果不一致
代码实现
- 开启事务
con.setAutoCommit(false);
- 一组业务执行完毕,提交事务
- 可以在catch语句中显示的定义回滚语句,但是默认失败就会回滚
正常情况
package com.Kuang.lesson04;import com.Kuang.lesson02.utils.JdbcUtils;import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;/*** Created with IntelliJ IDEA.** @author : Genius Sue* @version : 1.0* @Project : JDBC* @Package : com.Kuang.lesson04* @ClassName : .java* @createTime : 2022/9/7 10:50* @Email : 1420779618@qq.com* @公众号 :* @Website :* @Description :*/
public class TestTransaction01 {public static void main(String[] args) {Connection conn = null;PreparedStatement pstm = null;ResultSet rs = null;try {conn = JdbcUtils.getConnection();//关闭数据库自动提交,会自动开启事物conn.setAutoCommit(false);//开启事务String sql01="update account set money = money-100 where name ='A'";pstm = conn.prepareStatement(sql01);pstm.executeUpdate();String sql02="update account set money = money+100 where name ='B'";pstm = conn.prepareStatement(sql02);pstm.executeUpdate();//业务完毕,提交事物conn.commit();System.out.println("操作成功");} catch (SQLException e) {try {//失败会默认回滚conn.rollback();//如果失败回滚事务} catch (SQLException ex) {throw new RuntimeException(ex);//System.out.println("操作失败");}throw new RuntimeException(e);}finally {JdbcUtils.release(conn, pstm, rs);}}
}
异常情况
package com.Kuang.lesson04;import com.Kuang.lesson02.utils.JdbcUtils;import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;/*** Created with IntelliJ IDEA.** @author : Genius Sue* @version : 1.0* @Project : JDBC* @Package : com.Kuang.lesson04* @ClassName : .java* @createTime : 2022/9/7 10:50* @Email : 1420779618@qq.com* @公众号 :* @Website :* @Description :*/
public class TestTransaction01 {public static void main(String[] args) {Connection conn = null;PreparedStatement pstm = null;ResultSet rs = null;try {conn = JdbcUtils.getConnection();//关闭数据库自动提交,会自动开启事物conn.setAutoCommit(false);//开启事务String sql01="update account set money = money-100 where name ='A'";pstm = conn.prepareStatement(sql01);pstm.executeUpdate();int x = 1/0;//报错String sql02="update account set money = money+100 where name ='B'";pstm = conn.prepareStatement(sql02);pstm.executeUpdate();//业务完毕,提交事物conn.commit();System.out.println("操作成功");} catch (SQLException e) {try {//失败会默认回滚conn.rollback();//如果失败回滚事务} catch (SQLException ex) {throw new RuntimeException(ex);//System.out.println("操作失败");}throw new RuntimeException(e);}finally {JdbcUtils.release(conn, pstm, rs);}}
}
10.8、数据库连接池
数据库连接 – 执行完毕 – 释放
连接-- 释放 是十分浪费系统资源的
池化技术:准备一些预先的资源,过来就连接预先准备好的
最小连接数:10(常用连接)
最大连接数:100 (业务最高承载上线)
超过最大连接数,排队等待
等待超时:100ms
编写连接池,实现一个接口DataSource
使用了这些数据库连接池之后,我们在项目开发中就不需要编写连接数据库的代码了
DBCP
需要用到的jar包
commons-pool.jar 下载地址
http://commons.apache.org/proper/commons-pool/download_pool.cgi
commons-dbcp.jar 下载地址
http://commons.apache.org/proper/commons-dbcp/download_dbcp.cgi
commons logging jar下载地址
Apache Commons Logging - Download Apache Commons Logging
配置文件dbcp.properties
#连接设置
driverClassName=com.mysql.cj.jdbc.Driver
url = jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=GMT%2B8
username=root
password=123456#初始化连接-常用连接数
initialSize=10#最大连接数量
maxActive=50#最大空闲连接
maxIdle=20#最小空闲连接
minIdle=5#超时等待时间以毫秒为单位 6000毫秒/1000等于60秒
maxWait=60000
#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样:【属性名=property;】
#注意:user 与 password 两个属性会被明确地传递,因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=UTF8#指定由连接池所创建的连接的自动提交(auto-commit)状态。
defaultAutoCommit=true#driver default 指定由连接池所创建的连接的只读(read-only)状态。
#如果没有设置该值,则“setReadOnly”方法将不被调用。(某些驱动并不支持只读模式,如:Informix)
defaultReadOnly=#driver default 指定由连接池所创建的连接的事务级别(TransactionIsolation)。
#可用值为下列之一:(详情可见javadoc。)NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_COMMITTED
工具类
package com.Kuang.lesson05.utils;import com.Kuang.lesson02.utils.JdbcUtils;
import org.apache.commons.dbcp2.BasicDataSourceFactory;import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;/*** Created with IntelliJ IDEA.** @author : Genius Sue* @version : 1.0* @Project : JDBC* @Package : com.Kuang.lesson05.utils* @ClassName : .java* @createTime : 2022/9/7 11:28* @Email : 1420779618@qq.com* @公众号 :* @Website :* @Description :*/
public class JdbcUtils_DBCP {private static DataSource dataSource = null;static {try {InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("dbcp.properties");Properties properties = new Properties();properties.load(in);//创建数据源dataSource = BasicDataSourceFactory.createDataSource(properties);} catch (Exception e) {throw new RuntimeException(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();}}}
}
测试类
package com.Kuang.lesson05;import com.Kuang.lesson05.utils.JdbcUtils_DBCP;import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;/*** Created with IntelliJ IDEA.** @author : Genius Sue* @version : 1.0* @Project : JDBC* @Package : com.Kuang.lesson05* @ClassName : .java* @createTime : 2022/9/7 11:46* @Email : 1420779618@qq.com* @公众号 :* @Website :* @Description :*/
public class TestDBCP {public static void main(String[] args) {Connection conn = null;PreparedStatement pstmt =null;ResultSet rs = null;try {conn = JdbcUtils_DBCP.getConnection();//与Statement的区别//使用?占位符代替参数String sql ="INSERT INTO users(`id`,`name`,`password`,`email`,`birthday`) VALUES(?,?,?,?,?)";pstmt = conn.prepareStatement(sql);//预编译sql,先写sql,不执行//手动给参数赋值pstmt.setInt(1, 5);pstmt.setString(2, "Genius Sue");pstmt.setString(3, "123456");pstmt.setString(4, "123456@qq.com");//注意点:sql.Date 数据库 new java.sql.Date()// util.Date java new Date().getTime()pstmt.setDate(5, new java.sql.Date(new Date().getTime()));//执行int i = pstmt.executeUpdate();if (i>0){System.out.println("插入成功");}} catch (SQLException e) {throw new RuntimeException(e);}finally {JdbcUtils_DBCP.release(conn, pstmt, rs);}}
}
C3P0
需要用到的jar包
https://sourceforge.net/projects/c3p0/
配置文件c3p0-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config><!--c3p0的缺省(默认)配置如果在代码中ComboPooledDataSource ds=new ComboPooledDataSource();这样写就表示使用的是c3p0的缺省(默认)--><default-config><property name="driverClass">com.mysql.jdbc.Driver</property><property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC</property><property name="user">root</property><property name="password">123456</property><property name="acquiredIncrement">5</property><property name="initialPoolSize">10</property><property name="minPoolSize">5</property><property name="maxPoolSize">20</property></default-config><!--c3p0的命名配置如果在代码中ComboPooledDataSource ds=new ComboPooledDataSource("MySQL");这样写就表示使用的是name是MySQL--><name-config name="MySQL"><property name="driverClass">com.mysql.cj.jdbc.Driver</property><property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=GMT%2B8</property><property name="user">root</property><property name="password">123456</property><property name="acquiredIncrement">5</property><property name="initialPoolSize">10</property><property name="minPoolSize">5</property><property name="maxPoolSize">20</property></name-config>
</c3p0-config>
工具类
package com.Kuang.lesson05.utils;import com.Kuang.lesson02.utils.JdbcUtils;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbcp2.BasicDataSourceFactory;import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;/*** Created with IntelliJ IDEA.** @author : Genius Sue* @version : 1.0* @Project : JDBC* @Package : com.Kuang.lesson05.utils* @ClassName : .java* @createTime : 2022/9/7 11:28* @Email : 1420779618@qq.com* @公众号 :* @Website :* @Description :*/
public class JdbcUtils_C3P0 {// private static ComboPooledDataSource dataSource = null; private static DataSource dataSource = null;static {try {//代码版配置
// dataSource = new ComboPooledDataSource();
// dataSource = new ComboPooledDataSource();
// dataSource.setDriverClass();
// dataSource.setJdbcUrl();
// dataSource.setUser();
// dataSource.setPassword();
// dataSource.setMaxPoolSize();
// dataSource.setMinPoolSize();//创建数据源dataSource = new ComboPooledDataSource("MySQL");//配置文件写法} catch (Exception e) {throw new RuntimeException(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();}}}
}
测试类
package com.Kuang.lesson05;import com.Kuang.lesson05.utils.JdbcUtils_C3P0;
import com.Kuang.lesson05.utils.JdbcUtils_DBCP;import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;/*** Created with IntelliJ IDEA.** @author : Genius Sue* @version : 1.0* @Project : JDBC* @Package : com.Kuang.lesson05* @ClassName : .java* @createTime : 2022/9/7 11:46* @Email : 1420779618@qq.com* @公众号 :* @Website :* @Description :*/
public class TestC3P0 {public static void main(String[] args) {Connection conn = null;PreparedStatement pstmt =null;ResultSet rs = null;try {conn = JdbcUtils_C3P0.getConnection();//原来是自己实现的,现在用别人实现的//与Statement的区别//使用?占位符代替参数String sql ="INSERT INTO users(`id`,`name`,`password`,`email`,`birthday`) VALUES(?,?,?,?,?)";pstmt = conn.prepareStatement(sql);//预编译sql,先写sql,不执行//手动给参数赋值pstmt.setInt(1, 6);pstmt.setString(2, "Genius Sue");pstmt.setString(3, "123456");pstmt.setString(4, "123456@qq.com");//注意点:sql.Date 数据库 new java.sql.Date()// util.Date java new Date().getTime()pstmt.setDate(5, new java.sql.Date(new Date().getTime()));//执行int i = pstmt.executeUpdate();if (i>0){System.out.println("插入成功");}} catch (SQLException e) {throw new RuntimeException(e);}finally {JdbcUtils_C3P0.release(conn, pstmt, rs);}}
}
总结
无论用什么数据源,本质还是一样的,DataSource接口不会变,方法就不会变
【数据库】MySQL入门相关推荐
- 01 MySQL数据库 MySQL入门
01 MySQL数据库 从今天开始,我们将进入系列课程的 第四模块 的学习,这个模块就是给大家讲解MySQL数据库. 以前,在开发程序时,我们会把很多的数据和信息存储到某个文件夹中的文件中,例如:us ...
- 数据库MySQL入门-上
文章目录 第1章 数据库 1.1 数据库概述 1.2 数据库表 1.3 表数据 第2章 MySql数据库 2.1 MySql安装 2.2 登录MySQL数据库 2.3 使用MySQL图形化开发工具 2 ...
- mysql数据库应用与开发姜桂洪 课后答案_数据库(MySQL) 入门实践
1 数据库 存放数据的仓库.例如你的账号信息,订单记录等. 2 SQL Structured Query Language,用于访问和处理关系数据库的标准的计算机语言. 按照功能又可分为四大类: DQ ...
- 数据库|MySQL入门大全
MySQL数据库入门大全 由于毕业后第一份工作的部分原因,必须好好地再学习下数据库,重点是MySQL.本文总结了自己学习过程中的全部历程,有数据库的基本概念介绍,有MySQL数据库中的4种语言,也有& ...
- 数据库MySQL入门第一天
数据库的几个基本概念 1,数据库(Database,DB) 数据库指的是以一定格式存放.能够实现多个用户共享.与应用程序彼此独立的数据集合. 2,数据库管理系统(Database Management ...
- mysql数据库 菜鸟_数据库-MySQL入门
什么是数据库? 一定方式储存在一起.能与多个用户共享.具有尽可能小的冗余度.与应用程序彼此独立的数据集合 数据库管理系统(简称DBMS):是为管理数据库而设计的电脑软件系统,一般具有存储.截取.安全保 ...
- [ 数据库 ] MySQL 入门到放弃(三) --- MySQL 数据管理
- Yii Framework2.0开发教程(5)数据库mysql性能
继续<Yii Framework2.0开发教程(3)数据库mysql入门> 首先给予一定的尊重yii2数据库支持引进 Yii 基于 PHP's PDO一个成熟的数据库访问层的建立.它提供了 ...
- 2. Mysql数据库的入门知识
2. Mysql数据库的入门知识 (1)打开Windows系统提供的服务查看相应的服务. (2)在Windows任务管理器的进程中查看 (3)使用命令行管理windows的Mysql数据库服务. Ne ...
- 超经典两万字,MySQL数据库快速入门。
「作者主页」:士别三日wyx 「作者简介」:CSDN top100.阿里云博客专家.华为云享专家.网络安全领域优质创作者 「专栏简介」:此文章已录入专栏<MySQL数据库快速入门> MyS ...
最新文章
- SHELL学习 续2
- Android导入工程提示Invalid project description
- [Debug]IOS微信浏览器不支持form表单的target=_blank
- Centos7下,简单DOCKER 使用.映射SSH端口到宿主主机.
- java 播放swf_我用java写了一个播放swf动画的类运行时报错了,代码和报错如下…...
- python书籍_Python书籍大汇总——入门到实战
- nginx只能访问80端口_nginx 访问不了非80端口
- 使用 Javascript操作DOM的一些方法
- layui搭建的php后台,使用layui框架搭建后台布局
- 不失真截取PDF中的矢量图到Word里
- oracle 运营维护_总结几个ORACLE数据库日常运维常用的命令(持续更新)
- HBase 的(伪)分布式安装
- 信息流媒体变现_抖音信息流投放优势,为什么选择抖音信息流广告投放呢?
- OC省字典的数组摘要集
- PotPlayer播放器在双屏扩展模式下,视频播放时所遇到的几个常见问题的专业解答
- 删除微云同步助手计算机快捷访问,腾讯微云同步助手使用说明:设置同步文件,方便随时查看...
- elasticsearch7.6 词频统计
- 功能:编写函数long fun ( char *p),将一个数字字符串转换为一个整数(不得调用C语言提供的将字符串转换为整数的函数)。
- 0基础学MySQL数据库—从小白到大牛(20)大小写规范、sql_mode的合理设置
- 360测试开发面试总结 -- 失败