MySQL数据管理 --- 业务级MySQL

MySQL数据管理 --- 业务级MySQL

外键（了解）

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

DROP TABLE IF EXISTS `grade`;
CREATE TABLE IF NOT EXISTS `grade`(
  `gradeid` INT(5) NOT NULL ,
  `gradename` VARCHAR(20) NOT NULL,
  PRIMARY KEY(`gradeid`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;
-- 学生表的gradeid字段 要去引用年级表的 gradeid
-- 定义外键key
-- 给这个外键添加约束（执行引用） references 引用
DROP TABLE IF EXISTS `student`;
CREATE TABLE IF NOT EXISTS `student`(
  `id` INT(5) NOT NULL AUTO_INCREMENT COMMENT '学号',
  `name` VARCHAR(20) NOT NULL DEFAULT '大傻春' COMMENT '姓名',
  `pwd` VARCHAR(20)  NOT NULL DEFAULT '123456' COMMENT '密码',
  `sex` VARCHAR(2)  NOT NULL DEFAULT '男' COMMENT '性别',
  `birthday` DATETIME  NOT NULL DEFAULT '1997-7-10' COMMENT '生日',
  `address` VARCHAR(50)  NOT NULL DEFAULT '桂林' COMMENT '地址',
  `email` VARCHAR(30)  NOT NULL DEFAULT 'xxx@outlook.com' COMMENT '邮箱',
  `gradeid` INT(5) NOT NULL,
  PRIMARY KEY(`id`),
  KEY `FK_gradeid`(`gradeid`),
  CONSTRAINT `FK_gradeid` FOREIGN KEY(`gradeid`) REFERENCES `grade`(`gradeid`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;

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

方式二： 创建表成功后，添加外键约束

DROP TABLE IF EXISTS `grade`;
CREATE TABLE IF NOT EXISTS `grade`(
  `gradeid` INT(5) NOT NULL ,
  `gradename` VARCHAR(20) NOT NULL,
  PRIMARY KEY(`gradeid`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;
-- 学生表的gradeid字段 要去引用年级表的 gradeid
-- 定义外键key
-- 给这个外键添加约束（执行引用） references 引用
DROP TABLE IF EXISTS `student`;
CREATE TABLE IF NOT EXISTS `student`(
  `id` INT(5) NOT NULL AUTO_INCREMENT COMMENT '学号',
  `name` VARCHAR(20) NOT NULL DEFAULT '大傻春' COMMENT '姓名',
  `pwd` VARCHAR(20)  NOT NULL DEFAULT '123456' COMMENT '密码',
  `sex` VARCHAR(2)  NOT NULL DEFAULT '男' COMMENT '性别',
  `birthday` DATETIME  NOT NULL DEFAULT '1997-7-10' COMMENT '生日',
  `address` VARCHAR(50)  NOT NULL DEFAULT '桂林' COMMENT '地址',
  `email` VARCHAR(30)  NOT NULL DEFAULT 'xxx@outlook.com' COMMENT '邮箱',
  `gradeid` INT(5) NOT NULL,
  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 约束名 REFERENCES 哪个表(哪个字段)

以上操作都是物理外键，数据库级别的外键，不建议使用（避免数据库过多造成困扰，了解即可）

最佳实践：

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

DML语言

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

DML语言：数据操作语言

  • insert
  • update
  • delete

添加

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

-- 由于主键自增我们可以省略（如果不写表的字段，他会一一匹配）
INSERT INTO `grade` VALUES('大三')
-- 一般写插入语句，我们一定要数据和字段一一对应

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

INSERT INTO `student`(`name`,`pwd`,`sex`)VALUES('张三','AAAAAA','男'),('李四','bbbbbb','男'),('林北','AAAbbb','男')

语法：insert into 表名 ([字段名1，字段2，字段3])values('值1'),('值2'),('值3'),(......)

注意事项：

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

修改

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

-- 修改学生名字，带条件
UPDATE `student` SET `name` = '天蓬' WHERE id = 1;
-- 不指定条件的情况下，会改动所有表
UPDATE `student` SET `name` = '八戒';
-- 修改多个属性，逗号隔开
UPDATE `student` SET `name` = '悟空',`email` = '123312@QQ.COM' WHERE id = 1;

-- 语法：
-- UPDATE 表名 SET colnum_name = value,[colnum_name = value,...] WHERE [条件]

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

操作符会返回布尔值

操作符 含义 范围 结果
= 等于 5=6 false
<>或!= 不等于 5<>6 true
>
<
<=
>=
between ... and ... 在某个范围内 [2,5]
and 我和你&& 5>1 and 1>2 false
or 我或你|| 5>1 or 1>2 true 
-- 通过多个条件定位数据
UPDATE `student` SET `name` = '悟空' WHERE `name` = '八戒' AND sex='男'

语法：UPDATE 表名 SET colnum_name = value,[colnum_name = value,...] WHERE [条件]

注意：

  • colnum_name 是数据库的列，尽量带上``
  • 条件，筛选的条件，如果没有指定，会修改所有的列
  • value，是一个具体的值，也可以是一个变量
  • 多个设置的属性之间，使用英文逗号隔开
UPDATE `student` SET `birthday` = CURRENT_TIME WHERE `name` = '悟空'

删除

delete 命令

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

-- 删除数据（避免这样写，会全部删除）
DELETE FROM `student`

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

TRUNCATE 命令

作用：完全清空一个数据库表，表的结构和索引约束不会变

-- 清空studen表
TRUNCATE `student`

DELETE 和 TRUNCATE 的区别

  • 相同点：都能删除数据，都不会删除表结构
  • 不同：
    • TRUNCATE 重新设置 自增列 计数器会归零
    • TRUNCATE 不会影响事务

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

  • InnoDB 自增列会从1开始（自增量存储在内存中）
  • MyISAM 继续从上一个自增量开始（自增量存在文件中，不会丢失）

DQL 查询数据（最重点）

DQL

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

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

Select完整语法：

SELECT [ALL | DISTINCT]
{*  |  table.*  |  [table.field1[as alist1][,table.field2[as alist2]][,...]]}
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}];-- 指定查询的记录从哪条到哪条

注意：[]括号表示可选的，{}括号表示必选的

指定查询字段

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

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

去重

作用：去除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 表

WHERE条件子句

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

逻辑运算符

运算符 语法 描述
and && a and b a && b
or || a or b a||b
Not ！

尽量使用英文

-- 查询成绩在95-100分之间的
SELECT STUDENTNO,STUDENTRESULT FROM RESULT
-- AND
SELECT STUDENTNO,STUDENTRESULT FROM RESULT WHERE STUDENTRESULT >=95 AND STUDENTRESULT <=100
-- &&
SELECT STUDENTNO,STUDENTRESULT FROM RESULT WHERE STUDENTRESULT >=95 && STUDENTRESULT <=100
-- 模糊查询（区间）BETWEEN
SELECT STUDENTNO,STUDENTRESULT FROM RESULT WHERE STUDENTRESULT BETWEEN 95 AND 100 OR STUDENTRESULT BETWEEN 80 AND 90

-- 除了1000号学生以为的同学的成绩
-- !=
SELECT STUDENTNO,STUDENTRESULT FROM RESULT WHERE STUDENTNO != 1000 and STUDENTNO != 1001
-- NOT
SELECT STUDENTNO,STUDENTRESULT FROM RESULT WHERE NOT STUDENTNO = 1000 AND NOT STUDENTNO = 1001

模糊查询：比较运算符

运算符 语法 描述
IS NULL a is null 如果操作符为NULL，结果为真
IS NOT NULL a is not null 如果操作符不为NULL，结果为真
BETWEEN a between b and c 若a在b和之间，结果为真
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=====
-- 查询地址为空的学生
SELECT studentNO,studentNAME FROM student WHERE ADDRESS = '' OR ADDRESS IS NULL;
-- 查询有生日的同学 不为空
SELECT studentNO,studentNAME FROM student WHERE BORNDATE != '' OR BORNDATE IS NOT NULL;

联表查询

JOIN 对比

img

-- ======联表查询======
SELECT * FROM student
SELECT * FROM RESULT
/* 思路
1. 分析需求，分析查询的字段来自哪些表，（连接查询）
2. 确定使用哪种连接查询？ 7种
确定交叉点（这两个表中哪个数据是相同的）
判断的条件：学生表中国 studentno = 成绩表 studentno*/
SELECT S.studentNO,studentNAME,SUBJECTNO,studentRESULT 
FROM student AS S
INNER JOIN RESULT AS R
WHERE S.studentNO = R.studentno

-- Right Join
SELECT S.studentNO,studentNAME,SUBJECTNO,studentRESULT 
FROM student AS S
RIGHT JOIN RESULT AS R
ON S.studentNO = R.studentno


-- LEFT Join
SELECT S.studentNO,studentNAME,SUBJECTNO,studentRESULT 
FROM student AS S
LEFT JOIN RESULT AS R
ON S.studentNO = R.studentno
操作 描述
INNER JOIN 如果表中至少有一个匹配，就返回行
RIGHT JOIN 会从右表中返回所有的值，即使右表中没有匹配
LEFT JOIN 会从左表中返回所有的值，即使左表中没有匹配 
-- 思考题（查询参加了考试的同学信息：学号、姓名、科目名、分数）
/* 思路
1. 分析需求，分析查询的字段来自哪些表，student\result\subject （连接查询）
2. 确定使用哪种连接查询？ 7种
确定交叉点（这两个表中哪个数据是相同的）
判断的条件：学生表中 studentno = 成绩表 studentno
*/
SELECT s.studentNO,studentNAME,subjectname,studentresult
FROM student AS S
RIGHT JOIN result AS R
ON S.studentno = R.studentno
INNER JOIN `subject` AS sub
ON R.subjectno = sub.subjectno

-- 要查询哪些数据 select ....
-- 从哪几个表中查  from 表  xxx Join 连接的表 on 交叉条件
-- 假设存在一种多张表查询，慢慢来，先查询两张表，然后再慢慢增加

-- From a left join b 主体为 a 表
-- From a RIGHT JOIN b 主体为 b 表

自连接(了解)

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

父类：

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

子类：

pid categoryid categoryName
3 4 数据库
2 8 办公信息
3 6 web开发
5 7 ps技术

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

父类 子类
信息技术 办公信息
软件开发 数据库
软件开发 web开发
美术设计 ps技术 
-- 查询父子信息
SELECT C1.categoryName AS '父类' , C2.categoryName AS '子类'
FROM category AS C1 , category AS C2
WHERE C1.categoryid = C2.pid

分页和排序

排序

-- 分页 limit  排序 order by 
-- 排序：升序 ASC  降序 DESC
-- 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 r.subjectNO = sub.subjectNO
WHERE subjectNAME = '高等数学-1'
ORDER BY studentresult DESC

分页

-- 分页，每页显示五条数据
-- 语法：limit 起始值，页面大小
-- limit 0,5  0-5
-- limit 6,5  6-11
-- limit 1,5  1-6

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 r.subjectNO = sub.subjectNO
WHERE subjectNAME = '高等数学-1'
ORDER BY studentresult DESC
LIMIT 0,5

-- 第一页 limit 0,5  （1-1）*5
-- 第二页 limit 0,5  （2-1）*5
-- 第三页 limit 0,5  （3-1）*5
-- 第N页  limit 0,5  （n-1）* pageSize
-- [pageSize 页面大小]
-- [(n-1)* pageSize 起始值]
-- [n：当前页]
-- [数据总数/页面大小 = 总页数]

语法：limit(查询起始下标,pageSize)

子查询

where（这个值是计算出来的）

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

-- 连表查询
-- 查询课程为 高等数学-2 且 分数不下于 80 的同学的学号和姓名  
SELECT S.studentno,studentname 
FROM student AS S
INNER JOIN result AS R
ON R.studentno = S.studentno
INNER JOIN subject AS sub
ON R.subjectno = sub.subjectno
WHERE subjectname = '高等数学-2' AND studentresult >= 80

-- 子查询
-- 分数不小于80分的学生的学号和姓名
SELECT DISTINCT S.studentno,studentname 
FROM student AS S
INNER JOIN result AS R
ON R.studentno = S.studentno
WHERE studentresult >= 80

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

分组和过滤

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

select小结

MySQL函数

常用函数

SELECT NOW()
SELECT CURDATE()

聚合函数

函数名称 描述
COUNT() 计数
SUM() 求和
AVG() 平均值
MAX() 最大值
MIN() 最小值
...... 
-- 聚合函数
-- 都能统计 表中的数据(想查询一个表中有多少记录，使用count)
SELECT COUNT(borndate) FROM student -- count(字段)，会忽略所有的null值
SELECT COUNT(*) FROM student -- count(*)，不会忽略null值， 本质 计算行数
SELECT COUNT(1) FROM student -- count(1)，不会忽略null值， 本质 计算行数

SELECT SUM(studentresult) AS TOTAL FROM result
SELECT AVG(studentresult) AS TOTAL FROM result
SELECT MAX(studentresult) AS TOTAL FROM result
SELECT MIN(studentresult) AS TOTAL FROM result

数据库级别的MD5加密（拓展）

什么是MD5？

主要增强算法复杂性和不可逆性

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

MD5破解网站的原理，背后有一个字典，MD5加密后的值，加密前的值

--  测试MD5
DROP TABLE IF EXISTS `testmd5`
CREATE TABLE IF NOT EXISTS `testmd5`(
  `id` INT(4) NOT NULL,
  `name` VARCHAR(20) NOT NULL,
  `pwd` VARCHAR(100) NOT NULL,
  PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8

-- 明文密码
INSERT INTO testmd5 VALUES (1,'悟空','a123456'),(2,'悟能','a123456'),(3,'悟净','a123456')

-- 加密
UPDATE testmd5 SET pwd=MD5(pwd) -- 加密全部
UPDATE testmd5 SET pwd=MD5(pwd) WHERE id = 1 -- 加密一个

-- 插入时加密
INSERT INTO testmd5 VALUES (4,'悟空',MD5('a123456'))

-- 如何校验：将用户传递进来的密码，进行md5加密，然后对比加密后的值
SELECT * FROM testmd5 WHERE `name` = '悟空' AND pwd = MD5('a123456')

事务

将一组SQL放在一个批次去执行，要么都成功，要么都失败

事务原则：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）

原文链接：https://blog.csdn.net/dengjili/article/details/82468576

原子性（Atomicity）
原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。

一致性（Consistency）
事务前后数据的完整性必须保持一致。

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

持久性（Durability）--- 事务提交
持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，不可逆，接下来即使数据库发生故障也不应该对其有任何影响

隔离所导致的问题

脏读：

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

不可重复读：

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

虚读（幻读）：

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

-- mysql 默认开启事务自动提交
SET autocommit = 0 /*关闭*/
SET autocommit = 1 /*开启（默认）*/

-- 手动处理事务
SET autocommit = 0 -- 关闭自动提交

-- 事务开启
START TRANSACTION -- 标记一个事务的开始，从这个之后的sql都在同一个事务内

INSERT xx
INSERT xx

-- 提交： 持久化（成功）
COMMIT
-- 回滚： 回到原来的样子（失败）
ROLLBACK

-- 事务结束
SET autocommit = 1 -- 开启自动提交

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

模拟事务：

CREATE DATABASE shop CHARACTER SET utf8 COLLATE utf8_general_ci

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',3000.00)

-- 模拟转账：事务
SET autocommit = 0; -- 关闭自动提交
START TRANSACTION;

UPDATE account SET money=money - 500 WHERE name = 'A'; -- A 减500
UPDATE account SET money=money + 500 WHERE name = 'B'; -- B 加500

COMMIT; -- 提交事务 被持久化
ROLLBACK; -- 回滚

SET autocommit = 1; -- 恢复默认值

索引

MySQL官方对索引的定义：索引（index）是帮助MySQL高效获取数据的数据结构

提取句子主干，就可以得到索引的本质：索引是数据结构

分类

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

  • 主键索引（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('刘');

测试索引

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

-- 插入100万数据.
SET GLOBAL log_bin_trust_function_creators=1; -- 开启创建函数功能
/*
  第一个语句 delimiter 将 mysql 解释器命令行的结束符由”;” 改成了”$$”，
  让存储过程内的命令遇到”;” 不执行
*/
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`)VALUES(CONCAT('用户',i),'19224305@qq.com','123456789',FLOOR(RAND()*2));
		SET i=i+1;
	END WHILE;
	RETURN i;
END;$$

SELECT mock_data()$$ -- 执行此函数 生成一百万条数据


SELECT * FROM app_user WHERE name = '用户9999'

EXPLAIN SELECT * FROM app_user WHERE name = '用户9999'

-- id _ 表名 _ 字段名
-- CREATE INDEX 索引名 ON 表（字段）
CREATE INDEX id_app_user_name ON app_user(`name`)
SELECT * FROM app_user WHERE name = '用户9999'

EXPLAIN SELECT * FROM app_user WHERE name = '用户9999'

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

索引原则

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

索引的数据结构

Hash类型的索引

Btree：InnoDB的默认数据结构

阅读：CodingLabs - MySQL索引背后的数据结构及算法原理

权限管理和数据库备份

用户管理

用户表：mysql.user

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

-- 创建用户  CREATE USER 用户名 IDENTIFIED BY '密码'
CREATE USER kuangshen IDENTIFIED BY '123456'

-- 修改密码 
-- 当前用户
SET PASSWORD = PASSWORD('123456')
-- 指定用户
SET PASSWORD FOR kuangshen = PASSWORD('123456')

-- 重命名
RENAME USER kuangshen TO kuangshen2

-- 用户授权 ALL PRIVILEGES 全部的权限， 库，表
-- ALL PRIVILEGES 除了给别人授权，别的都能干
GRANT ALL PRIVILEGES ON *.* TO kuangshen

-- 查询权限
SHOW GRANTS FOR kuangshen -- 查看指定用户的权限
SHOW GRANTS FOR root@localhost -- 查看root用户权限

-- 撤销权限 REVOKE 哪些权限 ，在哪个库撤销，给谁撤销
REVOKE ALL PRIVILEGES ON *.* FROM kuangshen

-- 删除用户
DROP USER kuangshen

MySQL备份

为什么要备份：

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

MySQL备份的方法：

  • 直接拷贝物理文件

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

    • sql转储

  • 使用命令行导出 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:/a.sql
 
 # mysqldump -h 主机 -u 用户名 -p 密码   数据库    > 物理磁盘位置/文件名
 mysqldump -hlocalhost -uroot -p123456 school  >D:/a.sql
 
 # 导入
 # 登录的情况下、切换到指定的数据库
 # source 备份文件
 source d:/a.sql
 
 mysql -u用户名 -p密码 库名< 备份文件

数据库的归约，三大范式（规范数据库设计）

为什么要设计

糟糕的数据库设计：

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

良好的数据库设计：

  • 节省内存空间
  • 保证数据库的完整性
  • 方便我们开发

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

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

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

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

三大范式

为什么需要数据规范化

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

三大范式（规范数据库的设计）

第一范式（1NF）

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

第二范式（2NF）

前提：满足第一范式

每张表只描述一件事情

第三范式（3NF）

前提：满足第二范式

第三范式需要确保数据表中的每一列数据都和主键直接相关，而不能间接相关。

规范性 和 性能 的问题

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

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

JDBC（重点）

数据库驱动

JDBC

SUN公司为了简化 开发人员的（对数据库的同一）操作，提供了一个（Java操作数据库的）规范，俗称JDBC

这些规范的实现由具体的厂商去做

对于开发人员来说，我们只需要掌握JDBC接口的操作即可

java.sql

javax.sql

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

第一个JDBC程序

  • 创建普通项目

  • 导入数据库驱动

  • 编写代码

    package com.gs.lesson;

import com.mysql.jdbc.Driver;

import java.sql.*;

/**
 * @version: java version 1.8
 * @author: 14
 * @description：
 */
public class JdbcFisrstDemo {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // 1、加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 2、用户信息和url
        String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false";
        String username = "root";
        String password = "123456";
        // 3、连接成功，返回数据库对象
        Connection connection = DriverManager.getConnection(url, username, password);

        // 4、执行sql的对象
        Statement statement = connection.createStatement();
        // 5、执行sql的对象 去执行 sql，可能存在结果，查看返回结果
        String sql = "select * from users";
        ResultSet resultSet = statement.executeQuery(sql);// 返回的结果集,封装了全部的查询结果
        while (resultSet.next()) {
            System.out.println("id:" + resultSet.getObject("id"));
            System.out.println("name:" + resultSet.getObject("name"));
            System.out.println("pwd:" + resultSet.getObject("password"));
            System.out.println("email:" + resultSet.getObject("email"));
            System.out.println("birth:" + resultSet.getObject("birthday"));
        }
        // 6、释放连接
        resultSet.close();
        statement.close();
        connection.close();
    }
}

步骤总结：

  • 加载驱动
  • 连接数据库 DriverManager
  • 获得执行sql的对象 Statement
  • 获得返回的结果集
  • 释放连接

DriverManager

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

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

URL

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

//mysql --- 3306
//jdbc:mysql://主机地址:端口号/数据库名?参数1&参数2&参数3
//oralce --- 1521
//jdbc:oracle:thin:@localhost:1521:sid

Statement | PrepareStatement 执行sql的对象

String sql = "select * from users" //编写sql

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

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

获得指定的数据类型

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

遍历，指针

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

释放资源

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

statement对象

代码实现

1、提取工具类

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

            driver = properties.getProperty("driver");
            url = properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");

            // 1、驱动只用加载一次
            Class.forName(driver);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    //获取连接资源
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url,username,password);
    }

    //释放连接资源
    public static void release(Connection conn, Statement stmt, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

2、编写增删改的方法 executeUpdate

public class TestInsert {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtils.getConnection(); //获取数据库连接
            stmt = conn.createStatement(); //获得sql的执行对象
            String sql = "INSERT INTO users(ID,NAME,PASSWORD,EMAIL,BIRTHDAY)"+
                    "VALUES(4,'KUANGSHEN','123456','1235563@QQ.COM','2025-1-1')";
            int i  = stmt.executeUpdate(sql);
            if (i > 0){
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(conn, stmt, rs);
        }
    }
}

public class TestDelete {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;

        try {
            conn = JdbcUtils.getConnection();
            stmt = conn.createStatement();
            String sql = "delete from users where id=4";
            int i = stmt.executeUpdate(sql);
            if ( i > 0){
                System.out.println("删除成功");
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(conn,stmt,null);
        }
    }
}

public class TestUpdate {
    public static void main(String[] args) throws SQLException {
        Connection conn = null;
        Statement stmt = null;

        try {
            conn = JdbcUtils.getConnection();
            stmt = conn.createStatement();
            String sql = "UPDATE users SET name= 'kuangshen' ,email = '858728@qq.com' where id = 1";
            int i = stmt.executeUpdate(sql);
            if (i > 0) {
                System.out.println("修改成功");
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(conn, stmt, null);
        }
    }
}

3、查询execuQuery

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

        try {
            conn = JdbcUtils.getConnection();
            stmt = conn.createStatement();
            //SQL
            String sql = "select * from users where id = 1";
            rs = stmt.executeQuery(sql);
            while (rs.next()) {
                System.out.println(rs.getString("name"));
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(conn, stmt, rs);
        }
    }
}

SQL注入的问题

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

public class SQL注入 {
    public static void main(String[] args) {

        login("' or'1=1","' or'1=1");
    }

    public static void login(String username, String password){
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();
            stmt = conn.createStatement();
            String sql = "select * from users where name = '"+username+"' and password = '"+password+"'";
            rs = stmt.executeQuery(sql);
            while(rs.next()){
                System.out.println(rs.getString("name"));
                System.out.println(rs.getString("password"));
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            JdbcUtils.release(conn, stmt, rs);
        }
    }
}

PreparedStatement

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

1、新增

public class TestInsert {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtils.getConnection(); //获取数据库连接

            //区别
            //使用?占位符 代替参数

            String sql = "INSERT INTO users(ID,NAME,PASSWORD,EMAIL,BIRTHDAY)"+
                    "VALUES(?,?,?,?,?)";
            ps = conn.prepareStatement(sql);//预编译SQL，先写sql，然后不执行

            //手动给参数赋值
            ps.setInt(1,6);
            ps.setString(2,"shisi");
            ps.setString(3,"123456");
            ps.setString(4,"8578482@qq.com");
            //注意点：sql.Date   数据库   java.sql.Date
            //       util.Date   java   new Date().getTime() 获得时间戳
            ps.setDate(5, new java.sql.Date(new Date().getTime()));

            //执行
            int i = ps.executeUpdate();
            if (i > 0) {
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(conn, ps, rs);
        }
    }
}

2、删除

public class TestDelete {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;

        try {
            conn = JdbcUtils.getConnection();

            String sql = "delete from users where id=?";

            ps = conn.prepareStatement(sql);
            ps.setInt(1, 5);
            int i = ps.executeUpdate();
            if ( i > 0){
                System.out.println("删除成功");
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(conn,ps,null);
        }
    }
}

3、更新

public class TestUpdate {
    public static void main(String[] args) throws SQLException {
        Connection conn = null;
        PreparedStatement ps = null;

        try {
            conn = JdbcUtils.getConnection();
            String sql = "UPDATE users SET name=?  where id =?";

            ps = conn.prepareStatement(sql);

            ps.setString(1, "kuangshen");
            ps.setInt(2, 5);

            int i = ps.executeUpdate();
            if (i > 0) {
                System.out.println("修改成功");
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(conn, ps, null);
        }
    }
}

4、查询

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

        try {
            conn = JdbcUtils.getConnection();
            //SQL
            String sql = "select * from users where id =?";

            ps = conn.prepareStatement(sql);
            ps.setInt(1, 6);//传递参数
            rs = ps.executeQuery();
            while (rs.next()) {
                System.out.println(rs.getString("name"));
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(conn, ps, rs);
        }
    }
}

5、防止SQL注入

public class SQL注入 {
    public static void main(String[] args) {

        login("' or'1=1","' or'1=1");
    }

    public static void login(String username, String password){
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();
            //PreparedStatement 防止SQL注入的本质，把传递进来的参数当做字符串
            // 假设其中存在转义字符，直接忽略，比如说'
            String sql = "select * from users where name = ? and password = ?";
            stmt = conn.prepareStatement(sql);
            stmt.setString(1, username);
            stmt.setString(2, password);
            rs = stmt.executeQuery();
            while(rs.next()){
                System.out.println(rs.getString("name"));
                System.out.println(rs.getString("password"));
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            JdbcUtils.release(conn, stmt, rs);
        }
    }
}

使用IDEA连接数据库

事务

代码实现

1、关闭自动提交，开启事务conn.setAutoCommit(false);

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

3、可以在catch语句中显式的定义 回滚语句，但默认失败就会回滚

public class 事务 {
    public static void main(String[] args) {
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            con = JdbcUtils.getConnection();

            con.setAutoCommit(false);// 关闭自动提交，开启事务

            String sql = "UPDATE account SET money = money - 100 where name = 'A'";
            ps = con.prepareStatement(sql);
            ps.executeUpdate();

            //int i = 1/0; // 让 事务 不能完成

            sql = "UPDATE account SET money = money + 100 where name = 'B'";
            ps = con.prepareStatement(sql);
            ps.executeUpdate();

            con.commit();// 业务完成 提交
        }catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(con, ps, rs);
        }
    }
}

数据库连接池

数据库连接 ---- 执行完毕 ---- 释放

连接 ---- 释放 十分浪费系统资源

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

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

若 常用连接数：10个

​ 最小连接数：10个

​ 最大连接数：15个 业务最高承载上限

​ 等待超时：100ms

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

开源数据源实现

DBCP

C3P0

Druid：阿里巴巴

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

DBCP

需要的jar包

commons-dbcp-1,4.jar commons-pool-1.6.jar

工具类

public class JdbcUtils_DBCP {

    private static DataSource dataSource = null;

    static {
        try {
            InputStream in = JdbcUtils.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 stmt, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

配置文件

#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false
username=root
password=123456

#<!-- 初始化连接 -->
initialSize=10

#最大连接数量
maxActive=50

#<!-- 最大空闲连接 -->
maxIdle=20

#<!-- 最小空闲连接 -->
minIdle=5

#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
maxWait=60000
#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：【属性名=property;】
#注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=UTF8

#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true

#driver default 指定由连接池所创建的连接的只读（read-only）状态。
#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
defaultReadOnly=

#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_UNCOMMITTED

C3P0

需要的jar包

c3p0-0.9.5.5.jar 、mchange-commons-java-0.2.19.jar

工具类

public class JdbcUtils_C3P0 {

    private static DataSource dataSource = null;

    static {
        try {
            //创建数据源 工厂模式  --->创建
            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 stmt, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <!--
c3p0的缺省（默认）配置
如果在代码中"ComboPooledDataSource ds=new ComboPooledDataSource();"这样写就表示使用的是c3p0的缺省（默认）-->
    <default-config>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&amp;characterEncoding=utf8&amp;uesSSL=true&amp;serverTimezone=UTC</property>
        <property name="user">root</property>
        <property name="password">123456</property>

        <property name="acquiredIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </default-config>

    <!--如果在代码中"ComboPooledDataSource ds=new ComboPooledDataSource("MySQL");"这样写就表示使用的是name是MySQL的配置-->
    <named-config name="MySQL">
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&amp;characterEncoding=utf8&amp;uesSSL=true&amp;serverTimezone=UTC</property>
        <property name="user">root</property>
        <property name="password">123456</property>

        <property name="acquiredIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </named-config>
</c3p0-config>

结论

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

posted @ 2024-07-18 15:53  十四2001  阅读(2)  评论(0)  编辑  收藏  举报