数据库笔记-初级入门
Published on 2022-03-01 21:41 in 分类: SQL with 努力努力yyy
分类: SQL

数据库笔记-初级入门

数据库笔记

1、数据表的类型

-- 关于数据库引擎

/*
INNODB 默认使用
MYISAM 早些年使用
*/

					MYISAM						INNODB
事务支持			  不支持						支持
数据行锁定             不支持                          支持
外键约束               不支持                          支持
全文索引                支持                          不支持
表空间的大小            较小                           较大，约为MYISAM的两倍

常规使用操作

在物理空间存在的位置

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

本质还是文件的存储

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

- [ ] InnoDB 在数据库表中只有 *.frm文件，以及上级目录下的ibdata文件

- [ ] MYISAM 对应的文件

  *.frm 表结构的定义文件
  *.MYD 数据文件 （data）
  *.MYI 索引文件 （index）

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

CHARSET = utf8

MySQL的默认编码是Latin1,不支持中文

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

character-set-server=utf8

2、修改和删除数据表字段

-- 修改表名
ALTER TABLE test RENAME AS test1

-- 增加表的字段(列)
ALTER TABLE test1 ADD age INT(11)

-- 修改表的字段 (重命名，修改约束！)
ALTER TABLE test1 MODIFY age VARCHAR(11) -- 修改约束
ALTER TABLE test1 CHANGE age age1 INT(1) -- 可以重命名+修改约束

-- 删除表的字段
ALTER TABLE test1 DROP age1

-- 删除表（如果表存在再删除 -- 保证安全性）
DROP TABLE IF EXISTS test1

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

注意点：

​ （1）``字段名，使用这个包裹

​ (2) 注释 -- /**/

​ （3）sql 关键字大小写不敏感，建议写小写

​ (4) 所有的符号全部使用英文

3、MySQL数据管理

3.1 、外键（了解即可）

方式一、在创建表的时候增加约束

CREATE TABLE IF NOT EXISTS `grade`(
	`gradeid` INT(10) NOT NULL AUTO_INCREMENT COMMENT '年级id',
	`gradename` VARCHAR(50) NOT NULL COMMENT '年级名称',
	PRIMARY KEY(`gradeid`)
)ENGINE=INNODB DEFAULT CHARSET=utf8

