MySQL
1、初识MySQL
Java EE ：企业级Java开发 Web
前端（页面：展示，数据！）
后台（连接点：连接数据库JDBC,链接前端（控制，控制试图跳转和给前端传递数据））
数据库（存数据，Txt、Excal、Word）
只会写代码，学好数据库，基本混饭吃
操作数据库，数据结构与算法，当一个不错的程序员
离散数学、数字电路、体系结构、编译原理。 +实战经验 高级程序员
1.1、为什么要学习数据库
- 岗位需求
- 现在的世界，大数据时代，得数据者得天下
- 被迫需求，存数据
- 数据库是所有软件体系中最核心的存在
1.2、什么是数据库
数据库（DB DataBase）
概念：数据仓库，软件，安装在操作系统（Windows linux mac …）之上，SQL，可以存储大量的数据 500万
作用：存储数据，管理数据
1.3、数据库分类
关系型数据库 （SQL）
- MySQL Oracle Sql Server DB2 SQLlite
- 通过表和表之间，行和列之间的关系进行数据的存储
非关系型数据库 （NoSQL） Not Only
- Redis MongDB
- 非关系型数据库，对象存储，通过对象的自身的属性来决定
DBMS(数据库管理系统)
- 数据库的管理软件，科学有效的管理我们的数据，维护和获取数据
- MySQL,数据库管理系统
1.4、MySQL简介
MySQL是一个关系型数据库管理系统
前世：瑞典MySQL AB公司
今生：属于Oracle 旗下产品
MySQL是最好的RDNMS(Relational Database Management System，关系数据库管理系统) 应用软件之一
开源的数据库软件
体积小、速度快、总体拥有成本低，招人成本也比较低，所有人必须会
中小型网站、或者大型网站、集群
官网：https://www.mysql.com/
安装建议：
-
尽量不要使用exe 删除时很难删除干净 注册表
-
尽可能使用压缩包安装
1.5、安装MySQL
5.7版本压缩包下载地址:https://dev.mysql.com/get/Downloads/MySQL-5.7/mysql-5.7.19-winx64.zip
-
解压
-
把这个包放到自己 的电脑环境目录下（建议）
-
在电脑path环境变量中添加自己的mysql文件夹下的bin目录
D:\mysql-5.7.19\bin //这里是我的目录 -
在mysql文件夹下新建一个my.ini文件
内容为
[mysqld] #目录一定要换成自己的 basedir=D:\mysql-5.7.19\ datadir=D:\mysql-5.7.19\data\ port=3306 #跳过密码 skip-grant-tables -
启动管理员下的cmd，将路径切换到mysql下的bin目录
cd /d D:\mysql-5.7.19\bin -
输入(安装mysql)
mysqld -install -
输入(初始化数据文件)
mysqld --initialize-insecure --user=mysql -
启动mysql
net start mysql -
进入mysql管理界面,(-p后面不要加空格)
mysql -u root -p -
进入界面后更改root密码（sql语句后一定要加;）
update mysql.user set authentication_string=password('123456') where user='root' and Host='localhost'; -
最后输入
flush privileges; //刷新权限 -
修改my.ini文件删除最后一句skip-grant-tables
-
重启mysql即可正常使用
net stop mysql net start mysql
1.6、安装SQLyog
-
安装
-
注册
-
打开连接数据库
-
尝试新建一个数据库school
-
尝试新建一个一张表student
字段：id name age -
查看表
-
自己尝试删除和添加表中内容
每一个sqlyog的执行操作，本质就是对应了一个sql，可以在软件的历史记录中查看
1.7、连接数据库
命令行连接
mysql -uroot -p123456 --连接数据库
------------------------------------
--所有的语句都是用;结尾
update mysql.user set authentication_string=password('123456') where user='root' and Host='localhost'; --修改用户密码
flush privileges; --刷新权限
show databases; --查看所有的数据库
use school --切换数据库use数据库名
show tables; --查看数据库中所有的表
describe student; --显示数据库中表的信息
create database person --创建一个名为person的表
exit; --退出连接
--单行注释 （SQL本来的注释）
/*
SQL的多行注释
*/
数据库语言 CRUD增删改查！
DDL 定义
DML 操作
DQL 查询
DCL 控制
2、操作数据库
操作数据库–>操作数据库中的表–>操作数据库中表的数据
mysql关键字不区分大小写
2.1、操作数据库
-
创建数据库
CREATE DATABASE [IF NOT EXISTS] person -
删除数据库
DROP DATABASE [IF EXISTS] person -
使用数据库
-- 如果你的表名和字段名是一个特殊字符的话，需要带`` USE `school` -
查看数据库
SHOW DATABASES --查看所有的数据库
学习思路：
- 对照sqlyog可视化历史记录查看sql
- 固定的语法或关键字必须要强行记住
2.2、数据库的列类型
-
数值
- tinyint 十分小的数据 1个字节
- smallint 较小的数据 2个字节
- mediumint 中等大小的数据 3个字节
- int 标准的整数 4个字节 常用
- bigint 较大的数据 8个字节
- float 浮点数 4个字节
- double 浮点数 8个字节
- decimal 字符串形式的浮点数 一般在金融计算的时候使用
-
字符串
- char 字符串固定大小的 0~255
- varchar 可变字符串 0~65535 常用的变量
- tinytext 微型文本
- text 文本串 保存大文本
-
时间日期
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
- 假设设置为非空，如果不给它赋值，就会报错
- NULL，如果不填写值，默认就是null
- 默认：
- 设置默认的值
拓展（了解）
/*
每一个表，都必须存在以下5个字段，未来做项目用的，表示每一个记录存在的意义
id 主键
version 乐观锁
is_delete 伪删除
gmt_create 创建时间
gmt_update 修改时间
*/
2.4、创建数据库表（重点）
-- 使用school数据库
-- 创建学生student表(列，字段) 使用SQL创建
-- 学号 登录密码 姓名 性别 出生日期 家庭住址 邮箱
-- 注意点，使用英文(),表的名称和字段尽量使用``括起来
-- AUTO_INCREMENT 自增
-- 字符串使用单引号括起来
-- 所有的语句后面加,(英文的)，最后一个不用加
-- PRIMARY KEY 主键，一般一个表只有一个唯一的主键
USE school
CREATE TABLE IF NOT EXISTS `student`(
`id` INT(10) NOT NULL AUTO_INCREMENT COMMENT '学号',
`pwd` VARCHAR(15) DEFAULT '123456' COMMENT '密码',
`name` VARCHAR(10) NOT NULL COMMENT '姓名',
`age` INT(3) NOT NULL COMMENT '年龄',
`birthday` DATETIME NOT NULL COMMENT '出生日期',
`sex` VARCHAR(2) DEFAULT '男' COMMENT '性别',
`email` VARCHAR(15) COMMENT '邮箱',
`address` VARCHAR(10) COMMENT '家庭住址',
PRIMARY KEY (`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8 --设置表的类型为INNODB 默认编码格式utf-8
总结格式：
CREATE TABLE [IF NOT EXISTS] 表名(
`字段名` 列类型 [属性] [索引] [注释],
`字段名` 列类型 [属性] [索引] [注释],
.....
`字段名` 列类型 [属性] [索引] [注释]
)[表类型] [字符集设置] [注释]
常用命令
SHOW CREATE DATABASE `school` -- 查看创建数据库的语句
SHOW CREATE TABLE `student` -- 查看创建student数据表时的定义语句
DESC `student` -- 显示表的结构
2.5、数据表的类型
-- 关于数据库引擎
/*
INNODB 默认使用~
MYISAM 早些年使用的
*/
| MYISAM | INNODB | |
|---|---|---|
| 事务支持 | 不支持 | 支持 |
| 数据行锁定 | 不支持（表锁） | 支持 |
| 外键约束 | 不支持 | 支持 |
| 全文索引 | 支持 | 不支持 |
| 表空间的大小 | 较小 | 较大，约为MYISAM的两倍 |
常规使用操作
- MYISAM 节约空间，速度较快
- INNODB 安全性高，事务的处理，多表多用户操作
在物理空间存在的位置
所有的数据库文件都存在data，一个文件夹就对应一个数据库
本质就是文件的存储
MySQL引擎在物理文件上的区别
- INNODB 在数据库表中只有一个 *.frm 文件，以及上级目录下的ibdata1文件
- MYISAM对应文件
- *.frm 表结构的定义文件
- *.MYD 数据文件（data）
- *.MYI 索引文件（index）
设置数据库表的字符串编码
CHARSRT=UTF8
不设置的话，MySQL的默认编码是Latin1，不支持中文
在my.ini中默认配置的编码
character-set-server=utf8
2.6、修改删除表
-
修改
-- 修改表名 ALTER TABLE 旧表名 RENAME AS 新表明 ALTER TABLE `teacher` RENAME AS teacher1 -- 增加表的字段 ALTER TABLE 表名 ADD 字段名 列属性 ALTER TABLE `teacher1` ADD `age` INT(3) -- 修改表的字段（修改约束，字段重命名） --ALTER TABLE 表名 MODIFY 字段名 列属性[] ALTER TABLE `teacher1` MODIFY age VARCHAR(3) -- 修改约束 --ALTER TABLE 表名 CHANGE 旧名字 新名字 列属性[] ALTER TABLE `teacher1` CHANGE `age` `age1` INT(3) -- 字段重命名 -- 删除表的字段 --ALTER TABLE 表名 DROP 字段名 ALTER TABLE `teacher1` DROP `age1` -
删除
-- 删除表（如果表存在再删除） DROP TABLE IF EXISTS`teacher1`
所有的创建和删除操作尽量加上判断，以免报错
注意点：
- 所有的字段名使用``包裹
- 注释 – /**/
- sql关键字大小写不敏感，建议写小写
- 所有的符号全部用英文
3、MySQL数据管路
3.1、外键（了解即可）
-
方式一：在创建表的时候，增加约束
CREATE TABLE `grade`( `gradeid` INT(5) NOT NULL AUTO_INCREMENT COMMENT '老师编号', `name` VARCHAR(5) COMMENT '姓名', PRIMARY KEY (`gradeid`) ) ENGINE=INNODB CHARSET=utf8 COLLATE=utf8_general_ci; ----------------------- --学生表的gradeid字段，要去引用年级表的gradeid --定义给外键key --给这个外键添加约束（执行引用） references 引用 CREATE TABLE `student` ( `id` INT(10) NOT NULL AUTO_INCREMENT COMMENT '学号', `pwd` VARCHAR(15) DEFAULT '123456' COMMENT '密码', `name` VARCHAR(10) NOT NULL COMMENT '姓名', `age` INT(3) NOT NULL COMMENT '年龄', `birthday` DATETIME NOT NULL COMMENT '出生日期', `sex` VARCHAR(2) DEFAULT '男' COMMENT '性别', `email` VARCHAR(15) DEFAULT NULL COMMENT '邮箱', `address` VARCHAR(10) DEFAULT NULL COMMENT '家庭住址', `gradeid` INT(5) COMMENT '年级', PRIMARY KEY (`id`), KEY `FK_gradeid` (`gradeid`), --重点 CONSTRAINT `FK_grade` FOREIGN KEY (`gradeid`) REFERENCES `grade`(`gradeid`) --重点 ) ENGINE=INNODB DEFAULT CHARSET=utf8删除有外键关系的表时，必须要先删除引用别人的表（从表），在删除被引用的表（主表）
-
方式二：表创建成功后，添加外键约束
CREATE TABLE `grade`( `gradeid` INT(5) NOT NULL AUTO_INCREMENT COMMENT '老师编号', `name` VARCHAR(5) COMMENT '姓名', PRIMARY KEY (`gradeid`) ) ENGINE=INNODB CHARSET=utf8 COLLATE=utf8_general_ci; -- -- -- -- -- -- -- -- -- -- CREATE TABLE `student` ( `id` INT(10) NOT NULL AUTO_INCREMENT COMMENT '学号', `pwd` VARCHAR(15) DEFAULT '123456' COMMENT '密码', `name` VARCHAR(10) NOT NULL COMMENT '姓名', `age` INT(3) NOT NULL COMMENT '年龄', `birthday` DATETIME NOT NULL COMMENT '出生日期', `sex` VARCHAR(2) DEFAULT '男' COMMENT '性别', `email` VARCHAR(15) DEFAULT NULL COMMENT '邮箱', `address` VARCHAR(10) DEFAULT NULL COMMENT '家庭住址', `gradeid` INT(5) COMMENT '年级', PRIMARY KEY (`id`) ) ENGINE=INNODB DEFAULT CHARSET=utf8 -- 重点 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
-- 插入语句（添加数据） -- 语法：insert into 要插入数据的表名 (字段名1,字段名2,字段名3,...) values ('值1','值2','值3'...),('值1','值2','值3'...),('值1','值2','值3'...),... -- 一般写插入语句时，数据和字段必须一一对应 -
update
--UPDATE 表名 SET colnum_nuame（字段）=value WHERE 条件 -
delete
--delete from 表名 where 条件
1、添加
insert into
-- 插入语句（添加数据）
-- 语法：insert into 要插入数据的表名 (字段名1,字段名2,字段名3,...) values ('值1','值2','值3'...),('值1','值2','值3'...),('值1','值2','值3'...),...
-- 一般写插入语句时，数据和字段必须一一对应
INSERT INTO `grade`(`gradename`) VALUES ('大一')
-- 插入多个字段
INSERT INTO `student` (`name`,`age`,`sex`,`address`)
VALUES ('小明',12,'男','北京'),('小红',13,'女','上海')
语法：
语法：insert into 要插入数据的表名 (字段名1,字段名2,字段名3,...) values ('值1','值2','值3'...),('值1','值2','值3'...),('值1','值2','值3'...),...
注意事项：
- 字段和字段之间使用英文逗号隔开
- 字段是可以省略的，但是后面的值必须要一一对应，不能少
- 可以插入多条数据，values后面的值，需要使用英文逗号隔开即可values (),(),(),…
2、修改
update 修改谁 （条件） set 原来的值= 新的值
-- 修改学员名字，带了条件
UPDATE `student` SET `name`='隔壁老王' WHERE `id`=1
-- 不指定条件的情况下，会改动所有表（别去这样干）
UPDATE `student` SET `name`='隔壁老王'
--修改多个属性，逗号隔开
UPDATE `student` SET `name`='老王',`address`='隔壁' WHERE `id`=2
-- 语法
-- UPDATE 表名 SET colnum_nuame（字段）=value WHERE 条件
条件：where子句运算符 id等于某个值，大于某个值，在某个区间内修改…
操作符会返回布尔值
| 操作符 | 含义 |
|---|---|
| = | 等于 |
| <>或 != | 不等于 |
| > | 大于 |
| < | 小于 |
| >= | 大于等于 |
| <= | 小于等于 |
| between…and… | 在某个范围内 |
| and | 与 |
| or | 或 |
-- 通过多个条件定位数据
UPDATE `student` SET `name`='王叔叔',`address`='隔壁' WHERE `id` BETWEEN 2 AND 4
UPDATE `student` SET `name`='老王',`address`='隔壁' WHERE `id`=4 AND `address`='上海'
UPDATE `student` SET `name`='老王',`address`='上海' WHERE `id`=4 OR `address`='隔壁'
语法：UPDATE 表名 SET colnum_nuame（字段）=value WHERE 条件
注意事项：
-
colnum_name是数据库的列，尽量带上``
-
条件：筛选，如果没有指定，则会修改所有的列
-
value，是一个具体的值，也可以是一个变量
UPDATE `student` SET `birthday`=CURRENT_TIME WHERE `id`= 5 -
多个设置的属性之间，使用英文逗号隔开
3、删除
delete 命令
语法：delete from 表名 where 条件
-- 删除数据，（避免这样写，会全部删除）
DELETE FROM `student`
-- 删除指定数据
DELETE FROM `student` WHERE `id`=1
TRUNCATE 命令
作用：完全清空一个数据库表，表的结构和索引约束不会变
-- 清空student表
TRUNCATE `student`
delete和TRUNCATE的区别
相同点：都能删除数据，都不会删除表结构
不同点：
- TRUNCATE 会重新设置自增列，计数器会归零
- TRUNCATE 不会影响事务
了解即可：delete删除问题，重启数据库现象
- 如果表类型为INNODB ：自增列会重1开始（数据是存在内存中的，断电即失）
- 如果表类型为MyISAM：继续从上一个自增量开始，不会清空计数器（数据是存在文件中的，不会丢失）
4、DQL查询数据（重中之重）
4.1、DQL
(Data Query Language：数据查询语言)
- 所有的查询操作都用它， select
- 简单的查询，复杂的查询，他都能做
- 数据库中最核心的语言，最重要的语句
- 使用频率最高的语句
建库建表添加数据，方便查询的学习
DROP DATABASE IF EXISTS `school`
CREATE DATABASE IF NOT EXISTS `school`;
-- 创建一个school数据库
-- ----------------------
USE `school`;-- 创建学生表
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student`(
`studentno` INT(4) NOT NULL COMMENT '学号',
`loginpwd` VARCHAR(20) DEFAULT NULL,
`studentname` VARCHAR(20) DEFAULT NULL COMMENT '学生姓名',
`sex` TINYINT(1) DEFAULT NULL COMMENT '性别，0或1',
`gradeid` INT(11) DEFAULT NULL COMMENT '年级编号',
`phone` VARCHAR(50) NOT NULL COMMENT '联系电话，允许为空',
`address` VARCHAR(255) NOT NULL COMMENT '地址，允许为空',
`borndate` DATETIME DEFAULT NULL COMMENT '出生时间',
`email` VARCHAR (50) NOT NULL COMMENT '邮箱账号允许为空',
`identitycard` VARCHAR(18) DEFAULT NULL COMMENT '身份证号',
PRIMARY KEY (`studentno`),
UNIQUE KEY `identitycard`(`identitycard`),
KEY `email` (`email`)
)ENGINE=MYISAM DEFAULT CHARSET=utf8;
-- 创建年级表
DROP TABLE IF EXISTS `grade`;
CREATE TABLE `grade`(
`gradeid` INT(11) NOT NULL AUTO_INCREMENT COMMENT '年级编号',
`gradename` VARCHAR(50) NOT NULL COMMENT '年级名称',
PRIMARY KEY (`gradeid`)
) ENGINE=INNODB AUTO_INCREMENT = 6 DEFAULT CHARSET = utf8;
-- 创建科目表
DROP TABLE IF EXISTS `subject`;
CREATE TABLE `subject`(
`subjectno`INT(11) NOT NULL AUTO_INCREMENT COMMENT '课程编号',
`subjectname` VARCHAR(50) DEFAULT NULL COMMENT '课程名称',
`classhour` INT(4) DEFAULT NULL COMMENT '学时',
`gradeid` INT(4) DEFAULT NULL COMMENT '年级编号',
PRIMARY KEY (`subjectno`)
)ENGINE = INNODB AUTO_INCREMENT = 19 DEFAULT CHARSET = utf8;
-- 创建成绩表
DROP TABLE IF EXISTS `result`;
CREATE TABLE `result`(
`studentno` INT(4) NOT NULL COMMENT '学号',
`subjectno` INT(4) NOT NULL COMMENT '课程编号',
`examdate` DATETIME NOT NULL COMMENT '考试日期',
`studentresult` INT (4) NOT NULL COMMENT '考试成绩',
KEY `subjectno` (`subjectno`)
)ENGINE = INNODB DEFAULT CHARSET = utf8;
-- -----------------------
-- 插入学生数据 其余自行添加 这里只添加了2行
INSERT INTO `student` (`studentno`,`loginpwd`,`studentname`,`sex`,`gradeid`,`phone`,`address`,`borndate`,`email`,`identitycard`)
VALUES
(1000,'123456','张伟',0,2,'13800001234','北京朝阳','1980-1-1','[email protected]','123456198001011234'),
(1001,'123456','赵强',1,3,'13800002222','广东深圳','1990-1-1','[email protected]','123456199001011233');
-- 插入成绩数据 这里仅插入了一组，其余自行添加
INSERT INTO `result`(`studentno`,`subjectno`,`examdate`,`studentresult`)
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);
-- 插入年级数据
INSERT INTO `grade` (`gradeid`,`gradename`) VALUES(1,'大一'),(2,'大二'),(3,'大三'),(4,'大四'),(5,'预科班');
-- 插入科目数据
INSERT INTO `subject`(`subjectno`,`subjectname`,`classhour`,`gradeid`)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);
4.2、查询指定字段
语法：select 字段，… from 表
-- 查询全部的课程 select 字段 from 表
SELECT * FROM `subject`
-- 查询指定字段
SELECT `subjectno`,`subjectname` FROM `subject`
-- 别名，给结果起一个名字，as 可以给字段起别名，也可以给表起别名
SELECT `studentno` AS 学号,`studentname` AS 姓名 FROM`student` AS 学生
-- 函数 concat(a,b)
SELECT CONCAT('姓名：',`studentname`) AS 学生 FROM `student`
有时候，列名字不是那么见名知意，我们会起别名， as
字段名 as 别名
表名 as 别名
as可以省略不写，别名不需要用单引号包裹，直接写
去重 distinct
作用：去除select查询出来的结果中有重复的数据，重复的数据只显示一条
-- 查询那些同学参加了考试
SELECT `studentno` 学号 FROM `result`
-- 发现重复数据，去重
SELECT DISTINCT `studentno` 学号 FROM `result`
数据库的列 （表达式）
SELECT VERSION() -- 查询系统版本（函数）
SELECT 1+2 计算结果 -- 用来计算结果（表达式）
SELECT @@auto_increment_increment -- 查询自增的步长（变量）
-- 学生成绩+1分查看
SELECT `studentno`,`studentresult`+1 FROM `result`
数据库中的表达式：文本值，列，null，函数，计算表达式，系统变量
select 表达式 from 表
4.3、where条件子句
作用：检索数据中符合条件的值
搜索的条件由一个或者多个表达式组成，结果返回布尔值
逻辑运算符
| 运算符 | 语法 | 描述 |
|---|---|---|
| and && | a and b a&&b | 逻辑与运算 |
| or || | a or b a||b | 逻辑或运算 |
| not != | not a !b | 逻辑非运算 |
尽量使用英文字母
-- 查询学号为1000的学生
SELECT `studentno`,`studentname` FROM `student` WHERE `studentno`=1000
-- 查询成绩为90-100之间的学生
SELECT `studentno`,`studentresult` FROM `result` WHERE `studentresult`>90 AND `studentresult`<100
SELECT `studentno`,`studentresult` FROM `result` WHERE `studentresult` BETWEEN 90 AND 100
-- 查询年级编号为1或者2的学生
SELECT `gradeid`,`gradename` FROM `grade` WHERE `gradeid`=1 OR `gradeid`=2
-- 查询课程号不等于3的学生
SELECT `studentno`,`studentresult` FROM `result` WHERE `subjectno`!=3
SELECT `studentno`,`studentresult` FROM `result` WHERE NOT `subjectno`=3
模糊查询： 比较运算符
| 运算符 | 语法 | 描述 |
|---|---|---|
| is null | a is null | 如果操作符为null，结果为真 |
| is not null | a is not null | 如果操作符不为null，结果为真 |
| between…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…，其中的某个值中，结果为真 |
-- like 结合 %(代表0到任意个字符) _(一个字符)
-- 查询姓张的同学
SELECT `studentno`,`studentname` FROM `student` WHERE `studentname` LIKE '张%'
-- 查询姓刘的，名字后面只有一个字的同学
SELECT `studentno`,`studentname` FROM `student` WHERE `studentname` LIKE '张_'
-- 查询姓刘的，名字后面有两个字的同学
SELECT `studentno`,`studentname` FROM `student` WHERE `studentname` LIKE '张__'
-- 查询名字中有伟的同学
SELECT `studentno`,`studentname` FROM`student` WHERE `studentname` LIKE '%伟%'
-- in (具体的一个或者多个值)
-- 查询地址在北京朝阳和广东深圳的学生
SELECT `studentno`,`studentname` FROM `student` WHERE `address` IN ('北京朝阳','广东深圳')
-- 查询有邮箱的学生 不为空
SELECT `studentno`,`studentname` FROM `student` WHERE `email` IS NOT NULL
-- 查询没有邮箱的学生 为空
SELECT `studentno`,`studentname` FROM `student` WHERE `email` IS NULL
4.4、联表查询
-- 两表查询
-- 查询 学号，姓名，课程编号，成绩
/* 思路
1.需求分析，分析查询字段来自那些表（连接查询）
2.确定使用哪种连接查询
确定交叉点（这两个表中那个数据是相同的）
判断的条件：学生表中的studentNo = 成绩表中的studentNO
*/
-- inner jion
SELECT stu.`studentno`,`studentname`,`subjectno`,`studentresult` FROM
`student` stu INNER JOIN`result` res ON stu.`studentno`=res.`studentno`
-- left join
SELECT stu.`studentno`,`studentname`,`subjectno`,`studentresult` FROM
`student` stu LEFT JOIN`result` res ON stu.`studentno`=res.`studentno`
-- right join
SELECT stu.`studentno`,`studentname`,`subjectno`,`studentresult` FROM
`student` stu RIGHT JOIN`result` res ON stu.`studentno`=res.`studentno`
| 操作 | 描述 |
|---|---|
| inner join | 如果表中至少有一个匹配，就返回行 |
| left join | 会从左表中返回所有的值，即使右表中没有匹配 |
| right join | 会从右表中返回所有的值，即使左表中没有匹配 |
-- 三表查询
-- 查询 学号，姓名，课程编号，课程名,成绩
SELECT stu.`studentno`,`studentname`,sub.`subjectno`,`subjectname`,`studentresult` FROM
`student` stu INNER JOIN`result` res ON stu.`studentno`=res.`studentno`
LEFT JOIN `subject` sub ON res.`subjectno`=sub.`subjectno`
-- 总结
-- 我要查询哪些数据，select...
-- 从那几张表中查 from 表 xxx join 连接的表 on 交叉条件
-- 假设存在一种多张表查询，慢慢来，先查询两张表再慢慢增加
-- 连接查询方式
-- a inner join b
-- a left join b
-- a right join b
自连接（了解）
自己的表和自己的表连接，核心：将一张表拆为两张一样的表即可
-- 建立一张表并插入数据，方便测试
CREATE TABLE `school`.`category`(
`categoryid` INT(3) NOT NULL COMMENT 'id', `pid` INT(3) NOT NULL COMMENT '父id 没有父则为1',
`categoryname` VARCHAR(10) NOT NULL COMMENT '种类名字',
PRIMARY KEY (`categoryid`) ) ENGINE=INNODB CHARSET=utf8 COLLATE=utf8_general_ci;
INSERT INTO `school`.`category` (`categoryid`, `pid`, `categoryname`) VALUES ('2', '1', '信息技术');
INSERT INTO `school`.`CATEGOrY` (`categoryid`, `pid`, `categoryname`) VALUES ('3', '1', '软件开发');
INSERT INTO `school`.`category` (`categoryid`, `PId`, `categoryname`) VALUES ('5', '1', '美术设计');
INSERT INTO `School`.`category` (`categoryid`, `pid`, `categorynamE`) VALUES ('4', '3', '数据库');
INSERT INTO `school`.`category` (`CATEgoryid`, `pid`, `categoryname`) VALUES ('8', '2', '办公信息');
INSERT INTO `school`.`category` (`categoryid`, `pid`, `CAtegoryname`) VALUES ('6', '3', 'web开发');
INSERT INTO `SCHool`.`category` (`categoryid`, `pid`, `categoryname`) VALUES ('7', '5', 'ps技术');
SELECT a.`categoryname`,b.`categoryname` FROM `category` a,`category` b
WHERE a.`categoryid`=b.`pid`
4.5、分页和排序
排序
语法：ORDER BY 字段 DESC OR ASC
-- 排序 order by
-- 升序： asc 降序:desc
-- order by 通过哪个字段排序，怎么排，
-- 查询的结果 降序，升序
SELECT stu.`studentno`,`studentname`,res.`subjectno`,`subjectname`,`studentresult` FROM
`student` stu INNER JOIN `result` res ON stu.`studentno`= res.`studentno`
INNER JOIN `subject` sub ON res.`subjectno` = sub.`subjectno`
分页
为什么要排序？
缓解数据压力，给人的体验更好，（瀑布流）
语法：limit 起始位置,页面大小
SELECT stu.`studentno`,`studentname`,res.`subjectno`,`subjectname`,`studentresult` FROM
`student` stu INNER JOIN `result` res ON stu.`studentno`= res.`studentno`
INNER JOIN `subject` sub ON res.`subjectno` = sub.`subjectno`
LIMIT 0,2
-- 第一页 limit 0,5 (1-1)*5
-- 第二页 limit 5,5 (2-1)*5
-- 第三页 limit 10,5 (3-1)*5
-- 第n页 limit (n-1)*pageSize,pageSize
-- 【pageSize：页面大小】
-- 【(n-1)*pageSize,pageSize：起始值】
-- 【n：当前页】
-- 【数据总数/页面大小=总页数】
4.6、子查询
where （这个值是算出来的）
本质，在where语句中嵌套一个子查询语句
where （select * from）
-- 查询科目为高等数学-2，成绩大于80的学生（学号，姓名）
SELECT `studentno`,`studentname` FROM `student` WHERE `studentno` IN (
SELECT `studentno` FROM `result` WHERE `studentresult`>=80 AND `subjectno`=(
SELECT `subjectno` FROM `subject` WHERE `subjectname`='高等数学-2'
)
)
4.7、分组和过滤
-- 查询每个课程的 总分 平均分(大于80) 最高分 最低分
-- 核心： 根据不同的课程分组
SELECT `subjectname`,SUM(`studentresult`) 总分,AVG(`studentresult`) 平均分,MAX(`studentresult`) 最高分,MIN(`studentresult`) 最低分
FROM `result` res INNER JOIN `subject` sub ON res.`subjectno` = sub.`subjectno`
GROUP BY sub.`subjectname` -- 分组
HAVING 平均分>80 -- 过滤
5、MySQL函数
官网：https://dev.mysql.com/doc/refman/5.7/en/func-op-summary-ref.html
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('123') -- 字符串长度
SELECT CONCAT('1','2') -- 拼接字符串
SELECT INSERT('123',1,2,'456') -- 从某个位置开始的某个长度，替换为任意长度
SELECT LOWER('ABC') -- 小写字母
SELECT UPPER('abc') -- 大写字母
SELECT INSTR('abcd','a') -- 返回第一次出现字符的位置
SELECT REPLACE('abcd','b','d') -- 替换出现的指定字符串
SELECT SUBSTR('abcd123',2,3) -- 返回指定的字符串，（源字符串，截取的位置，截取的长度）
SELECT REVERSE('12345') -- 反转字符串
-- 将查询到的姓张的同学改为姓章
SELECT REPLACE(`studentname`,'张','章') FROM `student`
WHERE `studentname` LIKE '张%'
--- 日期与时间函数
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()
SELECT COUNT(`studentno`) FROM `student` -- count(字段)，会忽略所有的null值
SELECT COUNT(1) FROM `student` -- COUNT(1)，不会忽略null值，本质：计算行数
SELECT COUNT(*) FROM `student` -- -- COUNT(*)，不会忽略null值，本质：计算行数
-- -- -- -- -- -- -- -- -- -- --
SELECT SUM(`studentresult`) 总分 FROM `result`
SELECT AVG(`studentresult`) 平均分 FROM `result`
SELECT MAX(`studentresult`) 最高分 FROM `result`
SELECT MIN(`studentresult`) 最低分 FROM `result`
5.3、数据库级别的MD5加密（拓展）
什么是MD5？
主要增强算法复杂度，和不可逆性
MD5不可逆，具体的值md5是一样的
md5破解网站的原理，背后有一个字典，通过md5加密后的值，找到加密前的值，只针对简单密码可以解密
CREATE TABLE `textmd5`(
`id` INT(3) NOT NULL,
`name` VARCHAR(10) NOT NULL,
`pwd` VARCHAR(50) NOT NULL,
PRIMARY KEY (`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;
ALTER TABLE `textmd5` MODIFY `pwd` VARCHAR(50)
-- 明文密码
INSERT INTO `textmd5`(`name`,`pwd`) VALUES ('小明','123456'),('小红','123456'),('小李','123456')
-- 加密
UPDATE `textmd5` SET `pwd` = MD5(`pwd`) WHERE `id` IN (4,5,6)
-- 插入时加密,
INSERT INTO `textmd5` VALUES (1,'小明',MD5('123456')),(2,'小红',MD5('123456')),(3,'小李',MD5('123456'))
6、事务
6.1、什么是事务
要么都成功，要么都失败
将一组SQL放在一个批次中去执行
事务原则：ACID 原则： 原子性 一致性 隔离性 持久性
参考博客：https://blog.csdn.net/dengjili/article/details/82468576
原子性（Atomicity）
要么都成功，要么都失败
一致性（Consistency）
事务前后数据的完整性必须保持一致。
隔离性（Isolation）
事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。
持久性（Durability）
持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响
隔离存在的问题
脏读：
指一个事务读取了另外一个事务未提交的数据。
不可重复读：
在一个事务内读取表中的某一行数据，多次读取结果不同。（这个不一定是错误，只是某些场合不对）
虚读(幻读)
是指在一个事务内读取到了别的事务插入的数据，导致前后读取不一致。
（一般是行影响，多了一行）
6.2、执行事务
-- 事务
-- mysql是默认开启事务自动提交的
SET autocommit = 0; -- 关闭
SET autocommit = 1; -- 开启
-- 手动处理事务
SET autocommit = 0; -- 关闭自动提交
START TRANSACTION -- 标记一个事务的开始，从这个之后的sql都在同一个事务内
COMMIT -- 提交 成功的话持久化到数据库中
ROLLBACK -- 回滚 提交失败的话回到原来的样子
-- 事务结束
SET autocommit = 1; -- 开启自动提交
-- 了解
SAVEPOINT 保存点名 -- 设置一个事务的保存点
ROLLBACK SAVEPOINT 保存点名 -- 回滚到保存点名
RELEASE SAVEPOINT 保存点名 -- 撤销指定的保存点
6.3、模拟场景
-- 模拟银行转账
CREATE DATABASE IF NOT EXISTS `bank` CHARACTER SET utf8 COLLATE utf8_general_ci
USE `bank`
CREATE TABLE `account`(
`id` INT(3) AUTO_INCREMENT,
`name` VARCHAR(10) NOT NULL,
`money` DECIMAL(9,2) NOT NULL,
PRIMARY KEY (`id`)
)ENGINE=INNODB `account`CHARSET=utf8
INSERT INTO `account`(`name`,`money`) VALUES ('老王',2000.00),('老张',1500.00)
SET autocommit = 0; -- 关闭自动提交 默认为自动提交
START TRANSACTION -- 开启一个事务（一组事务）
UPDATE `account` SET `money` = `money`-500 WHERE `name` = '老王' -- 老王向老张转账500
UPDATE `account` SET `money` = `money`+500 WHERE `name` = '老张' -- 老张接受老王转账500
COMMIT -- 提交，一旦成功就被持久化到数据库中
ROLLBACK -- 回滚
SET autocommit = 1; -- 恢复到默认
7、索引
MySQL官方对索引的定义为：索引（index）是帮助MySQL高效获取数据的数据结构，提取句子的主干，就可以得到索引的本质：索引就是数据结构
7.1、索引的分类
- 主键索引 （primary key）
- 唯一的标识，主键不可重复，只能有一个列作为主键
- 唯一索引 （ unique key）
- 避免重复列的出现，唯一索引可以重复，多个列都可以用标识位 唯一索引
- 常规索引 （key/index）
- 默认的，index或key 关键字来设置
- 全文索引 （fulltext）
- 在特定的数据库引擎下才有 MyISAM
- 快速定位数据
基础语法
-- 索引的使用
-- 1.在创建表的时候给字段增加索引
-- 2.创建完毕后，增加索引
-- 显示所有的索引信息
SHOW INDEX FROM `student`
-- 增加一个全文索引 索引名，列名
ALTER TABLE `student` ADD FULLTEXT INDEX `studentName` (`studentName`)
-- EXPLAIN 分析sql执行的状况
EXPLAIN SELECT * FROM `student`;
EXPLAIN SELECT * FROM `student` WHERE MATCH(`studentName`) AGAINST('刘');
7.2、测试索引
-- 新建一个表用于测试索引
CREATE TABLE `app_user` (
`id` BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT,
`name` VARCHAR(50) DEFAULT '',
`email` VARCHAR(50) NOT NULL,
`phone` VARCHAR(20) DEFAULT '',
`gender` TINYINT(4) UNSIGNED DEFAULT '0',
`password` VARCHAR(100) NOT NULL DEFAULT '',
`age` TINYINT(4) DEFAULT NULL,
`create_time` DATETIME DEFAULT CURRENT_TIMESTAMP,
`update_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
-- 使用函数插入一百万条数据
DELIMITER $$
-- 写函数之前必须要写，标志
CREATE FUNCTION mock_data ()
RETURNS INT
BEGIN
DECLARE num INT DEFAULT 1000000;
DECLARE i INT DEFAULT 0;
WHILE i<num DO
INSERT INTO `app_user`(`name`,`email`,`phone`,`gender`,`password`,`age`)VALUES(CONCAT('用户',i),'[email protected]',CONCAT('18',FLOOR(RAND()*((999999999-100000000)+100000000))),FLOOR(RAND()*2),UUID(),FLOOR(RAND()*100));
SET i=i+1;
END WHILE;
RETURN i;
END;
SELECT mock_data() -- 执行此函数 生成一百万条数据
SELECT `phone` FROM `app_user` WHERE `name`= '用户99999' -- 非索引查询 用时3.514s
EXPLAIN SELECT `phone` FROM `app_user` WHERE `name`= '用户99999' -- 查询了99995行查到
-- id_表名_字段名
-- create index 索引名 on 表(字段)
CREATE INDEX id_app_user_name ON `app_user` (`name`) -- 建立索引
SELECT `phone` FROM `app_user` WHERE `name`= '用户99999' -- 0.011s
EXPLAIN SELECT `phone` FROM `app_user` WHERE `name`= '用户99999' -- 查询了一行查到
总结：
索引在小数据数量的时候，用处不大，但是在大数据的时候，区别十分明显
7.3、索引原则
- 索引不是越多越好-
- 不要对经常变动的数据加索引
- 小数据量的表不需要加索引
- 索引一般加在常用来查询的字段上
索引的数据结构
Hash类型的索引
Btree：InnoDB的默认数据结构
参考：https://blog.codinglabs.org/articles/theory-of-mysql-index.html
8、权限管理和备份
8.1、用户管理
SQLyog可视化管理
SQL命令操作
用户表：mysql.user
本质：对这张表进行增删改查
-- 创建用户 user 用户名 identified by 密码
create user `chenjlong` identified by '123456'
-- 修改当前用户密码 set password = password(新密码)
set password = password('111111')
-- 修改指定用户的密码 set password for 用户名 = password(密码)
set password for chenjlong = password('123456')
-- 用户重命名 rename user 旧名字 to 新名字
rename user chenjlong to chenjl
-- 用户授权 grant 权限名 on 库.表 to 用户
-- all privileges：全部的权限 ，除了给别人授权
grant all privileges on *.* to chenjl
-- 查询权限
show grants for chenjl -- 查看指定用户的权限
show grants for root@localhost
-- root用户权限 GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' WITH GRANT OPTION
-- 撤销权限 revoke 权限名 on 库.表 from 用户
revoke all privileges on *.* from chenjl
-- 删除用户
drop user chenjl
8.2、MySQL备份
为什么要备份：
- 保证重要的数据不丢失
- 数据转移
MySQL数据库备份的方式
- 直接拷贝物理文件
- 在SQLyog这种可视化工具中手动导出
- 在想要导出的表或者库中，右键备份或导出
- 使用命令行导出mysqldumo 命令行使用
-- mysqldump -h主机名 -u用户名 -p密码 数据库 表名1 表名2 ... > 物理磁盘位置/文件名
mysqldump -hlocalhost -uroot -p123456 school student > d:/a.sql
-- 导出数据库
mysqldump -hlocalhost -uroot -p123456 school > d:/b.sql
-- ----------------------------------------------
-- 导入
--1.登录
mysql -u用户名 -p密码
-- 2.导入的是表的话要切换到指定的数据库下，导入的是数据库则不用，直接导入
-- use 数据库名
-- source 理磁盘位置/文件名
source d:/a.sql
9、规范数据库设计
9.1、为什么需要设计
当数据库比较复杂的时候，我们就需要设计了
糟糕的数据库设计：
- 数据冗余，浪费空间
- 数据库插入和删除都会麻烦、异常（屏蔽使用物理外键）
- 程序的性能差
良好的数据库设计
- 节省内存空间
- 保证数据库的完整性
- 方便我们开发系统
软件开发中，关于数据库的设计
- 分析需求：分析业务和需要处理的数据库的请求
- 概要设计，设计关系图E-R图
设计数据库步骤：（以个人博客为例，学习设计思路）
- 收集信息，分析需求
- 用户表（用户登录注销，用户个人信息，写博客，创建分类）
- 分类表（文章分类，谁创建的）
- 文章表（文章信息）
- 评论表
- 友链接（友链信息）
- 自定义表（系统信息，某个关键的字，或者一些主字段，key：value）
- 标识实体（把需求落地到每个字段）
- 写博客：user–>blog
- 创建分类：user -->category
- 关注：user -->user
- 友链：links
- 评论：user —user–blog
9.2、三大范式（了解）
为什么需要数据规范化？
- 信息异常
- 更新异常
- 插入异常
- 无法正常显示信息
- 删除异常
- 丢失有效的信息
什么是三大范式？
参考博客：https://www.cnblogs.com/wsg25/p/9615100.html
第一范式（1NF）
原子性：保证每一列不可再分
第二范式（2NF）
前提：满足第一范式
每张表只描述一件事情
第三范式（3NF）
前提：满足第二范式
确保数据表中的每一列数据都和主键直接相关，而不能间接相关
以上为规范数据库的设计
规范性和性能的问题
阿里手册规范：关联查询的表不得超过三张表
- 考虑商业化的需求和目标（成本，用户体验）数据库的性能更加重要
- 在规范性性能问题的时候，需要适当的考虑一下规范性
- 故意给某些表增加一些冗余的字段。（从多表查询变为单表查询）
- 故意增加一些计算列（从大数据量降低为小数据量的查询：索引）
10、JDBC（重点）
10.1、数据库驱动
我们的程序会通过数据库驱动，和数据库打交道
10.2、JDBC
sun公司为了简化开发人员（对数据库的统一）操作，提供了一个（Java操作数据库的）规范，俗称JDBC
这些规范的实现由具体的厂商去做~
对于开发人员来说，我们只需要掌握JDBC接口的操作即可
需要在我们的IDEA导入一个数据库驱动包，mysql-connector-5.1.47.jar
10.3、第一个JDBC程序
创建一个数据库和表方便测试
-- JDBC
CREATE DATABASE jdbcStudy CHARACTER SET utf8 COLLATE utf8_general_ci;
USE jdbcStudy;
CREATE TABLE `users`(
id INT PRIMARY KEY,
NAME VARCHAR(40),
PASSWORD VARCHAR(40),
email VARCHAR(60),
birthday DATE
);
INSERT INTO `users`(id,NAME,PASSWORD,email,birthday)
VALUES(1,'zhansan','123456','[email protected]','1980-12-04'),
(2,'lisi','123456','[email protected]','1981-12-04'),
(3,'wangwu','123456','[email protected]','1979-12-04')
1、在IDEA中创建一个普通项目
2、导入数据库驱动
3、编写测试代码
//第一个JDBC程序
import java.sql.*;
public class FirstJdbc {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
//1.加载驱动
Class.forName("com.mysql.jdbc.Driver"); //固定写法 加载驱动
//2.用户信息和url jdbcstudy:数据库名 useUnicode=true&character=utf8：解决编码问题，固定写法 useSSL=true 使用安全的连接
String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true";
String username = "root";
String pwd = "123456";
//3.连接成功，返回数据库对象 Connection 代表数据库
Connection connection= DriverManager.getConnection(url,username,pwd);
//4.执行SQL的对象，Statement 执行sql对象
Statement statement = connection.createStatement();
//5.执行SQL对象 去执行SQL,可能存在结果，查看返回结果
String sql = "SELECT * FROM `users`";
ResultSet resultSet = statement.executeQuery(sql);//执行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"));
}
//释放连接
resultSet.close();
statement.close();
connection.close();
}
}
步骤总结：
- 加载驱动
- 连接数据库 DriverManager
- 获得执行sql的对象 Statement
- 获得返回的结果集
- 释放连接
DriverManager
//DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Class.forName("com.mysql.jdbc.Driver"); //固定写法 加载驱动
Connection connection= DriverManager.getConnection(url,username,pwd);
//connection 代表数据库
//数据库设置自动提交
//事务提交
//事务回滚
URL
String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true";
//mysql 默认端口3306
//格式 协议://主机地址:端口号/数据库名?参数1&参数2&参数3&...
// oracle 默认端口 1521
//jdbc:oracle:thin:@localhost:1521:sid
Statement 执行sql的对象 （PrepareStatement）
String sql = "SELECT * FROM `users`"; //编写一个sql
statement.executeQuery(); //查询操作返回ResultSet结果集
statement.execute(); //操作任何sql
statement.executeUpdate() //更新、插入、删除，都用这个，返回一个受影响的行数
ResultSet 查询的结果集：封装了所有的查询结果
获得指定的数据类型
resultSet.getObject(); //在不知道列类型的情况下使用object
resultSet.getInt();
resultSet.getString();
resultSet.getDate();
resultSet.getFloat();
resultSet.getDouble();
遍历，指针
resultSet.beforeFirst(); //移动到最前面
resultSet.afterLast(); //移动到最后面
resultSet.next(); //移动到下一个数据
resultSet.previous(); //移动到前一行
resultSet.absolute(row) //移动到指定行
释放资源
resultSet.close();
statement.close();
connection.close(); //耗资源
10.4、statement对象
jdbc中的statement对象用于向数据库发送sql语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可
statement对象的executeUpdate方法，用于向数据库发送增删改的sql语句，executeUpdate执行完成后，将会返回一个整数（即增删改语句导致了数据库几行数据发生了变化）
statement.executeQuery方法用于向数据库发送查询语句，excuteQuery方法返回代表查询结果的ResultSet对象
代码实现：
1、在src目录下新建db.properties文件
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true
username=root
password=123456
2、提取工具类
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
public class JdbcUtils {
private static String driver = null;
private static String url = null;
private static String username = null;
private static String password = null;
static{
try {
InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
Properties properties = new Properties();
properties.load(in);
driver = properties.getProperty("driver");
url = properties.getProperty("url");
username = properties.getProperty("username");
password = properties.getProperty("password");
//驱动只用加载一次
Class.forName(driver);
} catch (Exception e) {
e.printStackTrace();
}
}
//获取连接
public static Connection getConnection() throws SQLException {
return DriverManager.getConnection(url, username, password);
}
//释放资源
public static void release(Connection conn, Statement st, ResultSet rs) throws SQLException {
if(conn != null){
conn.close();
}
if(st != null){
st.close();
} if(rs != null){
rs.close();
}
}
}
3、编写增删改的方法 executeUpdate
import com.chenjlong.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) throws SQLException {
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 (4,'小明','123456','[email protected]','2020-06-07')";
int i = st.executeUpdate(sql);
if(i>0){
System.out.println("插入成功");
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
JdbcUtils.release(conn,st,rs);
}
}
}
import com.chenjlong.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) throws SQLException {
Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
st = conn.createStatement();
String sql = "DELETE FROM `users` WHERE `id`=4";
int i = st.executeUpdate(sql);
if(i>0){
System.out.println("删除成功");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JdbcUtils.release(conn,st,rs);
}
}
}
import com.chenjlong.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) throws SQLException {
Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
st = conn.createStatement();
String sql = "UPDATE `users` SET `name`= '老王' WHERE `id`=3";
int i = st.executeUpdate(sql);
if(i>0){
System.out.println("更新成功");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JdbcUtils.release(conn,st,rs);
}
}
}
4、查询 executeQuery
import com.chenjlong.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class TestSelect {
public static void main(String[] args) throws SQLException {
Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
st = conn.createStatement();
String sql = "select * from users WHERE `id`=3";
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
// SQL注入
import com.chenjlong.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Injection {
public static void main(String[] args) throws SQLException {
login("'OR ' 1=1","'OR ' 1=1");
}
//登录业务
public static void login(String username,String password) throws SQLException {
Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
st = conn.createStatement();
// '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);
}
}
}
本质：
SELECT * FROM `users` WHERE `name`=''OR'1=1' AND `password`=''OR'1=1'
10.5、PreparedStatement对象
PreparedStatement可以防止SQL注入，效率更好！
1、新增
import com.chenjlong.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class TestInsert {
public static void main(String[] args) throws SQLException {
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,"123456");
st.setString(4,"[email protected]");
st.setString(5,"2020-01-01");
//执行
int i = st.executeUpdate();
if(i>0){
System.out.println("插入成功");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JdbcUtils.release(conn,st,rs);
}
}
}
2、删除
import com.chenjlong.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class TestDelete {
public static void main(String[] args) throws SQLException {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
String sql = "delete from `users` where `id`=?";
st = conn.prepareStatement(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,rs);
}
}
}
3、更新
import com.chenjlong.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class TestUpdate {
public static void main(String[] args) throws SQLException {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
String sql = "update `users` set `name`= ?,`birthday` = ? where `id`=?";
st = conn.prepareStatement(sql);
st.setString(1,"wangwu");
st.setString(2,"1981-12-04");
st.setInt(3,3);
int i = st.executeUpdate();
if(i>0){
System.out.println("更新成功");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JdbcUtils.release(conn,st,rs);
}
}
}
4、查询
import com.chenjlong.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class TestSelect {
public static void main(String[] args) throws SQLException {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
String sql = "SELECT `name`,`password` FROM `users` WHERE `id`=?";
st = conn.prepareStatement(sql);
st.setInt(1,3);
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);
}
}
}
5、防止sql注入原理
本质：把传递进来的参数当做字符，假设其中存在转义字符，比如说 ’ 会被直接忽略
10.6、使用IDEA连接数据库
参考：https://www.bilibili.com/video/BV1NJ411J79W?p=43
10.7、事务
要么都成功，要么都失败
ACID原则 ：原子性，一致性，隔离性，持久性
代码实现
1、开启事务 conn.setAutoCommit(false);
2、一组事务执行完毕，提交事务
3、可以在catch语句中显示的定义回滚语句，但默认失败就会回滚
import com.chenjlong.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class Transaction {
public static void main(String[] args) throws SQLException {
Connection conn = null;
PreparedStatement st =null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
conn.setAutoCommit(false); //关闭数据库的自动提交，同时开启事务
String sql1 = "update `account` set `money`=`money`-100 where `name`=?";
st = conn.prepareStatement(sql1);
st.setString(1,"A");
st.executeUpdate();
String sql2 = "update `account` set `money`=`money`+100 where `name`=?";
st = conn.prepareStatement(sql2);
st.setString(1,"B");
st.executeUpdate();
//业务完毕，提交事务
conn.commit();
System.out.println("提交成功");
} catch (SQLException e) {
//如果失败，默认回滚
// try {
// conn.rollback();
// } catch (SQLException throwables) {
// throwables.printStackTrace();
// }
e.printStackTrace();
} finally {
JdbcUtils.release(conn,st,rs);
}
}
}
10.8、数据库连接池
数据库连接 – 执行完毕 --释放
连接— 释放 十分浪费系统资源
池化技术：准备一些预先的资源，过来就连接预先准备好的
最小连接数
最大连接数
等待超时
编写连接池，实现一个接口，DataSources
开源数据源实现
DBCP
C3P0
Druid 阿里巴巴
使用这些数据库连接池之后，在项目开发中就不需要编写连接数据库的代码了
DBCP
需要用到的jar包
commons-dbcp-1.4 commons-pool-1.6
配置文件
#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true
username=root
password=123456
#
initialSize=10
#最大连接数量
maxActive=50
#
maxIdle=20
#
minIdle=5
#
maxWait=60000
#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：【属性名=property;】
#注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=UTF8
#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true
#driver default 指定由连接池所创建的连接的只读（read-only）状态。
#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
defaultReadOnly=
#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_UNCOMMITTED
import org.apache.commons.dbcp.BasicDataSourceFactory;
import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
public class JdbcUtils_DBCP {
private static DataSource dataSource = null;
static{
try {
InputStream in = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
Properties properties = new Properties();
properties.load(in);
//创建数据源 工厂模式-->创建
dataSource = BasicDataSourceFactory.createDataSource(properties);
} catch (Exception e) {
e.printStackTrace();
}
}
//获取连接
public static Connection getConnection() throws SQLException {
return dataSource.getConnection(); //从数据源获取连接
}
//释放资源
public static void release(Connection conn, Statement st, ResultSet rs) throws SQLException {
if(conn != null){
conn.close();
}
if(st != null){
st.close();
} if(rs != null){
rs.close();
}
}
}
c3P0
需要用到的jar包
c3p0-0.9.5.5 mchange-commons-java-0.2.19
<c3p0-config>
<default-config>
<property name="driverClass">com.mysql.jdbc.Driverproperty>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcStudy?useUnicode=true&characterEncoding=utf8&useSSL=trueproperty>
<property name="user">rootproperty>
<property name="password">123456property>
<property name="acquireIncrement">5property>
<property name="initialPoolSize">10property>
<property name="maxPoolSize">20property>
<property name="minPoolSize">5property>
default-config>
<named-config name="MySQL">
<property name="driverClass">com.mysql.jdbc.Driverproperty>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcStudy?useUnicode=true&characterEncoding=utf8&useSSL=trueproperty>
<property name="user">rootproperty>
<property name="password">123456property>
<property name="acquireIncrement">5property>
<property name="initialPoolSize">10property>
<property name="maxPoolSize">20property>
<property name="minPoolSize">5property>
named-config>
c3p0-config>
package com.chenjlong.lesson05.utils;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;
import javax.sql.DataSource;
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();
// dataSource.setUser();
// dataSource.setPassword();
// dataSource.setJdbcUrl();
// dataSource.setMaxPoolSize();
// dataSource.setMinPoolSize();
//创建数据源 工厂模式-->创建
dataSource = new ComboPooledDataSource("MySQL"); //配置文件写法
} catch (Exception e) {
e.printStackTrace();
}
}
//获取连接
public static Connection getConnection() throws SQLException {
return dataSource.getConnection(); //从数据源获取连接
}
//释放资源
public static void release(Connection conn, Statement st, ResultSet rs) throws SQLException {
if(conn != null){
conn.close();
}
if(st != null){
st.close();
} if(rs != null){
rs.close();
}
}
}
结论：
无论使用什么数据源，本质还是一样的，DataSources接口不会变，方法就不会变