Mysql数据库详解(看B站狂神mysql记得课后笔记)
Mysql数据库入门详解
数据库的分类
关系型数据库(SQL)
- MySQL，Oracle,Sql Server ,DB2,SQLlite
- 通过表和表之间，行和列之间的关系进行数据的储存，学员信息表，考勤表
非关系型数据库(No SQL)
- Redis，MongDB
- 非关系型数据库，对象储存，通过对象的自身的属性来决定
DBMS(数据库管理系统)
-
数据库的管理软件,科学有效的管理我们的数据，维护和获取数据;
-
MySQL,数据管理系统
使用数据库管理工具创建一个数据库
数据库字符集要选utf8mb4才是真的utf-8
连接数据库
在dos里面命令行连接,连接前确定已配置好环境变量
mysql -uroot -p123456 --(密码)
show databases; --查询所有数据库
use school --切换数据库use 数据库名
show tables; --查看所有的表
describe student; --显示数据库中所有的表的信息
exit; --退出连接
--单行注释
/**
多行注释
*/
数据库xxx语言 CRUD增删改查
- DDL 数据库定义语言
- DML 数据库操作语言
- DQL 数据库查询语言
- DCL 数据库控制语言
操作数据库
操作数据库>操作数据库中的表>操作数据库中表的数据
1.创建数据库
CREATE database if not exists westos; --if not exists表示如果不存在
2.删除数据库
drop database if exists westos --if exists 表示如果存在
3.使用数据库
use school
数据库数据类型
数值
- tinyint(十分小的数据 1个字节大小)
- smallint(较小的数据 2字节)
- mediumint(中等大小 3字节)
- int(4字节)
- bigint(较大的 8字节)
- float (浮点数,4字节)
- double(双精度,8字节)
- decimal (字符串形式的浮点数 金融计算的时候,一般是使用decimal)
字符串
- char 字符(0-255)
- varchar 可变字符串(0~65535)对应String
- tinytext(微型文本 2^8-1)
- text 文本串 (2^16-1) 大文本
时间日期 java.util.Date
- date YYYY–MM-DD,日期格式
- time HH：mm:ss时间格式
- datetime YYYY–MM-DD HH：mm:ss常用的时间格式
- timestamp 时间戳 1970.1.1到现在的毫秒数
- year年份表示
null
- 没有值
- 不要使用null值进行运算
数据库的字段属性
Unsigned：
- 无符号整数
- 就是只能为正整数
zerofill:
- 0填充的
- 不足的位数使用0来填充 int(3) 5 – 005
自增
- 自动在上一条记录的基础上+1(默认)
- 通常用来设计唯一的主键 必须是整数类型
- 可以自定义设计增长值
非空 not null
-
如果设置为 not null，不给它赋值，就会报错
-
null，如果不填写，默认是null
创建数据库表
CREATE TABLE `teachar` ( `id` int(10) NOT NULL AUTO_INCREMENT, `name` varchar(50) COLLATE utf8mb4_bin NOT NULL, `password` varchar(50) COLLATE utf8mb4_bin NOT NULL, `sex` varchar(2) COLLATE utf8mb4_bin DEFAULT NULL, `birthday` datetime DEFAULT NULL, `address` varchar(100) COLLATE utf8mb4_bin DEFAULT NULL, `email` varchar(50) COLLATE utf8mb4_bin DEFAULT NULL, PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin
```sql
show create database school(数据库名) --查看创建数据库的语句
show create table student --查看student数据表查询语句
desc student–显示表的结构
**关于数据库引擎**
- INNODB默认使用
- MYISAM 早些年使用
| | MYISAM | INNODB |
| :----------- | ------ | ------------------------- |
| 事务支持 | 不支持 | 支持 |
| 数据行锁定 | 不支持 | 支持 |
| 外键约束 | 不支持 | 支持 |
| 全文索引 | 支持 | 不支持 |
| 表空间的大小 | 较小 | 较大约2倍**常规使用操作** |
- MYISAM 节约空间，速度较快
- INNODB 安全性高，事务的处理，多表多用户操作
**在物理空间存在的位置**
所有的数据库文件都存在data目录下
本质还是文件的存储
MySQL引擎在物理文件上的区别
- INNODB 在数据库表中只有一个*.frm文件，以及上级目录下的ibdata1文件
- MYISAM 对应的文件
- *.frm 表结构的定义文件
- *.MYD 数据文件(data)
- *.MYI 索引文件(index)
**设置数据库表的字符集编码**
```sql
charset=utf8 --不设置的话，会是mysql默认编码(不支持中文)
也可以在my.ini中配置默认的编码
character-set-server=utf8
修改删除表
修改
--修改表名
ALTER TABLE teachar RENAME AS teachar1
增加表的字段
--增加表的字段 ALTER TABLE 表名 ADD 字段 列属性
ALTER TABLE teachar1 ADD age INT(11)
--修改表的字段(重命名，修改约束)
ALTER TABLE teachar1 MODIFY age VARCHAR(11)
--字段重命名
ALTER TABLE teachar1 CHANGE age age1 INT(11)
--删除表的字段
ALTER TABLE teachar1 DROP age1
--删除表
DROP TABLE IF EXISTS teachar1
所有的创建和删除操作尽量加上判断
MySQL数据库管理
外键
CREATE TABLE `student` (
`id` int(10) NOT NULL AUTO_INCREMENT,
`name` varchar(50) COLLATE utf8mb4_bin NOT NULL,
`pwd` varchar(30) COLLATE utf8mb4_bin NOT NULL,
`sex` varchar(2) COLLATE utf8mb4_bin DEFAULT NULL,
`birthday` datetime DEFAULT NULL,
`gradeid` int(10) DEFAULT NULL,
`address` varchar(100) COLLATE utf8mb4_bin DEFAULT NULL,
`email` varchar(50) COLLATE utf8mb4_bin DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `grid` (`gradeid`),
CONSTRAINT `grid` FOREIGN KEY (`gradeid`) REFERENCES `grade` (`gradeid`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin
删除有外键关系的表的时候，必须先删除引用别人的表,再删除被引用的表
物理外键，数据库级别的外键，不建议使用
最佳实践
- 数据库就是单纯的表，只用来存数据，只有行和列
- 我们想使用多张表的数据，想使用外键(程序去实现)
DML语言
- insert
- update
- delete
添加
--插入语句(添加)
--INSERT INTO student([字段1，字段2，字段3]) VALUES('值1'),('值2'),('值3')
--由于主键自增我们可以省略(如果不写表的字段，他就会一一匹配)
--一般写插入语句我们一定要数据和字段一一对应
INSERT INTO `grade`(`gradename`) VALUES('萌萌')
INSERT INTO `grade`(`gradename`)
VALUES('大萌萌'),('无敌萌萌')
INSERT INTO `student`(`name`,`pwd`,`sex`)
VALUES('超萌萌','12234','男'),
('超萌a萌','1234','男')
注意
1，字段和字段之间使用英文逗号隔开
2，字段是可以省略的但必须和值一一对应，不能少
3， 可以同时插入多条数据，values后面的值，需要使用，隔开即可 values(),()
修改
update 修改谁(条件) set 原来的值=新值
--修改name字段
UPDATE `student` SET `name`='超级萌萌' WHERE NAME='22'
--不指定条件的情况下，会改动所有表
UPDATE `student` SET `name`='帅气的萌萌'
--修改多个属性
UPDATE `student` SET `name`='超级无敌萌',`pwd`='988',`email`='@qqq.com' WHERE id=1;
--语法:
--update `表名` set `字段名` ='values' where 条件
条件 where 子句 运算符 id等于 大于 小于 在某个区间内修改
操作符返回boolean型
| 操作符 | 含义 | 范围 | 结果 |
|---|---|---|---|
| = | 等于 | 5=6 | false |
| <>或!= | 不等于 | 5!=6 | true |
| > | |||
| < | |||
| <= | |||
| >= | |||
| BETWEEN 1 AND 3 | 在某个范围内 | [1,3] | |
| AND | 同&& | ||
| OR | 同|| |
--通过多个条件
UPDATE `student` SET `name`='超级乖乖' WHERE id<3 AND `name`='好乖乖'
注意
- 表名 和字段名 尽量都带上· ·以免报错
- where 筛选条件，如果没有指定，则会修改所有的列
- value,是一个具体的值，也可以是一个变量
- 多个设置的属性之间，使用英文逗号隔开
删除
delete命令 语法 delete from 表名 where 条件
--删除数据(避免这样写)
DELETE FROM `student`;
--删除一条数据
DELETE FROM `student` WHERE id=1;
truncate 命令 完全清空一张数据库 表的结构索引约束不会变
--清空student
truncate `student`
delete 和 truncate 区别
-
相同点:都能删除数据，都不会删除表结构
-
不同
-
TRUNCATE 重新设置自增列，计数器会归零
-
不会影响事务
-
delete删除的问题，重启数据库现象
- innoDB 自增列会从1开始(存在内存当中，断电即失)
- MyISAM继续从上一个自增量开始(存在文件中，不会丢失)
DQL查询数据(最重要)
DQL(Data Query language: 数据查询语言)
-
所有的查询操作都用它 select
-
简单的查询，复杂的查询它都能做
-
数据库中最核心的语言
select完整的语法
SELECT [ALL | DISTINCT] {* | table.* | [table.field1[as alias1][,table.field2[as alias2]][,...]]} FROM table_name [as table_alias] [left | right | inner join table_name2] -- 联合查询 [WHERE ...] -- 指定结果需满足的条件 [GROUP BY ...] -- 指定结果按照哪几个字段来分组 [HAVING] -- 过滤分组的记录必须满足的次要条件 [ORDER BY ...] -- 指定查询记录按一个或多个条件排序 [LIMIT {[offset,]row_count | row_countOFFSET offset}]; -- 指定查询的记录从哪条至哪条注意 : [ ] 括号代表可选的 , { }括号代表必选得
-- 创建一个school数据库
create database if not 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;
-- 插入科目数据
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);
-- 插入学生数据 其余自行添加 这里只添加了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,'预科班');
查询指定字段
--查询所有 学生表
SELECT * FROM `student`
--查询指定字段
SELECT `studentno`,`studentname` FROM student
--别名，给结果起一个名字AS 也可以给字段起别名 也可以给表起别名
SELECT `studentno` AS `学号`,`studentname` AS `学生姓名` FROM student AS `s`
--函数 CONCAT(a,b)
SELECT CONCAT('姓名: ',studentname) AS `新名字` FROM student
语法 selete 字段1,字段2 from 表名
字段名 和表名都可以起别名 (字段名) AS 别名
去重
去重select 查询出来的结果中 重复的数据，重复的数据只显示一条
--查询一下有哪些同学参加了考试成绩
SELECT `studentno` FROM `result`
--去除重复数据
SELECT DISTINCT `studentno` FROM `result`
数据库中的表达式 文本值 列 null 函数 表达式
--查询系统版本
SELECT VERSION()
--用来计算
SELECT 100*5-100 AS 计算
--查询自增的步长
SELECT @@auto_increment_increment
--学员考试成绩
SELECT `studentno`,`studentresult`+1 AS `提分后` FROM `result`
select 表达式 from 表
where 条件子句
作用：检索数据中 符合条件 的检索数据
逻辑运算符
| 运算符 | 语法 | 描述 |
|---|---|---|
| and && | a and b a77b | 逻辑与 |
| or || | a or b a||b | 逻辑或 |
| not ! | not a !a | 逻辑取反 |
--查询考试成绩在95到100分之间
SELECT `stUdentno` ,`studentresult` FROM `result`
WHERE `studentresult`>=95 &&`studentresult`<=100
--模糊查询(区间)
SELECT `studentno`,`studentresult` FROM `result`
WHERE `studentresult` BETWEEN 80 AND 100
SELECT `studentno`,`studentresult` FROM `result`
WHERE `studentno`!=1000
SELECT `studentno`,`studentresult` FROM `result`
WHERE NOT `studentno`=1000
模糊查询：比较运算符
| 运算符 | 语法 | 描述 |
|---|---|---|
| is null | a is null | 如果为null 结果为真 |
| is not null | a is not null | 如果操作符为not null 结果为真 |
| between | a between b and c | 若a在b到c之间则结果为真 |
| like | a like b | SQL匹配 如果a匹配b 则结果为真 |
| in | a in(a1,a2,a3…) | 假如a在a1 或者a2…其中的一个则返回为真 |
--模糊查询(区间)
SELECT `studentno`,`studentresult` FROM `result`
WHERE `studentresult` BETWEEN 80 AND 100
SELECT `studentno`,`studentresult` FROM `result`
WHERE `studentno`!=1000
SELECT `studentno`,`studentresult` FROM `result`
WHERE NOT `studentno`=1000
--模糊查询
INSERT INTO `student`(`loginpwd`,`studentname`,`sex`,`gradeid`,`phone`,`address`,`borndate`,`email`,`identitycard`)VALUES
('12345','张无敌猛男','1','12','1998056','爆炸猛男','1980-01-01 00:00:00','@qq.com','1008116')
--like结合 %(代表0到任意个字符) _(一个字符)
SELECT `studentname`,`studentno` FROM `student`
WHERE `studentname` LIKE '张%'
--查询名字后面只有一个字的
SELECT `studentno`,`studentname` FROM `student`
WHERE `studentname` LIKE '%张%'
---IN (具体的一个或者多个值)====
SELECT `studentno`,`studentname` FROM `student`
WHERE `studentno` IN(1001,1002,1003)
--查询是猛男的学生
SELECT `studentno`,`studentname` FROM `student`
WHERE `address` IN('北京朝阳')
--null NOT NULL IS
SELECT `studentno`,`studentname` FROM `student`
WHERE `loginpwd` = '' OR `loginpwd` IS NULL
--查询有出生日期的同学 不为空
SELECT `studentno`,`studentname` FROM `student`
WHERE `borndate` IS NOT NULL
-- 联表模糊查询
SELECT r.studentno,r.studentresult,s.* FROM `student` AS s,`result` AS r
WHERE r.studentno=s.studentno
&& r.studentno=1000
&& s.`studentname` LIKE '%张%'
联表查询
join对比
七种join理论
-- === 联表查询 join===================================
SELECT * FROM `result`,`student`
/*
分析需求 分析查询的字段来自哪些表
确定使用哪种链接查询
确定交叉点(这两个表中哪个数据是相同的)
判断的条件 :学生表中的 studentno=成绩表 studentno
*/
SELECT s.`studentno`,`studentname`,`subjectno`,`studentresult`
FROM `student` AS s
INNER JOIN `result` AS r
WHERE s.`studentno`=r.`studentno`
-- Right join
-- join(连接表名) on(判断条件) 连接查询
-- where 等值查询
SELECT s.`studentno`,`studentname`,`subjectno`,`studentresult`
FROM `student` AS s
RIGHT JOIN `result` AS r
ON s.`studentno` = r.`studentno`
WHERE s.`studentno` IS NOT NULL
-- left join
SELECT s.`studentno`,`studentname`,`subjectno`,`studentresult`
FROM `student` AS s
LEFT JOIN `result` AS r
ON s.`studentno` = r.`studentno`
-- 查询学员所属的年级 (学号,学生的姓名,年级名称)
SELECT s.`studentno` AS `学号`,s.`studentname` AS `学生名`,g.`gradename` `年级名`
FROM `student` AS s
INNER JOIN `grade` AS g
ON s.`gradeid`=g.`gradeid`
-- 查询科目所属的年级(科目名称,年级名称 )
SELECT s.`subjectname` AS `科目名称`,g.`gradename` AS `年级名称`
FROM `grade` AS g
INNER JOIN `subject` AS s
ON g.`gradeid`=s.`gradeid`
-- 查询参加了 数据库结构-1 考试的同学 信息 :学号 学生姓名 科目名 分数
SELECT s.`studentno`,s.`studentname`,r.`studentresult`,sub.`subjectname`
FROM `student` AS s
INNER JOIN `result` AS r
ON s.`studentno`=r.`studentno`
INNER JOIN `subject` AS sub
ON s.`gradeid`=sub.`gradeid`
WHERE sub.`subjectname` LIKE '数据库结构%'
/*
分析查询哪些表 student result subject
确定使用哪种连接查询
确定交叉点
判断条件 学生表中的studentno= studentno
*/
SELECT s.`studentno`,s.`studentname`,su.`subjectname`,r.`studentresult`
FROM `student` AS s
RIGHT JOIN `result` AS r
ON r.`studentno`=s.`studentno`
INNER JOIN `subject` AS su
ON r.`subjectno`=su.`subjectno`
WHERE s.`studentno` IS NOT NULL
-- 我要查询哪些数据 select (字段名)
-- 从哪里查询 from (表名) (连接方式) join (连接表名) on (连接条件)
-- 假设存在一种多张表查询，慢慢来 先查询两张表慢慢增加
| 操作 | 描述 |
|---|---|
| inner join | 如果表中至少有一个匹配，就返回行 |
| left join | 从左表中返回值 即使右表中没有匹配 |
| right join | 从右表中返回所有值 即使 左表中没有匹配 |
自连接联表查询
自连接建表
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技术');
自连接：自己的表和自己的表链接，核心:一张表拆为两张一样的表即可
| categoryid | categoryname |
|---|---|
| 2 | 信息技术 |
| 3 | 软件开发 |
| 5 | 美术设计 |
子类
| pid | categoryid | categoryname |
|---|---|---|
| 3 | 4 | 数据库 |
| 2 | 8 | 办公信息 |
| 3 | 6 | web开发 |
| 5 | 7 | 美术设计 |
操作:查询父类对应的子类关系
| 父类 | 子类 |
|---|---|
| 信息技术 | 办公信息 |
| 软件开发 | 数据库 |
| 软件开发 | web开发 |
| 美术设计 | ps技术 |
查询父子信息
-- 查询父子信息
SELECT a.`categoryname` AS `父栏目`,b.`categoryname` AS `子栏目`
FROM `category` AS a,`category` AS b
WHERE a.`categoryid`=b.`pid`
分页和排序
-- ==================排序 order by 分页 limit ==============
-- 排序 升序 asc 降序 desc
-- 查询的结果根据 成绩降序 排列
--降序
SELECT s.`studentno`,s.`studentname`,r.`studentresult`,sub.`subjectname`
FROM `student` AS s
INNER JOIN `result` AS r
ON s.`studentno`=r.`studentno`
INNER JOIN `subject` AS sub
ON s.`gradeid`=sub.`gradeid`
WHERE sub.`subjectname` LIKE '数据库结构%'
ORDER BY r.`studentresult` DESC
分页
-- 分页，每页只显示五条数据
-- limit(起始位置,最大数量)
-- (当前页-1) *页面大小 =起始位置 (n-1) *pagesize
-- limmit 0,5
-- limmit 5,5
-- limmit 10,5
SELECT s.`studentno`,s.`studentname`,r.`studentresult`,sub.`subjectname`
FROM `student` AS s
INNER JOIN `result` AS r
ON s.`studentno`=r.`studentno`
INNER JOIN `subject` AS sub
ON s.`gradeid`=sub.`gradeid`
WHERE sub.`subjectname` LIKE '数据库结构%'
ORDER BY r.`studentresult` ASC
LIMIT 0,5
-- 查询 java课程 成绩排名前十的学生 ，并且分数要大于80 的学生信息(学号,姓名，课程名称)
SELECT sub.`subjectname` AS `课程名称`,s.`studentno` AS `学号`,s.`studentname` AS `学生名称`,r.`studentresult` AS `分数`
FROM `student` AS s
INNER JOIN `subject` AS sub
ON s.`gradeid`=sub.`gradeid`
INNER JOIN `result` AS r
ON s.`studentno`=r.`studentno`
WHERE r.`studentresult`>=80 AND
sub.`subjectname` LIKE 'Java%'
ORDER BY r.`studentresult` DESC
LIMIT 0,10
-- 练习
-- 查询 c语言 前五名成绩 (学号，姓名，分数)
SELECT s.`studentno`,s.`studentname`,r.`studentresult`,sub.`subjectname`
FROM `student` AS s
INNER JOIN `result` r
ON s.`studentno`=r.`studentno`
INNER JOIN `subject` AS sub
ON r.`subjectno`=sub.`subjectno`
WHERE `subjectname` LIKE '%c语言%'
ORDER BY r.`studentresult` DESC
LIMIT 0,5
语法limt(查询起始下标，页面大小)
分组
-- 查询不同课程的平均分，最高分，最低分
SELECT `subjectname`,AVG(r.`studentresult`) AS 平均分,MAX(r.`studentresult`) AS 最大分,MIN(r.`studentresult`) AS 最低分
FROM `result` AS r
INNER JOIN `subject` AS s
ON r.`subjectno`=s.`subjectno`
GROUP BY s.`subjectno` -- group by 通过什么字段来分组
HAVING 平均分>80 -- having 分组后必须满足的次要条件
子查询
where(这个值是计算出来的)
本质: 在where 语句中嵌套一个子查询语句
MySQL函数
常用函数(假*常用)
-- =============常用函数=========================
-- 数学运算
SELECT ABS(-8) -- 绝对值
SELECT CEILING(9.4) -- 向上取整
SELECT FLOOR(9.4) -- 向下取整
SELECT RAND() -- 返回0-1 随机数
SELECT SIGN(-10) -- 判断一个数的符号 负数返回-1 整数返回1
-- 字符串函数
SELECT CHAR_LENGTH('劳资是猛男') -- 字符串长度
SELECT CONCAT('劳资','是一个','猛男') -- 拼接字符串
SELECT INSERT('超级无敌猛男',1,2,'劳资是一个') -- 替换字符串,insert("原字符",'开始位置','替换长度','用作替换的字符')
SELECT LOWER('WuDiMengNan') -- 小写字母
SELECT UPPER('WuDiMengNan') -- 大写字母
SELECT INSTR('chaojiwudimengnan','wudi') -- 指定字符第一次出现的位置
SELECT REPLACE('ccccc','c','mengnan') -- 替换指定的字符串
SELECT SUBSTR('超级猛男无人能当',3,30) -- 返回指定的子字符串(源字符串,起始位置,截取长度)
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 VERSION()
聚合函数(真*常用)
| 函数名称 | 描述 |
|---|---|
| count() | 计数 |
| sum() | 求和 |
| avg() | 平均值 |
| max() | 最大值 |
| min() | 最小值 |
-- ================聚合函数====================
-- 统计表中的数 (想查询一个表中有多少个记录就是用count)
SELECT COUNT(`studentname`) FROM `student`; -- count(字段),会忽略所有的null值
SELECT COUNT(*) FROM `student`; -- count(*) 不会忽略null值
SELECT COUNT(1) FROM `result`;-- count(1) 本质 计算行数
SELECT SUM(`studentresult`) AS 总和 FROM `result`;
SELECT AVG(`studentresult`) AS 平均分 FROM `result`
SELECT MAX(`studentresult`) AS 最大分 FROM `result`
SELECT MIN(`studentresult`) AS 最低分 FROM `result`
-- 分组
-- 查询不同课程的平均分，最高分，最低分
SELECT `subjectname`,AVG(r.`studentresult`) AS 平均分,MAX(r.`studentresult`) AS 最大分,MIN(r.`studentresult`) AS 最低分
FROM `result` AS r
INNER JOIN `subject` AS s
ON r.`subjectno`=s.`subjectno`
GROUP BY s.`subjectno` -- group by 通过什么字段来分组
HAVING 平均分>80 -- having 分组后必须满足的次要条件
数据库级别的MD5加密
什么是md5
**MD5由MD4、MD3、MD2改进而来，主要增强算法复杂度和不可逆性。MD5算法因其普遍、稳定、快速的特点，仍广泛应用于普通数据的加密保护领域 **
**md5 破解网站的原理,背后有一个字典，md5 加密后的值 **
-- md5 加密
UPDATE `testmd5` SET `pwd`=MD5(`pwd`)
WHERE `id`=1
-- md5 查询
SELECT `pwd` FROM `testmd5`
WHERE `pwd`=MD5('345678')
事务
事务是 一组sql 要么都成功 要么都失败
事务原则 : ACID 原子性 一致性 隔离性 持久性 (脏读 幻读)
原子性（Atomicity）
原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
一致性（Consistency）
事务前后数据的完整性必须保持一致。
隔离性（Isolation）
事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离,互不干扰。
隔离导致的一些问题
- 脏读: 指一个事务读取了另一个事务未提交的数据
- 不可重复读: 在一个事务内读取表中的某一行数据，多次读取结果不同。（这个不一定是错误，只是某些场合不对）
- **虚读(幻读): **是指在一个事务内读取到了别的事务插入的数据，导致前后读取不一致。
（一般是行影响，多了一行）
持久性（Durability）
持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响
-- ===================== 事务 ===============================
-- mysql默认开启事务自动提交的
SET autocommit = 0 -- 关闭自动提交
SET autocommit = 1 -- 开启自动提交
-- 事务开启
START TRANSACTION -- 标记一个事务的开始 ,从这个之后的sql都在同一个sql
COMMIT -- 提交 ：持久化(成功)
ROLLBACK -- 回滚:回到原来的样子
-- 事务结束
SET autocommit =1 -- 开启自动提交
SAVEPOINT 保存点 -- 设置一个事务的保存点
ROLLBACK TO SAVEPOINT 保存点 -- 回滚到保存点
RELEASE 保存点 -- 移除保存点
-- 创建一张测试表
CREATE TABLE `account`(
`id` INT(7) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(30) NOT NULL,
`money` DECIMAL(9,2) NOT NULL,
PRIMARY KEY (`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO `account`(`name`,`money`)
VALUES('A',2000),
('B',4000),
('C',6000)
-- 模拟转账:事务
SET autocommit =0 -- 关闭自动提交
START TRANSACTION -- 开启一个事务(一组事务)
UPDATE `account` SET `money`=`money`-1000 WHERE `id`=1
UPDATE `account` SET `money`=`money`+1000 WHERE `id`=3
COMMIT;
ROLLBACK;
SET autocommit =1 ;
索引
*ySQL官方对索引的定义为：
索引（index）是帮助MySQL高效获取数据的数据结构（有序）。在数据之外，数据库系统还维护者满足特定查找算法的数据结构，这些数据结构以某种方式引用（指向）数据， 这样就可以在这些数据结构上实现高级查找算法，这种数据结构就是索引
索引的分类
在一个表中，主键索引只能有一个，唯一索引可以有多个
- 主键索引(primary key)
- 唯一的标识，主键不可重复，只能只有一个列作为索引
- 唯一索引 (unique key)
- 避免重复的列出现，唯一索引可以重复，多个列都可以标识唯一索引
- 常规索引(key / index)
- 默认的 index key 关键字来设置
- 全文索引(fulltext)
- 在特定的数据库引擎下
-- 索引
-- 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('张')
测试索引
-- 插入100万数据.
DELIMITER $$
-- 写函数之前必须要写，标志
CREATE FUNCTION mock_data ()
RETURNS INT
BEGIN
DECLARE num INT DEFAULT 1000000;
DECLARE i INT DEFAULT 0;
WHILE i<num DO
INSERT INTO `app_user`(`name`,`eamil`,`phone`,`gender`)VALUES(CONCAT('用户',i),'[email protected]','123456789',FLOOR(RAND()*2));
SET i=i+1;
END WHILE;
RETURN i;
END;
SELECT mock_data() -- 执行此函数 生成一百万条数据
SELECT * FROM app_user WHERE `name`='用户100000';
EXPLAIN SELECT * FROM app_user WHERE `name`='用户100000';
-- create index 索引名 on 表
CREATE INDEX id_app_name ON `app_user`(`name`)
索引在大数据量的时候效率高
索引原则
-
索引不是越多越好
-
不要对经常变得数据加索引
-
小数据量的表不需要加索引
-
索引一般加在常用来查询的字段上
索引的数据结构
hash 类型的索引
Btree: innoDB 的默认数据结构
权限管理和备份
-- ================权限管理
-- 创建用户
CREATE USER mengnan IDENTIFIED BY '123456'
-- 修改密码(修改当前用户密码)
SET PASSWORD =PASSWORD('123456')
-- 修改密码
SET PASSWORD FOR mengnan = PASSWORD('123')
-- 重命名
RENAME USER mengnan TO menmen
-- 用户授权 all privileges 全部权限 库 表
-- all privileges 除了给别人授权，其他都能干
GRANT ALL PRIVILEGES ON *.* TO menmen
-- 查询权限
SHOW GRANTS FOR menmen -- 查看指定用户的权限
SHOW GRANTS FOR root@localhost
-- 撤销权限
REVOKE ALL PRIVILEGES ON *.* FROM menmen
-- 删除用户
DROP USER menmen
Mysql备份
mysql数据库备份的方式
-
直接拷贝物理文件
-
在sqlyog这种可视化工具中手动导出
- 在想要导出的表或者库中，右键，选择备份或导出
- 使用命令行导出 mysqldump 命令行使用
# mysqldump -h主机名 -u用户名 -p密码 数据库 表名 >物理磁盘路径
mysqldump -hlocalhost -uroot -p123456 school student >D:/1.sql
# mysqldump -h主机名 -u用户名 -p密码 数据库 表名 >物理磁盘路径/文件名
# 导出多张表
mysqldump -hlocalhost -uroot -p123456 school student result>D:/2.sql
导入数据库
# 先登陆
mysql -uroot -p123456
#登陆的情况下，切换到指定的数据
#切换到指定数据库
use school
#导入命令
source d:/1.sql
#未登录
mysql -u用户名 -p密码 库民< 备份文件
假设你要备份数据库，防止数据丢失
规范数据库设计
当数据库比较复杂的时候，我们就需要设计了
糟糕的数据库设计
- 数据冗余，浪费空间
- 数据库插入和删除都会麻烦，[屏蔽使用物理外键]
良好的数据设计
- 节省内存空间
- 保证数据库的完整性
- 方便我们开发系统
软件开发中，关于数据库的设计
- 分析需求
- 概要设计:设计关系图E-R图
设计数据库的步骤(个人博客)
-
收集信息，分析需求
- 用户表(用户名登陆注销，用户的个人信息，写博客，创建分类)
- 分类表(文章分类,谁创建的)
- 文章表(文章的信息)
- 有链表(友链信息)
- 自定义表(系统信息，某个关键的字，或者一些字段)
-
标识实体()
数据库设计的三大范式
三大范式
第一范式（1NF）
原子性 ：保证每一列不可再分
第二范式（2NF）
前提:满足第一范式
每张表只描述一件事情
第三范式（3NF）
第三范式需要确保数据表中的每一列数据都和主键直接相关，而不能间接相关
规范数据库的设计
规范性和性能的问题
关联查询的表不能超过三张表
- 考虑商业化的需求和目标 数据库性能更加重要
- 在规范性能的问题的时候，需要适当的考虑一下 规范性
- 故意给某表增加一些冗余的字段(从多表查询中变为单表查询)
- 故意增加一些计算列(从大数据量降低为小数据量的查询)
JDBC(重点)
数据库驱动
我们的程序会通过数据库驱动 和数据库打交道
jdbc
Java数据库连接，（Java Database Connectivity，简称JDBC）是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。JDBC也是Sun Microsystems的商标。我们通常说的JDBC是面向关系型数据库的。
对于开发人员只需要使用jdbc即可
JDBC程序
idea创建一个普通项目
创建册数数据
-- 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')
导入jar包添加到项目中 mysql-connector-java-5.1.49.jar
测试代码
package com.xxgc;
import java.sql.*;
public class jdbc {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
// 加载驱动
Class.forName("com.mysql.jdbc.Driver"); //固定写法
// 用户信息和url
String url="jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8";
String usernmae="root";
String password="123456";
// 连接成功，数据库对象
Connection connection = DriverManager.getConnection(url, usernmae, password);
// 执行sql的对象 去执行sql
Statement statement = connection.createStatement();
String sql= "SELECT * FROM `users`";
//结果集封装了我们全部查询的结果
ResultSet resultSet = statement.executeQuery(sql);
while (resultSet.next()){
System.out.println(resultSet.getObject("id"));
System.out.println(resultSet.getObject("NAME"));
System.out.println(resultSet.getObject("PASSWORD"));
System.out.println(resultSet.getObject("email"));
System.out.println(resultSet.getObject("birthday"));
}
// 释放连接
resultSet.close();
statement.close();
connection.close();
}
}
步骤总结
- 加载驱动
- 连接数据库DriverManager
- 获取执行sql的对象statement
- 获得返回的结果集
- 释放连接
DriverManager
// 加载驱动
Class.forName("com.mysql.jdbc.Driver"); //固定写法
URL
//jdbc:mysql://主机名:端口号/数据库名?参数1&参数2
String url="jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8";
statement 执行sql的对象
statement.executeQuery(); // 查询
statement.execute(); //执行任何sql
statement.executeUpdate(); //更新 插入 删除都用这个，返回一个受影响行数
ResultSet 查询结果集,封装了所有的查询结果
//和数据库中的类型一一匹配
resultSet.getObject(); // 不知道列类型的情况下使用
// 如果知道列的类型就使用指定的类型
resultSet.getString();
resultSet.getDate();
resultSet.getInt();
resultSet.getDouble();
遍历指针
resultSet.beforeFirst(); //移动到最前面
resultSet.afterLast(); //移动到最后面
resultSet.next() // 移动到下一个
resultSet.previous(); // 移动到上一个
resultSet.absolute(); // 移动到指定行
释放资源
// 释放连接 十分耗费资源
resultSet.close();
statement.close();
connection.close();
DRUD代码实现
编写一个jdbc链接数据库的工具类
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
public class jdbcutils {
private static String driver;
private static String url;
private static String username;
private static String password;
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();
}
}
编写一个db.properties配置文件存放链接数据的地址，用户名密码
driver=com.mysql.jdbc.Driver
# 链接时设置编码为utf-8
url=jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&characterEncoding=utf8
username=root
password=123456
调用我们编写的工具类，实现插入一条数据
import com.utils.jdbcutils;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
public class testsql {
public static void main(String[] args) throws SQLException {
Connection connection=null;
Statement statement=null;
try {
connection = jdbcutils.getConnection(); //获取数据库链接
statement = connection.createStatement();//获取sql执行对象
String sql="INSERT INTO users(`NAME`,`PASSWORD`,`email`,`birthday`) VALUES" +
"('三三','1234','[email protected]','2020-06-05')";
int i = statement.executeUpdate(sql);
if(i>0) System.out.println("插入成功");
}catch (Exception e){
e.printStackTrace();
}finally {
jdbcutils.release(connection,statement,null);
}
}
}
编写增删改的方法statement.executeUpdate()
增
import com.utils.jdbcutils;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
public class testinsert {
public static void main(String[] args) throws SQLException {
Connection connection=null;
Statement statement=null;
try {
connection = jdbcutils.getConnection(); //获取数据库链接
statement = connection.createStatement();//获取sql执行对象
String sql="INSERT INTO users(`NAME`,`PASSWORD`,`email`,`birthday`) VALUES" +
"('三三','1234','[email protected]','2020-06-05')";
int i = statement.executeUpdate(sql);
if(i>0) System.out.println("插入成功");
}catch (Exception e){
e.printStackTrace();
}finally {
jdbcutils.release(connection,statement,null);
}
}
}
删
import com.utils.jdbcutils;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
public class testdelete {
public static void main(String[] args) throws SQLException {
Connection connection=null;
Statement statement=null;
try {
connection = jdbcutils.getConnection(); //获取数据库链接
statement = connection.createStatement();//获取sql执行对象
String sql="DELETE from `users` WHERE id = 4";
int i = statement.executeUpdate(sql);
if(i>0) System.out.println("删除成功");
}catch (Exception e){
e.printStackTrace();
}finally {
jdbcutils.release(connection,statement,null);
}
}
}
改
import com.utils.jdbcutils;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
public class testupdata {
public static void main(String[] args) throws SQLException {
Connection connection=null;
Statement statement=null;
try {
connection = jdbcutils.getConnection(); //获取数据库链接
statement = connection.createStatement();//获取sql执行对象
String sql="UPDATE `users` SET `NAME`='法外狂徒',`PASSWORD`='4321',`email`='[email protected]' \n" +
"WHERE id>1 ";
int i = statement.executeUpdate(sql);
if(i>0) System.out.println("修改成功");
}catch (Exception e){
e.printStackTrace();
}finally {
jdbcutils.release(connection,statement,null);
}
}
}
查
import com.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 connection=null;
Statement statement=null;
ResultSet rs=null;
try {
//获取连接
connection = jdbcutils.getConnection();
//获取sql对象
statement = connection.createStatement();
//sql
String sql="select * from users where id=1";
//查询获取返回集合
ResultSet query = statement.executeQuery(sql);
//遍历
while (query.next()){
System.out.println(query.getObject("NAME"));
System.out.println(query.getObject("PASSWORD"));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
jdbcutils.release(connection,statement,rs);
}
}
}
SQL注入的问题
sql 存在漏洞
import com.utils.jdbcutils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class SQLinject {
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 connection=null;
Statement statement=null;
ResultSet rs=null;
try {
//SELECT * FROM `users` WHERE `NAME`='' or 1=1 AND `PASSWORD`='' or 1=1 ;
//获取连接
connection = jdbcutils.getConnection();
//获取sql对象
statement = connection.createStatement();
//sql
String sql="SELECT * FROM `users` WHERE `NAME`= "+"'"+username+"'"+" AND `PASSWORD`="+"'"+password+"'";
//查询获取返回集合
ResultSet query = statement.executeQuery(sql);
//遍历
while (query.next()){
System.out.println(query.getObject("NAME"));
System.out.println(query.getObject("PASSWORD"));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
jdbcutils.release(connection,statement,rs);
}
}
}
PreparedStatement对象
PreparedStatement可以防止SQL注入,更安全
增
import com.utils.jdbcutils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Date;
public class testinsert {
public static void main(String[] args) throws SQLException {
Connection connection=null;
PreparedStatement statement=null;
try {
connection = jdbcutils.getConnection(); //获取数据库链接
String sql="INSERT INTO users(`NAME`,`PASSWORD`,`email`,`birthday`) VALUES (?,?,?,?)";
statement= connection.prepareStatement(sql);
statement.setObject(1,"张三");
statement.setObject(2,"123456");
statement.setObject(3,"[email protected]");
statement.setObject(4,new java.sql.Date(new Date().getTime()));
int i = statement.executeUpdate();
if(i>0) System.out.println("插入成功");
}catch (Exception e){
e.printStackTrace();
}finally {
jdbcutils.release(connection,statement,null);
}
}
}
删
import com.utils.jdbcutils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class testdelete {
public static void main(String[] args) throws SQLException {
Connection connection=null;
PreparedStatement statement=null;
try {
connection = jdbcutils.getConnection(); //获取数据库链接
String sql="DELETE from users WHERE id=?";
statement= connection.prepareStatement(sql);
statement.setObject(1,1);
int i = statement.executeUpdate();
if(i>0) System.out.println("删除成功");
}catch (Exception e){
e.printStackTrace();
}finally {
jdbcutils.release(connection,statement,null);
}
}
}
改
import com.utils.jdbcutils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class testupdate {
public static void main(String[] args) throws SQLException {
Connection connection=null;
PreparedStatement statement=null;
try {
connection = jdbcutils.getConnection(); //获取数据库链接
String sql="update `users` set `NAME` =?,`PASSWORD`=? WHERE id=?";
statement= connection.prepareStatement(sql);
statement.setObject(1,"张三三");
statement.setObject(2,"123456");
statement.setObject(3,"2");
int i = statement.executeUpdate();
if(i>0) System.out.println("更新成功");
}catch (Exception e){
e.printStackTrace();
}finally {
jdbcutils.release(connection,statement,null);
}
}
}
查
import com.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 connection=null;
PreparedStatement statement=null;
ResultSet rs=null;
try {
//获取连接
connection = jdbcutils.getConnection();
//sql
String sql="SELECT * from users WHERE id>?";
//预编译sql
statement= connection.prepareStatement(sql);
//设置参数
statement.setObject(1,3);
//执行sql
rs=statement.executeQuery();
//遍历结果
while (rs.next()){
System.out.println(rs.getObject("NAME"));
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
jdbcutils.release(connection,statement,rs);
}
}
}
防止sql注入
import com.utils.jdbcutils;
import java.sql.*;
public class LoginTest {
public static void main(String[] args) throws SQLException {
login("张三","123456");
}
public static void login(String username,String password) throws SQLException {
Connection connection=null;
PreparedStatement statement=null;
ResultSet rs=null;
try {
//SELECT * FROM `users` WHERE `NAME`='' or 1=1 AND `PASSWORD`='' or 1=1 ;
//获取连接
connection = jdbcutils.getConnection();
//获取sql对象
//PreparedStatement 防止sql注入的本质，把传递进来的参数当做字符
// 假设其中存在转义字符,比如说' 会被忽略掉
String sql="SELECT * FROM `users` WHERE `NAME`=? AND `PASSWORD`= ?";
statement= connection.prepareStatement(sql);
statement.setObject(1,username);
statement.setObject(2,password);
rs=statement.executeQuery();
//sql
//查询获取返回集合
//遍历
while (rs.next()){
System.out.println("登陆成功");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
jdbcutils.release(connection,statement,rs);
}
}
}
使用IDEA 连接mysql
输入数据库名称，连接名，密码
连接成功后切换数据库
在idea中修改的数据必须点绿色箭头的提交才能修改成功
在console 中选择或者新建一个控制台可以编写sql语句
如果IDEA连接数据库测试失败
没有导入mysql驱动包导致
导入驱动包后检查mysql数据源配置版本是否正确
事务
ACID原则
原子性: 要么全都成功，要么全都失败
一致性: 结果不变，总数一直
隔离性: 多个进程互不干扰
持久性: 一旦提交不可逆，持久化到数据库了
隔离性的问题:
脏读 ：一个事务读取了另一个没有提交的事务
不可重复读：在同一个事务内，重复读取表中的数据，表数据发生了改变
虚读(幻读):在一个事务内，读取到了别人插入的数据，导致前后读出来的结果不一致
代码实现
- 开启事务connection.setAutoCommit(false);
- 执行业务逻辑
- 提交事务，持久化到数据库中
import com.utils.jdbcutils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class transaction_01 {
public static void main(String[] args) throws SQLException {
Connection connection=null;
PreparedStatement st=null;
ResultSet rs=null;
try {
connection= jdbcutils.getConnection();
//关闭数据的自动提交==开启事务
connection.setAutoCommit(false);
String sql="UPDATE work set money=money-100 WHERE id=1";
st= connection.prepareStatement(sql);
st.executeUpdate();
// int i= 1/0;
String sql_1="UPDATE work SET money=money+100 WHERE id=2";
st= connection.prepareStatement(sql_1);
st.executeUpdate();
// 业务完毕提交事务
connection.commit();
connection.setAutoCommit(true);
System.out.println("成功");
} catch (SQLException e) {
//失败默认回滚
System.out.println("失败");
e.printStackTrace();
}finally {
jdbcutils.release(connection,st,rs);
}
}
}
数据库连接池
数据库连接–执行完毕–释放 十分浪费系统资源
池化技术:准备一些预先的资源,过来就连接预先准备好的
最小连接数: 10
最大连接数:20
等待超时:100ms
编写连接池,实现一个接口 DataSource
开源数据源实现
DBCP
C3P0
Druid:阿里巴巴
使用了这些数据库连接池之后,我们在项目开发中就不需要编写连接数据库的代码了!
DBCP
需要用到的jar包都可以在阿里云仓库找到 commons-dbcp-1.4.jar commons-pool-1.6.jar
DBCP连接池配置
#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&characterEncoding=utf8&uesSSL=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_COMMITTED
从数据源中获取连接
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 source=null;
static {
try {
InputStream in =jdbcutils_dbcp.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
Properties properties = new Properties();
properties.load(in);
//创建数据源 工厂模式--> 创建对象
source = BasicDataSourceFactory.createDataSource(properties);
}catch (Exception e){
e.printStackTrace();
}
}
// 获取连接
public static Connection getConnection() throws SQLException {
//从数据源中获取连接
return source.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();
}
}
测试连接和查询
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class testdbcp {
public static void main(String[] args) throws SQLException {
Connection connection=null;
PreparedStatement statement=null;
ResultSet rs=null;
try {
//获取连接
connection = jdbcutils_dbcp.getConnection();
//sql
String sql="SELECT * from users WHERE id>?";
//预编译sql
statement= connection.prepareStatement(sql);
//设置参数
statement.setObject(1,1);
//执行sql
rs=statement.executeQuery();
//遍历结果
while (rs.next()){
System.out.println(rs.getObject("NAME"));
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
jdbcutils_dbcp.release(connection,statement,rs);
}
}
}
C3P0
导入jar包 c3p0-0.9.1.2.jar mchange-commons-java-0.2.9.jar
<c3p0-config>
<default-config>
<property name="driverClass">com.mysql.jdbc.Driverproperty>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&characterEncoding=utf8&uesSSL=true&serverTimezone=UTCproperty>
<property name="user">rootproperty>
<property name="password">123456property>
<property name="acquiredIncrement">5property>
<property name="initialPoolSize">10property>
<property name="minPoolSize">5property>
<property name="maxPoolSize">20property>
default-config>
<named-config name="MySQL">
<property name="driverClass">com.mysql.jdbc.Driverproperty>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&characterEncoding=utf8&uesSSL=true&serverTimezone=UTCproperty>
<property name="user">rootproperty>
<property name="password">123456property>
<property name="acquiredIncrement">5property>
<property name="initialPoolSize">10property>
<property name="minPoolSize">5property>
<property name="maxPoolSize">20property>
named-config>
c3p0-config>
c3p0连接数据库
import com.mchange.v2.c3p0.ComboPooledDataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class jdbcutils_c3p0 {
private static ComboPooledDataSource source=null;
static {
try {
source= new ComboPooledDataSource("MySQL");
//创建数据源 工厂模式--> 创建对象
}catch (Exception e){
e.printStackTrace();
}
}
// 获取连接
public static Connection getConnection() throws SQLException {
//从数据源中获取连接
return source.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();
}
}
无论使用什么数据源 本质还是一样 ,DataSource 接口不会变
urce ds=new ComboPooledDataSource();"这样写就表示使用的是c3p0的缺省（默认）–>
com.mysql.jdbc.Driver
jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&characterEncoding=utf8&uesSSL=true&serverTimezone=UTC
root
123456
5
10
5
20
com.mysql.jdbc.Driver
jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&characterEncoding=utf8&uesSSL=true&serverTimezone=UTC
root
123456
5
10
5
20
c3p0连接数据库
import com.mchange.v2.c3p0.ComboPooledDataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class jdbcutils_c3p0 {
private static ComboPooledDataSource source=null;
static {
try {
source= new ComboPooledDataSource("MySQL");
//创建数据源 工厂模式--> 创建对象
}catch (Exception e){
e.printStackTrace();
}
}
// 获取连接
public static Connection getConnection() throws SQLException {
//从数据源中获取连接
return source.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();
}
}
无论使用什么数据源 本质还是一样 ,DataSource 接口不会变
❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀完结撒花❀❀❀❀❀❀❀❀❀❀❀❀❀❀