-- test1 的gradeid字段 要去引用年级表的gradeid
-- 定义外键key
-- 给这个外键添加约束 （执行引用）
CREATE TABLE IF NOT EXISTS `teststudent` (
  `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 '邮箱',
  `gradeid` INT(10) NOT NULL COMMENT '年级id',
  PRIMARY KEY (`id`),
  KEY `FK_gradeid` (`gradeid`),
  CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade`(`gradeid`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

删除有外键关系的表的时候，必须要先删除引用别人的表（从表），再删除被引用的表（主表）

方式二、创建表的时候没有外键关系，通过修改表中的修改外键添加外界约束

alter table `teststudent`
add constraint `FK_gradeid` foreign key(`gradeid`) references `grade`(`gradeid`)

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

最佳实践

​ 数据库就是单纯的表，只用来存数据，只有行（数据）和列（字段）

​ 我们想使用多张表的数据，想使用外键（程序去实现）

3.2 、DML语言（全部记住）

数据库意义：数据存储，数据管理

DML语言：数据操作语言

​ insert

​ update

​ delete

3.3、添加

insert

-- 插入语句（添加）
-- insert into 表名 (字段1，字段2，.....) values('值1','值2',....)
insert into `grade`(`gradename`) values('大四')

-- 由于主键自增我们可以省略,但是一定要保证数据和字段一一对应
-- 插入多个字段
insert into `grade`(`gradename`) values('大二'),('大三')
insert into `student`(`name`,`pwd`,`sex`) 
values ('李四','aaaaa','男'),('王五','aaaaa','男')

注意事项：

​ 1.字段和字段之间用 英文逗号隔开

​ 2.字段是可以省略的，但是后面的值必须要一一对应，不能少

​ 3.可以同时插入多条数据，values后面的值，需要用逗号隔开 values(),(),.....

3.4、修改

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

-- 修改学员名字
update `student` set `name`='奥里给' where id = 1

-- 不指定条件的情况下，会改动所有表！
update `student` set name = '奥里给'

-- 修改多个属性，用逗号隔开
update `student` set `name`='奥里给',email='24736743@qq.com' where id = 1

-- 语法：
-- update 表名 set colnum_name = value,[colnum_name=value......] where [条件]

条件：where子句 运算符 id等于某个值，大于某个值，在某个区间内修改......

BETWEEN...AND...表示在某个范围内

-- 通过多个条件定位数据
update `student` set `name`='奥里给666' where `name`='奥里给' AND sex='女'

注意：

​ 1.colnum_name 是数据库的列，尽量带上``

​ 2.条件，筛选的条件，如果没有指定，则会修改所有的列

​ 3.value，是一个具体的值，也可以是一个变量

​ 4.多个设置属性之间用逗号隔开

3.5、删除

delete

语法：delete from 表名 [where 条件]

-- 删除数据（避免这样写）,否则会全部删除
delete from `student`

-- 删除指定数据
delete from `student` where id = 1;

TRUNCATE 命令
作用：完全清空一个数据库表，表的结构和索引约束不会变。
-- 清空student表
TRUNCATE `student`

delete 和TRUNCATE 的区别
	相同点：都能删除数据，都不会删除表结构
	不同点：
		TRUNCATE 重新设置 自增列 计数器会归零
		TRUNCATE 不会影响事物

-- 测试delete 和 TRUNCATE 区别
create table `test`(
	`id` int(4) not null auto_increment,
    `coll` varchar(20) not null,
    primary key(`id`)
)engine=innodb default charset=utf8

insert into `test`(`coll`) values('1'),('2'),('3')

delete from `test` -- 不会影响自增
TRUNCATE TABLE `test` -- 自增会归零

了解即可：delete删除的问题，重启数据库，现象

​ InnoDB 自增列会从1开始（存在内存当中的，断电即失）

​ MyISAM 继续从上一个自增量开始（存在文件中，不会丢失）

4.DQL查询数据（最重点）

4.1、DQL

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

select 语法

select [all | distinct]
{* | table.* | [table.field[as alias1]][,table.field[as alias2]][,...]}
from table_name [as table_alias]
	[left | right | inner join table_name]  -- 联合查询
	[where ...] -- 指定结果需满足的条件
	[group by ...] -- 指定结果按照哪几个字段来分组（分组）
	[having] -- 过滤分组的记录必须满足的次要条件
	[order by ...] -- 指定查询记录按一个或多个条件排序（排序）
	[limit {[offset,]row_count | row_countOFFSET offset}] -- 指定查询的记录从哪条到哪条（分页）
	
	
-- ps：[]表示可选的，{}表示必选的

4.2、指定查询字段

-- 查询全部的学生 select 字段 from 表
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

语法：select 字段... from 表

去重 distinct

作用：去除select查询出来的结果中重复的数据，重复的数据只显示一条

-- 查询一下有哪些同学参加了考试
select * from result -- 查询全部的考试成绩
select `StudentNo` from result -- 查询有哪些同学参加了考试
select distinct `StudentNo` from result -- 发现重复数据，去重

select version -- 查询系统版本
select 100*3-1 as 计算结果 -- 用来计算
select @@auto_increment_increment -- 查询自增的步长（变量）

-- 学员考试成绩 +1 分查看
select `StudentNo`,`StudentResult`+1 AS '提分后' from result

数据库中的表达式：文本值、列、函数、null、计算表达式、系统变量

select 表达式 from 表

4.3、where条件子句

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

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

运算符 语法 描述
AND && a and b a&&b 逻辑与
OR || a or b a||b 逻辑或
NOT ! not a !a 逻辑非

尽量使用英文字母

-- =================where=================
select StudentNo,`StudentResult` from result

-- 查询考试成绩在95~100分之间
select StudentNo,`StudentResult` from result
where StudentResult>=95 and StudentResult<=100;

-- and   &&
-- 查询考试成绩在95~100分之间
select StudentNo,`StudentResult` from result
where StudentResult>=95 && StudentResult<=100;

-- 模糊查询（区间范围）
select StudentNo,`StudentResult` from result
where StudentResult between 95 and 100;

-- 除了1000号学生之外的同学的学生成绩
select StudentNo,`StudentResult` from result
where StudentNo!=1000;

-- !=   not 
select StudentNo,`StudentResult` from result
where not StudentNo=1000;

模糊查询：比较运算符
运算符 语法 描述
IS NULL a is null 如果操作符为null，则结果为真
IS NOT NULL a is not null 如果操作符为 not null，则结果为真
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（具体的一个或多个值）===============
-- 查询 1001、1002、1003号学员
select `StudentNo`,`StudentName` from `student`
where StudentNo in (1001,1002,1003);

-- 查询在北京、安徽、河南洛阳的学生
select `StudentNo`,`StudentName` from `student`
where `Address` in ('北京','安徽','河南洛阳');


-- ============= null 和 not null ===========

-- 查询地址为空的学生 null ''
select `StudentNo`,`StudentName` from `student`
where address = '' or address is null;

-- 查询有出生日期的同学
select `StudentNo`,`StudentName` from `student`
where `BornDate`is not null;

4.4、联表查询

JOIN 对比

img

-- =====================联表查询 join =================

-- 查询参加了考试的同学（学号，姓名，科目编号，分数）
select * from result
select * from result

/*
思路：
1.分析需求，分析查询的字段来自哪些表（连接查询）
2.确定使用哪种连接查询？ 七种
确定交叉点（这两个表中哪个数据是相同的）
判断条件：学生表中的StudentNo = 成绩表 StudentNo
*/

-- Join on 连接查询
-- where 等值查询

-- Inner join
select s.StudentNO,StudentName,SubjectNo,StudentResult
from student as s
inner join result as r
where s.StudentNo = r.StudentNo


-- Right join
select s.StudentNO,StudentName,SubjectNo,StudentResult
from student as s
right join result as r
on s.StudentNo = r.StudentNo

-- Left join
select s.StudentNO,StudentName,SubjectNo,StudentResult
from student as s
left join result as r
where s.StudentNo = r.StudentNo

-- 查询缺考的同学
select s.StudentNO,StudentName,SubjectNo,StudentResult
from student as s
left join result as r
on s.StudentNo = r.StudentNo
where StudentResult is null

-- 查询参加考试的同学信息：学号、学生姓名、科目名、分数

select s.StudentNo,StudentName,SubjectNo,StudentResult
from Student as s
right join Result as r
on r.StudnentNo = s.StudentNo
inner join Subject as sb
on sb.SubjectNo = r.SubjectNo


-- 要查询哪些数据 select.....
-- 从那几个表中查from表   XXX join 连接的表 on 交叉条件
-- 假设存在多张表查询，慢慢来，先查询两张表，然后再慢慢增加
操作 描述
Inner Join 如果表中至少有一个匹配，就返回匹配的值
Left Join 即使右表中没有匹配，也会从左表中返回所有的值
Right Join 即使左表中没有匹配，也会从右表中返回所有的值 
自连接

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

父类

categoryid categoryName
2 信息技术
3 软件开发
5 美术设计

子类

pid（父id） categoryid（自己id） categoryName
3 4 数据库
2 8 办公信息
3 6 web开发
5 7 PS技术

操作：查询父类对应的子类关系（希望查询后的表格为下面的表格的样子）

父类 子类
信息技术 办公信息
软件开发 数据库
软件开发 web开发
美术设计 PS技术 
-- 查询父子信息,把一张表看为两个一模一样的表

select a.`categoryName` as '父栏目',b.`categoryName` as '子栏目'
from `category` as a,`category` as b
where b.pid = a.categoryid

-- 查询学员所属的年级（学号、学生姓名、年级名称） 
select studentNo,studentName,`GradeName`
from student as s
inner join `grade` as g
on s.`GradeID` = g.`GradeID`

-- 查询科目所属的年级(科目名称、年级名称)
select `SubjectName`,`GradeName`
from `subject` sub
inner join `grade` g
on sub.`GradeID` = h.`GradeID`

-- 查询了参加 数据库结构-1 考试的同学信息：学号、学生姓名、科目名、分数
select s.`StudentNo`,`StudentName`,`SubjectName`,`StudentResult`
from student as s
inner join `result` as r
on s.`StudentNo` = r.`StudentNo`
inner join `Subject` as sub
on sub.`SubjectNo` = r.`SubjectNo`
where subjectName='数据库结构-1'

4.5、分页和排序

排序

-- ===================分页limit和排序order by===================
-- 升序： ASC ，降序：DESC
-- 查询了参加 数据库结构-1 考试的同学信息：学号、学生姓名、科目名、分数
-- order by 通过哪个字段排序，怎么排
-- 查询的结果根据 成绩降序 排序
select s.`StudentNo`,`StudentName`,`SubjectName`,`StudentResult`
from student as s
inner join `result` as r
on s.`StudentNo` = r.`StudentNo`
inner join `Subject` as sub
on sub.`SubjectNo` = r.`SubjectNo`
where subjectName='数据库结构-1' 
order by StudentResult DESC

分页

-- 假设现在有100万条数据  －》无法全部显示  －》分页 缓解数据库压力，用户体验更好    与瀑布流区分
-- 查询了参加 数据库结构-1 考试的同学信息：学号、学生姓名、科目名、分数
-- 分页，每页只显示五条数据
-- 语法： limit 起始值，页面的大小
-- limit 0,5  1~5
-- limit 1,5 2~6
-- limit 6,5
select s.`StudentNo`,`StudentName`,`SubjectName`,`StudentResult`
from student as s
inner join `result` as r
on s.`StudentNo` = r.`StudentNo`
inner join `Subject` as sub
on sub.`SubjectNo` = r.`SubjectNo`
where subjectName='数据库结构-1' 
limit 5,5

-- 第一页 limit 0,5
-- 第二页 limit 5,5
-- 第n页 limit (n-1)*pagesize,pagesize  
-- pagesize代表页面大小
-- n代表当前页
-- (n-1)*pagesize代表起始值
-- 数据总数/页面大小 = 总页数

语法： limit(查询起始下表，pagesize)

-- 查询 Java第一学年 课程成绩排名前十的学生，并且分数要大于80的学生信息（学号、姓名、课程名称、分数）
select StudentNo,StudentName,SubjectName,StudentResult
from `student` as s
inner join `Result` as r
on s.`StudentNo` = r.`StudentNo`
inner join `Subject` as sub
on sub.`SubjectNo` = r.`SubjectNo`
where SubjectName = 'Java第一学年'  AND StudentResult>=80
order by StudentResult DESC
limit 0,10

4.6、子查询

本质：在where语句中嵌套一个子查询语句

where(select * from)

-- ========================where========================

-- 1.查询数据库结构-1 的所有考试结果（学号、科目编号、成绩）,降序排列
-- 方式一：使用连接查询
select StudentNo,r.`SubjectNo`,StudntResult
from `result` as r
inner join `subject` sub
on r.SubjectNo = sub.SubjectNo
where SubjectName = '数据库结构-1'
order by StudentResult DESC

-- 方式二：使用子查询
select StudentNo,`SubjectNo`,StudntResult
from `result`
where SubjectNo = (
select SubjectNo from `subject`
where SubjectName='数据库结构-1'
)
order by StudentResult Desc

-- 查询分数不小于80分的学生的学号和姓名
select StudentNo,StudentName
from `Student` as s
inner join `Result` as r
on s.`StudentNo` =r.`StudentNo`
where StudentResult>=80

-- 查询高等数学-2科目的分数不小于80分的学生的学号和姓名
select StudentNo,StudentName
from `Student` as s
inner join `Result` as r
on s.`StudentNo` =r.`StudentNo`
where StudentResult>=80 AND `SubjectNo` =

4.7、分组和过滤

-- 查询不同课程的平均分，最高分，最低分, 平均分大于80分
-- 核心：（根据不同的课程分组）
select SubjectName,avg(StudentResult) as 平均分,max(StudentResult),min(StudentResult)
from result as r
inner join `Subject` sub
on r.`SubjectNo` = sub.`SubjectNo`
group by r.SubjectNo -- 通过什么字段来分组
having 平均分>80

-- 查询课程为高等数学-2 且分数不小于80的同学的学号和姓名
-- 方式一
select StudentNo,StudentName
from `Student` as s
inner join result as r
on s.StudentNo = r.StudentNO
inner join `Subject` as sub
on r.`SubjectNo`=sub.`SubjectNo`
where `SubjectName = '高等数学-2' AND StudentResult>=80


-- 方式二
Select distinct s.`StudentNo`,`StudentName`
from student as s
inner join result as r
on s.`StudentNo` = r.`StudentNo`
where `StudentResult`>=80 AND `SubjectNo`=(
	select SubjectNo from `subject`
    where `SubjectName` = '高等数学-2'
)


-- 方式三
Select distinct `StudentNo`,`StudentName`
from student
where `StudentNo` in(
	select `StudentNo`
    from result
    where `StudentResult`>=80 AND `SubjectNo`=(
    select `SubjectNo` from Subject where `SubjectName`='高等数学-2'
    )
)


-- 练习：查询C语言-1 前5名同学的成绩的信息（学号、姓名、分数）
-- 使用子查询

5、MySQL函数

5.1、常用函数

-- ============================常用函数=======================

-- 数学运算
select ABS(-8) -- 绝对值
select ceiling(9.4) -- 向上取整 ->10
select floor(9.4) -- 向下取整 ->9
select RAND() -- 返回一个0~1之间的随机数
select sign() -- 判断一个数的符号 0->0  负数返回-1   正数返回1

-- 字符串函数
select char_length('奥里给') -- 字符串长度  ->3
select concat('奥','里','给') -- 拼接字符串
select insert('我爱编程hello',1,2,'超级热爱') -- ->超级热爱编程hello  作用：替换，从某个位置开始替换某个长度
select lower('GuangZhou') -- 转小写
select upper() -- 转大写
select instr('GuangZhou','h') -- 查询子层第一次出现的位置 ->7
select repalce('I Love Java','I','Everyone') -- 替换出现的指定字符串
select substr('I Love Java',4,2) -- 返回指定的字符串(源字符串，截取的位置，截取的长度)
select reverse('123') -- 反转字符串中的字符 ->321


-- 查询姓 周的同学，改为邹
select replace(studentname,'周','邹') from student
where studentname like '周%'


-- 时间和日期函数（记住）
select current_date() -- 获取当前日期
select now() -- 获取当前的时间
select localtime() -- 获取本地时间
select sysdate() -- 获取系统时间

select year(now()) -- 格式：year(Date())
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(studentname) from student; -- count（指定列） ！会忽略所有的null值! 
select count(*) from student; -- count(*)   ！不会忽略所有的null值！ 本质：计算行数
select count(1) from student; -- count(1)	！不会忽略所有的null值！ 本质：计算行数


select sum(`StudentResult`) as 总和 from result
select avg(`StudentResult`) as 平均分 from result
select max(`StudentResult`) as 最高分 from result
select min(`StudentResult`) as 最低分 from result

5.3、数据库级别的MD5加密（扩展）

什么是MD5？

信息摘要算法，主要增强算法复杂度和不可逆性

MD5不可逆，具体的值和MD5是一样的

MD破解网站的原理，背后有一个字典，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 values(1,'张三','123456'),(2,'李四','123456'),(3,'王五','123456')

-- 加密
update testmd5 set pwd = md5(pwd) -- 加密全部的密码

-- 插入的时候加密
insert into testmd5 values(1,'小明',md5('123456'))

-- 如何校验:用户传的还是123456，所以要对用户传递进来的密码，进行md5加密，然后对比加密后的值
select * from testmd5 where `name` = '小明' AND pwd = md5('123456')

6、事物

6.1、什么是事物

要么都成功，要么都失败

===================

1.SQL执行 A给B转账 A1000 --->200 B 200

2、SQL执行 B收到A的钱 A 800 -> B 400

结果就出现了差错

=======================

将一组SQL放在一个批次中去执行

事物原则：ACID原则   原子性、一致性、隔离性、持久性   （脏读，幻读......）

原子性（Atomicity）

要么都成功，要么都失败

一致性（Consistency）

事物前后的数据完整性要保持一致，1000

持久性（Durability）

事物一旦提交则不可逆，被持久化到数据库中

隔离性（Isolation）

事物的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事物的操作数据所干扰，事物之间要相互隔离。

隔离所导致的问题

脏读：

指一个事务读取了另外一个事务未提交的数据

不可重复读：

在一个事务内读取表中的某一行数据，多次读取结果不同。（这个不一定是错误，只是某些场合不对）

虚读（幻读）：

是指在一个事务内读取到了别的事务插入的数据，导致前后读取不一致。

执行事务

-- ========================事务===========================
-- 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 utf_8_general_ci
use shop

create table `account`(
	`id` int(3) not null auto_increment,
    `name` varchar(30) not null,
    `money` decimal(9,2) not null,
    primary key(`id`)
)engine=innodb default charset=utf8

insert into `account`(`name`,`money`)
values('A',2000.00),('B',10000.0)

-- 模拟转账：事物（A向B转钱）
set autocommit = 0; -- 关闭自动提交
start transaction -- 开启一个事物（一组事物）
update account set money = money-500 where `name`='A' --A减500
update account set money = money+500 where `name`='B' --B加500

commit; -- 提交事务，一旦提交就被持久化了
rollback;-- 回滚
set autocommit = 1;-- 恢复默认值

7、索引

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

7.1、索引的分类

在一个表中，主键索引只能有一个，唯一索引可以有多个

主键索引 （PRIMARY KEY）

​ 唯一的标识，主键不可重复，只能有一个列作为主键

唯一索引 （UNIQUE KEY）

​ 避免重复的列出现，唯一索引可以重复，多个列都可以标识为唯一索引

常规索引 （KEY/INDEX）

​ 默认的，index、key关键字来设置

全文索引 （FullText）

​ 在特定的数据库引擎下才有，MyISAM(现在应该都有)

​ 快速定位数据

-- 索引的使用
-- 1、在创建表的时候给字段增加索引
-- 2、创建完毕后，增加索引

-- 显示所有的索引信息
show index from student

-- 增加一个索引
alter table school.`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 COMMENT '用户昵称',
`email` VARCHAR(50) NOT NULL COMMENT '用户邮箱',
`phone` VARCHAR(20) DEFAULT COMMENT '手机号',
`gender` TINYINT(4) UNSIGNED DEFAULT 0COMMENT '性别（0：男;1:女）',
`password` VARCHAR(100) NOT NULL COMMENT '密码',
`age` TINYINT(4) DEFAULT0  COMMENT '年龄',
`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 COMMENT = 'app用户表'


-- 插入100万数据
delimiter $$ -- 写函数之前必写,当作标志
create function mock_data()
returns int
begin
	declare num int default 1000000;
	declare i int default 0;
	while i<num do
		-- 插入语句
		insert into app_user(`name`,`email`,`phone`,`gender`,`password`,`age`)
    values(
    CONCAT('用户',i),
    '2303121113@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();

-- 查看索引带来的效率
explain select * from app_user where `name`='用户9999'； -- 查找了大约991749行

-- id_表名_字段名
-- create index 索引名 on 表（地段）
create index id_app_user_name on app_use(`name`);
explain select * from app_user where `name`='用户9999'； -- 查找了1行，也就是唯一定位了

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

7.3、索引原则

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

Hash类型的索引

Btree：InnoDB的默认数据结构~

推荐文章：http://blog.codinglabs.org/articles/theory-of-mysql-index.html

8、数据库备份

8.1、用户管理

SQLyog可视化管理

通过用户管理实现即可

SQL命令操作

用户表：mysql.user

本质：对这张表进行增删改查

-- 创建用户 create user 用户名 identified by '密码'
create user xiaoyu identified by '123456'

-- 修改密码（修改当前用户密码）
set password = password('1111111');
-- 修改密码（修改指定用户密码）
set password for xiaoyu = password('111111');

-- 重命名 rename user 原名字 to 新名字
rename user xiaoyu to xiaoyu2

-- 用户授权 all privileges 全部的权限，库.表(除了给别人授权的权限，其他的权限都有)
grant all privileges *.* to xiaoyu2

-- 查看权限
show grants for xiaoyu2 -- 查看指定用户的权限
show grant for root@localhost -- 查看管理员权限

-- 撤销权限 revoke 哪些权限，在哪个库撤销，给谁撤销
revoke ALL privileges on *.* from xiaoyu2

-- 删除用户
drop user xiaoyu

8.2、MySQL备份

为什么要备份：

  • 保证重要的数据不丢失
  • 数据转移 A---->B

MySQL数据库备份的方式

  • 直接拷贝物理文件
  • 在Sqlyog这种可视化工具中手动导出

​ --在想要导出的表或者库中，右键，选择备份或导出

  • 使用命令行导出 mysqldump 在命令行使用
# mysqldump -h主机 -u用户名 -p密码 数据库 表名 > 物理磁盘位置/文件名
mysqldump -hlocalhost -uroot -p123456 school student > D:/a.sql

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

#导入
#先登录
mysql -uroot -p123456
#切换数据库
use school;
#导入
source D:/a.sql #source 备份文件

9、规范数据库设计

9.1、为什么需要设计

当数据库比较复杂的时候，我们就需要设计

糟糕的数据库设计：

  • 数据冗余，浪费空间
  • 数据库插入和删除都会麻烦，产生异常【屏蔽使用物理外键】
  • 程序的性能差

良好的数据库设计：

  • 节省内存空间
  • 保证数据库的完整性
  • 翻遍我们开发系统

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

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

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

  • 收集信息，分析需求

    • 用户表（用户登录注销，用户的个人信息，写博客，创建分类）
    • 分类表（文章分类，谁创建的）
    • 文章表（文章的信息）
    • 友情链接表（友情链接信息）
    • 自定义表（系统信息，某个关键的字，或者一些主字段） key:value

  • 表示实体（把需求落地到每个字段）

  • 表示实体之间的关系

    • 写博客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操作

两个包

java.sql

javax.sql

还需要导入一个数据库驱动包

mysql-connector-java.jar

10.3、第一个JDBC程序

创建测试数据库

1.创建一个普通项目

2.导入数据库驱动

创建一个lib文件夹，导入相关包。

Add as Library

3.编写测试代码

代码块

步骤总结：

1.加载驱动

2.连接数据库DriverManager

3.获得执行sql的对象

4.获得返回的结果集

5.释放连接

DriverManager

// DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver())
class.forName("com.mysql.cj.jdbc.Driver");//固定写法，加载驱动
Connection connection = DriverManager.getConnection(url,username,password);

//connection 代表数据库
//数据库设置自动提交
//事物提交
//事物回滚
connection.rollback();
connection.commit();
connection.setAutoCommit();

URL

String url = "jdbc:mysql://localhost:3306/jdbcstudy"
useUnicode=true&characterEncoding=utf8&useSSL=true";

//mysql -- 3306
//jdbc:mysql://主机地址:端口号/数据库名?参数1&参数2&参数3

//oralce -- 1521
//jdbc:oracle:thin:@localhost:1521:sid

Statement执行SQL的对象 PreareStatement执行SQL的对象

//执行SQL的对象
String sql = "select * from users";//编写sql

Statement statement = connection.createStatement();

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

ResultSet查询的结果集:封装了所有的查询结果

获得指定的数据类型

resultset.getObject(); // 在不知道列类型的情况下使用
//如果知道列的类型就使用指定的类型
result.getString();
result.getInt();
result.getFloat();
result.getDate();
result.getobject();
......

遍历,指针

resultset.beforeFirst(); // 移动到最前面
resultset.afterLast(); //移动到最后面
resultset.next(); // 移动到下一个数据
resultset.previous(); // 移动到前一行
resultset.absolute(row) //移动到指定行

释放资源

//6.释放连接
resultset.close();
statement.close();
connection.close(); //耗资源，用完关掉！

10.4、statement对象

JDBC中的statement对象用于向数据库发送SQL语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可。

Statement对象的executeUpdate方法，用于向数据库发送增、删、改的sql语句，executeUpdate执行完后，将会返回一个整数（即增删改语句导致了数据库几行数据发生了变化）。

Statement.executeQuery方法用于向数据库发送查询语句，executeQuery方法返回代表查询结果的ResultSet对象。

CRUD操作-create

使用executeUpdate(String sql) 方法完成数据添加操作，示例操作：

Statement st = connection.createStatement();
String sql = "insert into user(...) values(....)";
int num = st.executeUpdate(sql);
if(num>0){
    System.out.println("插入成功！");
}

CRUD操作-delete

使用executeUpdate(String sql)方法完成数据删除操作，示例操作：

Statement st = connection.createStatement();
String sql = "delete from user where id=1";
int num = st.executeUpdate(sql);
if(num>0){
    System.out.println("删除成功！");
}

CRUD操作-update

使用executeUpdate(String sql)方法完成数据修改操作，示例操作：

Statement st = connection.createStatement();
String sql = "update user set name='' where name=''";
int num = st.executeUpdate(sql);
if(num>0){
    System.out.println("修改成功！");
}

CRUD操作-read

使用executeQuery(String sql)方法完成数据查询操作，示例操作:

Statement st = connection.createStatement();
String sql = "select * from user where id=1";
ResultSet rs = st.executeQuery(sql);
while(rs.next()){
    //根据获取列的数据类型，分别调用rs的相应方法映射到java对象中
}

代码实现

//配置JDBC.properties文件
Driver = com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/wang_database?serverTimeZone=GTM&useUnicode=true&characterEncoding=utf8&useSSL=false
username=root
password=WANG20010724A

//JDBCUtils.java工具类
import java.io.IOException;
import java.sql.*;
import java.util.Properties;
import java.io.InputStream;


public class JDBCUtils{
    private static String Driver = null;
    private static String url= null;
    private static String username = null;
    private static String password = null;
    static{
        try{
            InputStream in = JDBCUtils.class.getClassLoader().getResourceAsStream("db.properties");
            Properties properties = new Properties();
            properties.load(in);

            Driver = properties.getProperty("Driver");
            url = properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");
            //1.驱动只用加载一次
            Class.forName(Driver);
        }catch(IOException e){
            e.printStackTrace();
        }catch(ClassNotFoundException e){
            e.printStackTrace();
        }
    }

    //获取链接
    public static Connection getConnection() throws SQLException {
            return DriverManager.getConnection(url,username,password);
    }
    //释放链接资源
    public static void release(Connection connection, Statement statement, ResultSet resultset){
        if(resultset!=null){
            try{
                resultset.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
        if(statement!=null){
            try{
                statement.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
        if(connection!=null){
            try{
                connection.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }

    }
}

// 测试插入操作
import java.sql.*;

public class TestInsert{
    public static void main(String[] args){
        Connection connection = null;
        Statement statement = null;
        ResultSet resultset = null;
        try{
            connection = JDBCUtils.getConnection();
            statement = connection.createStatement();
            //增操作
            //String sql = "insert into user(`id`,`NAME`,`PASSWORD`,`email`,`birthday`) values(4,'xiaoyu','123456','2303121113@qq.com','2001-1-1')";
            //查询操作
            String sql = "select * from user where UID=2019054405";
            resultset = statement.executeQuery(sql);
            while(resultset.next()){
            	System.out.println(resultset.getString("Phone"));
            }

            /*int num = statement.executeUpdate(sql);
            if(num>0){
                System.out.println("插入成功");
            }*/
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
            JDBCUtils.release(connection,statement,resultset);
        }
    }
}

SQL注入的问题

sql存在漏洞，会被攻击，导致数据泄露 ---------SQL会被拼接

public SQL注入{
    public static void main(String[] args){
        //login("xiaoyu","123456");
        //可以获取所有sql账户的信息
        login(" 'or '1=1"," 'or '1=1");//技巧
    }
    public static void login(String username,String password){
        Connection connection = null;
        Statement statement = null;
        ResultSet resultset = null;
        try{
            Connection connection = JDBCUtils.getConnection();
            statement = connection.createStatement();
            String sql = "select * from user where `NAME`='"+username+" AND `password`='"+password+"'";
            resultset = statement.executeUpdate(sql);
            while(resultset.next()){
                System.out.println(resultset.getString("NAME"));
                System.out.println(resultset.getString("password"));
            }
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
            JDBCUtils.release(connection,statement,resultset);
        }
    }
}

10.5、PreparedStatement对象

PreparedStatement可以防止SQL注入，并且效率更高

1、新增

import java.sql.*;

public class TestInsetPreparement {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = JDBCUtils.getConnection();

            //区别，用？替代
            String sql = "insert into user(`id`,`NAME`,`PASSWORD`,`email`,`birthday`) values(?,?,?,?,?)";
            preparedStatement = connection.prepareStatement(sql);//预编译SQL，先写sql，然后不执行

            //手动给参数赋值
            preparedStatement.setInt(1,4);
            preparedStatement.setString(2,"xiaoyu");
            preparedStatement.setString(3,"123456");
            preparedStatement.setString(4,"2303121113@qq.com");
            //注意点：sql.Date 数据库 java.sql.Date()
            preparedStatement.setDate(5,new java.sql.Date(new java.util.Date().getTime()));

            //执行
            int num = preparedStatement.executeUpdate();
            if(num>0){
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.release(connection,preparedStatement,null);
        }
    }
}

2、删除

import java.sql.*;

public class TestInsetPreparement {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = JDBCUtils.getConnection();

            //区别
            String sql = "delete from users where id=?";
            preparedStatement = connection.prepareStatement(sql);//预编译SQL，先写sql，然后不执行

            //手动给参数复制
            preparedStatement.setInt(1,4);

            //执行
            int num = preparedStatement.executeUpdate();
            if(num>0){
                System.out.println("删除成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.release(connection,preparedStatement,null);
        }
    }
}

3、更新

import java.sql.*;

public class TestInsetPreparement {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = JDBCUtils.getConnection();

            //区别
            String sql = "update users set 'NAME'=? where id=?";
            preparedStatement = connection.prepareStatement(sql);//预编译SQL，先写sql，然后不执行

            //手动给参数复制
            preparedStatement.setString(1,"xiaoyu");
            preparedStatement.setInt(2,1);

            //执行
            int num = preparedStatement.executeUpdate();
            if(num>0){
                System.out.println("修改成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.release(connection,preparedStatement,null);
        }
    }
}

4、查询

import java.sql.*;

public class TestInsetPreparement {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            connection = JDBCUtils.getConnection();

            //区别
            String sql = "select * from user where UID=?";
            preparedStatement = connection.prepareStatement(sql);//预编译SQL，先写sql，然后不执行

            //手动给参数复制
            preparedStatement.setString(1,"2019054405");

            //执行
            resultSet = preparedStatement.executeQuery();
            while(resultSet.next()){
                System.out.println(resultSet.getString("Phone"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.release(connection,preparedStatement,resultSet);
        }
    }
}

10.6、事务

要么都成功，要么都失败

代码实现

1、开启事务 connection.setAutoCommit(false);

2、一组业务执行完毕，提交事务

3、可以在catch语句中显式的定义回滚语句，但是默认catch到异常就会回滚

import java.sql.*;

public class TestTransaction {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            connection = JDBCUtils.getConnection();
            //关闭数据库的自动提交，自动会开启事务
            connection.setAutoCommit(false);//开启事务

            String sql1 = "update account set money=money-500 where name=?";
            preparedStatement = connection.prepareStatement(sql1);
            preparedStatement.setString(1,"A");
            preparedStatement.executeUpdate();
            String sql2 = "update account set money=money+500 where name=?";
            preparedStatement = connection.prepareStatement(sql2);
            preparedStatement.setString(1,"B");
            preparedStatement.executeUpdate();

            //模拟失败,这里抛出异常便会自动回滚
            int x = 1/0;

            //业务完毕，提交事务
            connection.commit();
            System.out.println("成功！");
        } catch (SQLException e) {
            try {
                connection.rollback();//如果失败则回滚事务
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        }finally {
            JDBCUtils.release(connection,preparedStatement,resultSet);
        }

    }
}

10.7、数据库连接池

数据库连接---执行完毕----释放 不断执行这个过程十分浪费系统资源

池化技术：准备一些预先的资源，过来就连接预先准备好的

最小连接数：10

最大连接数：15

等待超时：100ms

编写连接池：实现DataSource接口

开源数据源实现（拿来即用）

DBCP

C3P0

Druid：阿里巴巴

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

DBCP

需要用到的jar包

commons-dbcp-1.4.jar、commons-pool-1.6.jar

如果不行可以再加入:commons-logging-1.2.jar

#注意配置文件的位置
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/wang_database?serverTimeZone=GTM&useUnicode=true&characterEncoding=utf8&useSSL=false
username=root
password=WANG20010724A



initialSize=10



maxActive = 50


minIdle=5


maxWait=6000


connectionProperties=userUnicode=true;characterEncoding=UTF8


defaultAutoCommit = true


defaultReadOnly=


defaultTransactionIsolation=READ_UNCOMMITTED


package DBCP;

import org.apache.commons.dbcp2.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("DBCP/dpcpconfig.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 connection, Statement statement, ResultSet resultset){
        if(resultset!=null){
            try{
                resultset.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
        if(statement!=null){
            try{
                statement.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
        if(connection!=null){
            try{
                connection.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }

    }
}


//DBPC测试类

package DBCP;

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

public class TestDBCP {
    public static void main(String[] args) {
        Connection connection = null;
        Statement statement = null;
        ResultSet resultset = null;
        try{
            connection = JDBCUtils_DBCP.getConnection();
            statement = connection.createStatement();
            //增操作
            //String sql = "insert into user(`id`,`NAME`,`PASSWORD`,`email`,`birthday`) values(4,'xiaoyu','123456','2303121113@qq.com','2001-1-1')";
            //查询操作
            String sql = "select * from user where UID=2019054405";
            resultset = statement.executeQuery(sql);
            while(resultset.next()){
                System.out.println(resultset.getString("Phone"));
            }

            /*int num = statement.executeUpdate(sql);
            if(num>0){
                System.out.println("插入成功");
            }*/
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
            JDBCUtils_DBCP.release(connection,statement,resultset);
        }
    }
}


C3P0

需要用到的jar包

c3p0-0.9.5.5.jar、mchange-commons-java-0.2.19.jar、mysql-connector-java-8.0.11.jar

<!--注意：首先c3p0-config.xml这个文件名不能改变！！！！
其次，要把这个配置文件放在src目录下，不能放在包里面
最后就是数据库时区配置问题
-->
<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <!-- 默认配置，如果没有指定则使用这个配置 -->
    <default-config>
        <property name="user">root</property>
        <property name="password">WANG20010724A</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/wang_database?characterEncoding=utf8&amp;useSSL=false</property>
        <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
        <property name="checkoutTimeout">30000</property>
        <property name="idleConnectionTestPeriod">30</property>
        <property name="initialPoolSize">3</property>
        <property name="maxIdleTime">30</property>
        <property name="maxPoolSize">100</property>
        <property name="minPoolSize">2</property>
        <property name="maxStatements">200</property>
    </default-config>
    <!-- 命名的配置,可以通过方法调用实现 -->
    <named-config name="MySQL">
        <property name="user">root</property>
        <property name="password">WANG20010724A</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/wang_database?serverTimeZone=GTM&amp;useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false</property>
        <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
        <!-- 如果池中数据连接不够时一次增长多少个 -->
        <property name="acquireIncrement">5</property>
        <!-- 初始化数据库连接池时连接的数量 -->
        <property name="initialPoolSize">20</property>
        <!-- 数据库连接池中的最大的数据库连接数 -->
        <property name="maxPoolSize">25</property>
        <!-- 数据库连接池中的最小的数据库连接数 -->
        <property name="minPoolSize">5</property>
    </named-config>
</c3p0-config>


//数据库接口
package 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 dataSource = null;
    static{
        try{
            //代码版配置
//            dataSource = new ComboPooledDataSource();
//            dataSource.setDriverClass();
//            dataSource.setUser();
//            dataSource.setPassword();
//            dataSource.setJdbcUrl();
//            dataSource.setMaxStatements();
//            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 connection, Statement statement, ResultSet resultset){
        if(resultset!=null){
            try{
                resultset.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
        if(statement!=null){
            try{
                statement.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
        if(connection!=null){
            try{
                connection.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }

    }
}


//测试类
package C3P0;

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

public class TestC3P0 {
    public static void main(String[] args) {
        Connection connection = null;
        Statement statement = null;
        ResultSet resultset = null;
        try{
            connection = JDBCUtils_C3P0.getConnection();
            statement = connection.createStatement();
            //增操作
            //String sql = "insert into user(`id`,`NAME`,`PASSWORD`,`email`,`birthday`) values(4,'xiaoyu','123456','2303121113@qq.com','2001-1-1')";
            //查询操作
            String sql = "select * from user where UID=2019054405";
            resultset = statement.executeQuery(sql);
            while(resultset.next()){
                System.out.println(resultset.getString("Phone"));
            }

            /*int num = statement.executeUpdate(sql);
            if(num>0){
                System.out.println("插入成功");
            }*/
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
            JDBCUtils_C3P0.release(connection,statement,resultset);
        }
    }
}


结论

无论使用什么数据源，本质还是一样的，DataSource接口不会变，方法就不会变

posted @   努力努力yyy  阅读(149)  评论(0)  编辑  收藏  举报
相关博文：
· HTML基础
· Java集合之List部分源码解析
· Mysql笔记
· MySQL数据库
· mysql
阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 开源Multi-agent AI智能体框架aevatar.ai，欢迎大家贡献代码
· Manus重磅发布：全球首款通用AI代理技术深度解析与实战指南
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
← → ↓ ↑
点击右上角即可分享
微信分享提示
AI IDE Trae