WHCSRL 技术网

MySQL---学习笔记

MySQL


JavaEE:企业级Java开发 web

前端(页面:展示,数据!)

后台(连接点:连接数据库JDBC,连接前端(控制,控制视图跳转,和给前端传递数据))

数据库(存数据,Txt,Excel,word)

只会写代码,学好数据库,基本混饭吃;

操作系统,数据结构与算法!当一个不错的程序猿!

离散数学,数字电路,体系结构,编译原理。+实战经验 高级程序猿

DBMS(数据管理系统)

  • 数据库的管理软件,科学有效的管理我们的数据。维护获取数据;
  • MySQL,数据库管理系统!

命令行执行

mysql -uroot -p123456  #连接数据库

update mysql.user set authentication_string=password('123456')where user = 'root' and Host ='localhost';#修改用户密码

flush privileges; #刷新权限

-----------------------------------------------------------------------------------------------------------------------

所有的语句都使用分号;结尾

show databases;#查看所有的数据库

use database;#切换数据库 use 数据库名

show tables; #查看数据库中所有的表

describe table;#显示表中所有的信息

create database hzx;#创建一个数据库

exit;#退出连接

-- 单行注释(SQL本来的注释)

/**/ 多行注释

CRUD增删改查! CV程序猿 API程序猿 CRUD程序猿!

DDL数据库定义语言

DML数据库操作语言

DQL数据库查询语言

DCL数据库控制语言

操作数据库


操作数据库>操作数据库中的表>操作数据库中表的数据

MySQL关键字不区别大小写   []可选 {}必选

操作数据库

1、创建数据库

CREATE DATABASE [IF NOT EXISTS] 名称

2、删除数据库

DROP DATABASE [IF EXISTS] 名称

3、使用数据库

  1. --库名或者表名或者字段名与关键字重复时 加 `
  2. USE `名称`

4、查看数据库

SHOW DATABASE --查看所有的数据库

数据库的数据类型

数值

  • tinyint        十分小的数据        1个字节
  • smallint      较小的数据           2个字节
  • mediumint   中等大小的数据   3个字节
  • int              标准的整数           4个字节        常用的  int
  • bigint        较大的数据             8个字节
  • float           浮点数                  4个字节
  • double      浮点数                   8个字节
  • decimal  字符串形式浮点数(金融计算的时候,一般使用)      

字符串

  • char        字符串固定大小的          0~255
  • varchar     可变字符串                   0~65535       常用的  String
  • tinytext      微型文本                      2^8 - 1
  • text             文本串                        2^16 - 1        保存大文本  

时间日期

  • date           YYYY-MM-DD  日期格式
  • time           HH:mm:ss        时间格式
  • datetime    YYYY-MM-DD   HH:mm:ss  最常用的时间格式
  • timestamp    时间戳    1970.1.1到现在的毫秒数
  • year     年份表示

null

  • 没有值,未知
  • 注意:不要使用null进行运算,结果为null

数据库的字段属性

Unsigned

  • 无符号的整数
  • 声明了该列不能声明为负数

zerofill

  • 0填充
  • 不足的位数,使用0来填充 int(3)   5----005

自增

  • 通常理解为自增,自动在上一条记录的基础上+1(默认)
  • 通常用来设计唯一的主键,必须是整数类型
  • 可以自定义设计主键的起始值,和步长

非空:null not null

  • 假设设置为not null,如果不给它赋值就会报错
  • null,不填写值 默认就是null

默认

  • 设置默认值
  • 如果不指定该列的值 则有默认的值

扩展

  1. /*每一个表 都必须存在一下5个字段 做项目用表示一个记录存在意义
  2. id 主键
  3. `version` 乐观锁
  4. is_delete 伪删除
  5. gmt_create 创建时间
  6. gmt_update 修改时间
  7. */

创建数据库表(重点)

  1. --注意 使用英文() 表的名称和字段尽量用` `括起来
  2. --AUTO_INCREMENT 自增
  3. --字符串使用单引号或者双引号括起来
  4. --所有的语句后面加, 最后一个不用加
  5. --DEAFAULT 默认值
  6. --PRIMARY KEY主键 一般一个表只有一个唯一的主键
  7. CREATE TABLE IF NOT EXISTS `student`(
  8. `id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
  9. `name` VARCHAR(30) NOT NULL DEFAULT '匿名' COMMENT'姓名',
  10. `pwd` VARCHAR(20) NOT NULL DEFAULT '123456' COMMENT'密码',
  11. `sex` VARCHAR(2) NOT NULL DEFAULT '女' COMMENT'性别',
  12. `birthday` DATETIME( NOT NULL DEFAULT NULL COMMENT'出生日期',
  13. `address` VARCHAR(100) NOT NULL DEFAULT NULL COMMENT'家庭住址',
  14. `email` VARCHAR(50) NOT NULL DEFAULT NULL COMMENT'邮箱',
  15. PRIMARY KEY(`id`)
  16. )ENGINE=INNODB DEFAULT CHARSET=utf8

格式:

  1. CREATE TABLE [IF NOT EXISTS] `表名`(
  2. '字段名' 列类型 [属性] [索引] [注释],
  3. '字段名' 列类型 [属性] [索引] [注释],
  4. ......
  5. '字段名' 列类型 [属性] [索引] [注释]
  6. )[表类型][字符集设置][注释]

常用命令:

  1. SHOW CREATE DATEBASE [数据库名] --查看创建数据库的语句
  2. SHOW CREATE TABLE [表名] --查看创建表的语句
  3. DESC [表名] --显示表的结构

数据表的类型

  1. --关于数据库引擎
  2. /*
  3. INNODB 默认使用~
  4. MYISAM 早些年使用
  5. */
MYISAMINNODB
事务支持不支持支持
数据行锁定不支持支持
外键约束不支持支持
全文索引支持不支持
表空间大小较小较大,约两倍

常规使用操作:

  • MYISAM 节约空间,速度较快
  • INNODB 安全性高,事务的处理,多表多用户操作

在物理空间存在的位置

所有的数据库文件都存在data目录下

本质还是文件的存储

MySQL数据库引擎在物理文件上的区别:

  • INNODB在数据库表中只有一个*.frm文件,以及上级目录下的ibdata文件
  • MYISAM对应文件
    • *.frm 表结构定义文件
    • *.MYD 数据文件
    • *.MYI 索引文件

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

CHARSET=utf8

不设置的话,会是MySQL字符集默认的编码(不支持中文)

修改删除表

修改

  1. --修改表名
  2. ALTER TABLE 表名 RENAME AS 新表名
  3. --增加表的字段
  4. ALTER TABLE 表名 ADD 字段 字段属性
  5. --修改表的字段(重命名,修改约束)
  6. ALTER TABLE 表名 MODIFY 字段 新的字段属性 --修改约束
  7. ALTER TABLE 表名 CHANGE 字段 新的字段名 --字段重命名
  8. --删除表的字段
  9. ALTER TABLE 表名 DROP 字段

删除

  1. --删除表
  2. DROP TABLE [IF EXISTS] 表名 --如果表存在,再删除

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

注意

  • ` ` 字段名使用这个包裹
  • 注释 -- , /* */
  • SQL关键字大小写不敏感,建议使用小写
  • 所有的符号用英文

MySQL数据管理


外键

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

  1. CREATE TABLE `grade`(
  2. `gradeid` INT(10) NOT NULL AUTO_INCREMENT COMMENT '年纪id',
  3. `gradename` VARCHAR(50) NOT NULL COMMENT '年级名称',
  4. PRIMARY KEY('gradeid')
  5. )ENGINE=INNODB DEFAULT CHARSET=utf8
  6. --学生表的gradeid字段要去引用年级表的gradeid
  7. --定义外键key
  8. --给这个外键添加约束(执行引用) reference 引用
  9. CREATE TABLE IF NOT EXISTS `student`(
  10. `id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
  11. `name` VARCHAR(30) NOT NULL DEFAULT '匿名' COMMENT'姓名',
  12. `pwd` VARCHAR(20) NOT NULL DEFAULT '123456' COMMENT'密码',
  13. `sex` VARCHAR(2) NOT NULL DEFAULT '女' COMMENT'性别',
  14. `birthday` DATETIME( NOT NULL DEFAULT NULL COMMENT'出生日期',
  15. `gradeid` INT(10) NOT NULL COMMENT '学生的年级',
  16. `address` VARCHAR(100) NOT NULL DEFAULT NULL COMMENT'家庭住址',
  17. `email` VARCHAR(50) NOT NULL DEFAULT NULL COMMENT'邮箱',
  18. PRIMARY KEY(`id`),
  19. KEY `FK_gradeid` (`gradeid`),
  20. CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade`(`gradeid`)
  21. )ENGINE=INNODB DEFAULT CHARSET=utf8

删除有外键关系的表的时候,必须要先删除引用别人的表(从表),再删除被引用的表(主表)

方式二:创建表成功后,添加外键约束

  1. CREATE TABLE `grade`(
  2. `gradeid` INT(10) NOT NULL AUTO_INCREMENT COMMENT '年纪id',
  3. `gradename` VARCHAR(50) NOT NULL COMMENT '年级名称',
  4. PRIMARY KEY('gradeid')
  5. )ENGINE=INNODB DEFAULT CHARSET=utf8
  6. --学生表的gradeid字段要去引用年级表的gradeid
  7. --定义外键key
  8. --给这个外键添加约束(执行引用) reference 引用
  9. CREATE TABLE IF NOT EXISTS `student`(
  10. `id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
  11. `name` VARCHAR(30) NOT NULL DEFAULT '匿名' COMMENT'姓名',
  12. `pwd` VARCHAR(20) NOT NULL DEFAULT '123456' COMMENT'密码',
  13. `sex` VARCHAR(2) NOT NULL DEFAULT '女' COMMENT'性别',
  14. `birthday` DATETIME( NOT NULL DEFAULT NULL COMMENT'出生日期',
  15. `gradeid` INT(10) NOT NULL COMMENT '学生的年级',
  16. `address` VARCHAR(100) NOT NULL DEFAULT NULL COMMENT'家庭住址',
  17. `email` VARCHAR(50) NOT NULL DEFAULT NULL COMMENT'邮箱',
  18. PRIMARY KEY(`id`)
  19. )ENGINE=INNODB DEFAULT CHARSET=utf8
  20. --创建表的时候没有外键关系
  21. ALTER TABLE `student`
  22. ADD CONSTRAINT `FK_gradeid` FOREIGN KEY(`gradeid`) REFERENCES `grade`(`gradeid`);
  23. 公式:ALTER TABLEADD CONSTRAINT 约束名 FOREIGN KEY(`作为外键的列`) REFERENCES 哪个表(哪个字段)

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

最佳实践 

  • 数据库就是单纯的表,只用来存数据,只有行(数据)和列(字段)
  • 想使用多张表的数据,想使用外键(程序去实现)

DML语言

数据库意义:数据存储,数据管理

DML语言:数据操作语言

  • Insert
  • update
  • delete

添加

Insert

  1. --插入语句(添加)
  2. INSERT INTO 表名([字段1,字段2,......]) values('值1','值2',......)
  3. --插入多个数据
  4. INSERT INTO 表名([字段1,字段2,......])
  5. values('值1','值2',......),('值1','值2',......),......

注意事项:

  1. 字段和字段之间使用 英文逗号隔开
  2. 字段是可以省略的,后面的值必须要一 一对应,不能少
  3. 可以同时插入多条数据,values后面的值,需要使用逗号隔开

修改

update 

  1. --修改学员名字
  2. UPDATE `student` SET `name`='hzx' WHERE `id` = 1;
  3. --语法:
  4. UPDATE 表名 SET 字段 =WHERE 条件;
  5. --多个属性 用逗号隔开
  6. UPDATE 表名 SET 字段 = 值 , 字段 = 值 , 字段 = 值 ,...... WHERE 条件;

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

操作符会返回 布尔值

操作符含义范围结果
=等于5=6false
<>或!=不等于5<>6true
>大于
<小于

>=

大于等于
<=小于等于
BETWEEN...AND...在某个范围内
AND我和你 &&
OR我或你 ||

注意:

  • 字段是数据库的列,尽量带上``
  • 条件,筛选的条件,如果没有指定则会修改所有的列
  • value是一个具体的值,也可以是一个变量

删除

delete

  1. --删除数据(避免这样写)
  2. DELETE FROM `student`
  3. --删除指定数据
  4. DELETE FROM `sudent` WHRER id = 1;
  5. --语法
  6. DELETE FROM 表名 [WHERE 条件]

TRUNCATE命令

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

  1. --清空表
  2. TRUNCATE 表名

DELETE 与 TRUNCATE 区别

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

DELETE删除问题,重启数据库现象

  • INNODB自增列会重1开始(存在内存当中,断点即失)
  • MYISAM 继续从上一个自增量开始(存在文件中,不会丢失)

DQL查询数据


DQL

(Data Query Language:数据查询语言)

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

Select完整的语法:

  1. SELECT [ALL | DISTINCT]
  2. {* | table.* | [table.field1[as alias1][,table.field2[as alias2]][,...]]}
  3. FROM table_name [as table_alias]
  4. [left | right | inner join table_name2] --联合查询
  5. [WHERE ...] --指定结果需满足的条件
  6. [GROUP BY ...] --指定结果按照哪几个字段来分组
  7. [HAVING] --过滤分组的记录必须满足的次要条件
  8. [ORDER BY ...] --指定查询记录按一个或多个条件排序
  9. [LIMIT {[offest,]row_count | row_countOFFSET offest}]; -- 指定查询的记录从哪条到哪条

 注意:[ ]括号代表可选,{ }括号代表必选

指定查询字段

  1. --查询语句 语法
  2. SELECT 字段 FROM
  3. --别名
  4. SELECT 字段 AS 别名 FROM
  5. --函数 Concat(a,b) 拼接
  6. SELECT CINCAT('',字段) FROM

有的时候,列名字不是那么见名知意 起别名  字段名 AS 别名

去重 distinct

  1. --发现重复数据 去重 语法
  2. SELECT DISTINCT 字段 FROM

作用:去除SELECT查询出来的结果重复的数据,重复的数据只显示一条

数据库的列(表达式)

  1. SELECT VERSION() --查询系统版本 (函数)
  2. SELECT 100*3-1 AS 计算结果 --用来计算(表达式)
  3. SELECT @@auto_increment_increment --查询自增的步长(变量)

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

where条件子句

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

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

逻辑运算符

运算符语法描述
and 或者 &&a and b  或者 a&&b逻辑与,两个都为真,结果为真
or  或者 ||a or b   或者  a | | b逻辑或,一个为真,结果为真
Not 或者 !not a 或者 ! a逻辑非,真为假,假为真

尽量使用英文字母

模糊查询 :比较运算符

运算符语法描述
is null a is null如果操作为null,结果为真
is not nulla is not null如果操作符为not null,结果为真
betweena between b and c若a在b和c之间,结果为真
likea like b如果a匹配b,结果为真
ina in (a1,a2....)假设a在a1或者a2或者....其中某一个值中,结果为真
  1. --模糊查询
  2. --语法 like 结合 %%(代表0到任意个字符) _(一个字符)
  3. SELECT 字段 FROMWHERE 字段 LIKE 'X%%' X:查询字符
  4. --in 具体的一个或者多个值
  5. --语法
  6. SELECT 字段 FROMWHERE 字段 IN(A,B); (A,B):A到B范围内

联表查询

join 对比

  1. /*
  2. 思路
  3. 分析需求,分析查询的字段来自哪些表(连接查询)
  4. 确定使用哪种连接查询
  5. 确定交叉点(两个表哪个数据是相同的)
  6. 判断的条件:学生表的中 studentNO = 成绩表 studentNo
  7. */
  8. -- inner join
  9. SELECT s.sudentNO,studentName,SubjectNo,StudentResult
  10. FROM student AS s
  11. INNER JOIN result AS r
  12. WHERE s.studentNo = r.studentNo
  13. -- right join
  14. SELECT s.sudentNO,studentName,SubjectNo,StudentResult
  15. FROM student AS s
  16. RIGHT JOIN result AS r
  17. ON s.studentNo = r.studentNo
  18. -- left join
  19. SELECT s.sudentNO,studentName,SubjectNo,StudentResult
  20. FROM student AS s
  21. LEFT JOIN result AS r
  22. ON s.studentNo = r.studentNo
操作描述
inner join如果表中至少有一个匹配,就返回值
left join即使右表中没有匹配,也会在左表中返回所有的值
right join即使左表中没有匹配,也会在右表中返回所有的值
  1. -- join (连接表) on (条件判断) 连接查询
  2. -- where 等值查询
  1. --查询哪些数据 select ...
  2. --从哪几个表中查FROM 表 XXX join 连接的表 on 交叉条件
  3. --假设存在一种多张表查询,慢慢来,先查询两张表再慢慢增加

自连接

  1. --自连接
  2. --创建一个表
  3. CREATE TABLE `category`(
  4. `categoryid` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '主题id',
  5. `pid` INT(10) NOT NULL COMMENT '父id',
  6. `categoryName` VARCHAR(50) NOT NULL COMMENT '主题名字',
  7. PRIMARY KEY (`categoryid`)
  8. )ENGINE=INNODB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8
  9. --插入数据
  10. INSERT INTO `category`(`categoryid`,`pid`,`categoryName`)
  11. VAKUES('2','1','信息技术'),
  12. ('3','1','软件开发'),
  13. ('4','3','数据库'),
  14. ('5','1','美术设计'),
  15. ('6','3','web开发'),
  16. ('7','5','ps技术'),
  17. ('8','2','办公信息');

 

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

父类:

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

子类:

pidcategoryidcategroyName
34数据库
28办公信息
36web开发
57ps技术

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

父类子类
信息技术办公信息
软件开发数据库
软件开发web开发
美术设计ps技术
  1. --查询父子信息:把一张表拆成两张一模一样的表
  2. SELECT a.`categoryName` AS '父栏目',b.`categoryName` AS `子栏目`
  3. FROM `category` AS a, `category` AS b
  4. WHERE a.`categoryid` = b.`pid`

分页和排序

排序

排序:升序 ASC , 降序 DESC

ORDER BY 通过哪个字段排序 怎么排

分页

为什么分页?

缓解数据库压力,给人体验更好,瀑布流

分页 每页只显示五条数据

语法:limit 起始值,页面大小

limit 0,5      1~5数据

limit 1,5        2~6数据

网页应用: 当前页,总页数   页面大小

网页应用公式:limit (n-1)*pageSize,pageSize

pageSize:页面大小

(n-1)*pageSize:起始值

n:当前页

数据总数/页面大小 = 总页数

子查询

where(固定的值,假设这个值不是固定的就是子查询)

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

  1. --查询数据库结构-1的所有考试结果(学号,科目编号,成绩),降序排列
  2. -- 方式一 使用连接查询
  3. SELECT `StudentNo`,r.`SubjectNo`,`StudentResult`
  4. FROM `result` r
  5. INNER JOIN `subject` sub
  6. ON r.SubjectNo = sub.SubjectNo
  7. WHERE SubjectName = '数据库结构-1'
  8. ORDER BY StudentResult DESC
  9. --方式二 子查询(由里及外)
  10. SELECT `StudentNo`,`SubjectNo`,`StudentResult`
  11. FROM `result`
  12. WHERE StudentNo = (
  13. SELECT SubjectNoFROM `Subject` WHERE SubjectName = '数据库结构-1'
  14. )
  15. ORDER BY StudentResult DESC
  16. -- 查询所有数据库结构-1的学生学号
  17. SELECT SubjectNoFROM `Subject` WHERE SubjectName = '数据库结构-1'

MySQL函数


官网:MySQL :: MySQL 8.0 Reference Manual :: 12.1 Built-In Function and Operator Reference

常用函数 

  1. --数学运算
  2. SELECT ABS(-8) --绝对值
  3. SELECT CEILING(9.4) --向上取整
  4. SELECT FLOOR(9.4) --向下取整
  5. SELECT RAND() --返回一个0~1之间的随机数
  6. SELECT SIGN() --判断一个数的符号 0是0 负数返回-1 整数返回1
  7. --字符串函数
  8. SELECT CHAR_LENGTH('hzx') --字符串长度
  9. SELECT CONCAT('H','Z','X') --拼接字符串
  10. SELECT INSERT('HZX',1,2,'X') --插入 替换 从某个位置开始替换某个长度
  11. SELECT LOWER() --转小写
  12. SELECT UPPER() --转大写
  13. SELECT INSTR() --返回字符串第一次出现的参数
  14. SELECT REPLACE() --替换出现的字符串
  15. SELECT SUBSTR() -- 返回指定的子字符串
  16. SELECT REVERSE() --反转字符串的字符
  17. --时间和日期函数
  18. SELECT CURRENT_DATE() -- 获取当前日期
  19. SELECT CURDATE() -- 获取当前日期
  20. SELECT NOW() -- 获取当前时间
  21. SELECT LOCALTIME() -- 本地时间
  22. SELECT SYSDATE() -- 系统时间
  23. SELECT YEAR() -- 年
  24. -- 系统
  25. SELECT SYSTEM_USER()
  26. SELECT USER()
  27. SELECT VERSION()

聚合函数

函数名称

描述

COUNT()计数
SUM()求和
AVG()平均值
MAX()最大值
MIN()最小值
......
  1. --聚合函数
  2. --查询表中有多少记录使用count()
  3. SELECT COUNT(字段) FROM--COUNT(字段) 会忽略所有的null值
  4. --本质计算行数
  5. SELECT COUNT(*) FROM--COUNT(*) 不会忽略所有的null值
  6. SELECT COUNT(1) FROM--COUNT(1) 不会忽略所有的null值
  7. SELECT SUM(字段) FROM
  8. SELECT AVG(字段) FROM
  9. SELECT MAX(字段) FROM
  10. SELECT MIN(字段) FROM
  11. --查询不同课程的平均分,最高分,最低分,平均分大于80
  12. --核心:(根据不同的课程分组)
  13. SELECT SubjectName,AVG(StudentResult),MAX(StudentResult),MIN(StudentResult)
  14. FROM result r
  15. INNER JOIN `subject` sub
  16. ON r.`SubjectNo` = sub.`SubjectNo`
  17. GROUP BY r.SubjectNo --通过什么字段来分组
  18. HAVING AVG(StudentResult) > 80

数据库级别的MD5加密

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

MD5不可逆,具体的值的MD5值是一样的

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

  1. CREATE TABLE `testmd5`(
  2. `id` INT(4) NOT NULL,
  3. `name` VARCHAR(20) NOT NULL,
  4. `pwd` VARCHAR(50) NOT NULL,
  5. PRIMARY KEY(`id`)
  6. )ENGINE=INNODB DEFAULT CHARSET=utf8
  7. --明文密码
  8. INSERT INTO testmd5 VALUES(1,'zhangsan','123456'),(2,'lisi','123456'),(3,'wangwu','123456')
  9. --加密
  10. UPDATE testmd5 SET pwd = MD5(pwd) WHERE id = 1
  11. --插入时候的加密
  12. INSERT INTO testmd5 VALUES(4,'xiaoming',MD5('123456'))
  13. --如何校验:将用户传递进来的密码,进行MD5加密,然后对比加密后的值
  14. SELECT * FROM testmd5 WHERE `name`='xiaoming' AND pwd=MD5('123456')

事务


什么是事务

要么都成功,要么都失败

  1. -----------------------------------------
  2. 1、SQL执行 AB 转账 A 1000--> 200 B 200
  3. 2、SQL执行 B收到A的钱 A 800 --> B 400
  4. -----------------------------------------

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

事务原则:ACID原则 原子性,一致性,隔离性,持久性      (脏读,幻读......)

原子性(Atomicity)

要么都成功,要么都失败

一致性(Consistency)

事务前后的数据完整性要保证一致

持久性(Durability)

事务一旦一脚则不可逆,被持久化到数据库中

隔离性(Isolation

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

隔离所导致的一些问题

脏读:

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

不可重复读:

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

虚读(幻读):

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

执行事务

MySQL默认开启事务自动提交

  1. --事务
  2. --MySQL默认开启事务自动提交
  3. SET autocommit = 0 /* 关闭 */
  4. SET autocommit = 1 /* 开启(默认) */
  5. --手动处理事务
  6. SET autocommit = 0 -- 关闭自动提交
  7. --事务开启
  8. START TRANSACTION -- 标记一个事务的开始,从这个之后的SQL都在同一个事务内
  9. INSERT XX
  10. INSERT XX
  11. -- 提交:持久化(成功)
  12. COMMIT
  13. --回滚: 回到原来的样子(失败)
  14. ROLLBACK
  15. --事务结束
  16. SET autocommit = 1 -- 开启自动提交
  17. --了解
  18. SAVEPOINT 保存点名称 --设置一个事务的保存点
  19. ROLLBACK TO SAVEPOINT 保存点名称 -- 回滚到保存点
  20. RELEASE SAVEPOINT 保存点名称 -- 撤销保存点

模拟场景

  1. --转账
  2. CREATE DATABASE shop CHARACTER SET utf8 COLLATE utf8_general_ci
  3. USE shop
  4. CREATE TABLE `account`(
  5. `id` INT(3) NOT NULL AUTO_INCREMENT,
  6. `name` VARCHAR(30) NOT NULL,
  7. `money` DECIMAL(9,2) NOT NULL,
  8. PRIMARY KEY(`id`)
  9. )ENGINE=INNODB DEFAULT CHARSET=utf8
  10. INSERT INTO `account`(`name`,`money`)
  11. VALUES('A',2000.00),('B',10000.00)
  12. -- 模拟转账:事务
  13. SET autocommit = 0; -- 关闭自动提交
  14. START TRANSACTION -- 开启一个事务
  15. UPDATE account SET money=money-500 WHERE `name`='A' -- A减500
  16. UPDATE account SET money=money+500 WHERE `name`='B' -- B加500
  17. COMMIT; -- 提交事务
  18. ROLLBACK; -- 回滚
  19. SET autocommit = 1; -- 自动提交

索引


 MySQL官方对索引的定义为:索引(Index)是帮助MySQL高效获取数据的数据结构。

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

索引的分类

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

  • 主键索引 (PRIMARY KEY)
    • 唯一的标识,主键不可重复,只能有一个列作为主键
  • 唯一索引 (UNIQUE KEY)
    • 避免重复的列出现,唯一索引可以重复,多个列都可以标识位 唯一索引
  • 常规索引 (KEY/INDEX)
    • 默认的,INDEX或者KEY关键字来设置
  • 全文索引 (Full Text)
    • 在特定的数据库引擎下才有,MYISAM
    • 快速定位数据
  1. --索引的使用
  2. --1、在创建表的时候给字段增加索引
  3. --2、创建完毕后,增加索引
  4. --显示所有的索引信息
  5. SHOW INDEX FROM
  6. --增加一个全文索引
  7. ALTER TABLEADD FULLTEXT INDEX 索引名(字段名);
  8. -- EXPLAIN 分析SQL语句执行的状况
  9. EXPLAIN SQL语句; -- 非全文索引
  10. EXPLAIN SELECT * FROMWHERE MATCH(字段) AGAINST(''); -- 全文索引

测试索引

  1. -- 插入100万条数据
  2. DELIMITER $$ -- 写函数之前必须写 当作标志
  3. CREATE FUNCATION 函数名()
  4. RETURN INT
  5. BEGIN
  6. DECLARE num INT DEFAULT 1000000;
  7. DECLARE I INT DEFAULT 0;
  8. WHERE i<num DO
  9. -- 插入语句
  10. set i = i+1;
  11. END WHILE;
  12. RETURN i;
  13. END;
  14. SELECT 函数();
  15. --第三种 创建索引
  16. --CREATE INDEX 索引名 ON 表(字段)

索引在小数据量的时候,影响不大,但是在大数据的时候,区别十分明显

索引原则

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

索引的数据结构

Hash类型的索引

Btree:InnoDB默认的数据结构

权限管理和备份


用户管理

用户表:mysql.user

本质:修改用户表

  1. --创建用户
  2. CRAETE USER 用户名 IDENTIFIED BY 密码
  3. --修改密码(当前用户)
  4. SET PASSWORD = PASSWORD(密码)
  5. --修改密码(指定用户)
  6. SET PASSWORD FOR 用户 = PASSWORD(密码)
  7. --重命名 修改用户名字
  8. RENAME USER 用户名 TO 新用户名
  9. --用户授权 全部的权限(除了给别人授权)
  10. GRANT ALL PRIVILEGES ON *.*
  11. --查询权限
  12. SHOW GRANTS FOR 用户名 --查看指定用户的权限
  13. --ROOT用户权限:GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' WITH GRANT OPTION
  14. --撤销权限 REVOKE 哪些权限 在哪个库撤销 给谁撤销
  15. REVOKE 权限 ONFROM 用户
  16. --删除用户
  17. DROP USER 用户

MySQL备份

为什么要备份:

  • 保证重要的数据不丢失
  • 数据转移

MySQL数据库备份方式:

  • 直接拷贝物理文件
  • 在可视化工具种手动导出
  • 使用命令行导出 mysqldump  命令行使用
      1. #mysqldump -h 主机 -u 用户名 -p 密码 数据库 表名 >物理磁盘位置/文件名
      2. mysqldump -hlocalhost -uroot -p123456 database table1 table2... >X:/XXX.sql

导入数据库:

  1. #导入
  2. #登录的情况下 切换到指定的数据库
  3. #source 备份文件
  4. source X:/XXX.sql
  5. 或者
  6. mysql -u用户名 -p密码 库名< 备份文件

假设你要备份数据库,防止数据丢失。

规范数据库设计


为什么需要设计

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

糟糕的数据库设计:

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

良好的数据库设计:

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

软件开发中,数据库设计

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

设计数据库的步骤:(例:个人博客网站)

  • 收集信息,分析需求
    • 用户表(用户登录注销,用户的个人i西南西,写博客,创建分类)
    • 分类表(文章分类,创建者)
    • 文章表(文章信息)
    • 友情链接表(友情链接信息)
  • 标识实体类(把需求落到每个字段上)
  • 标识实体之间的关系

三大范式

为社么需要规范化

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

三大范式

第一范式(1NF)

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

第二范式(2NF)

前提:满足第一范式

每张表只描述一件事情

第三范式(3NF)

前提:满足第一范式、第二范式

确保主键与数据直接相关

规范数据库的设计

规范性 和 性能的问题

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

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

JDBC


数据库驱动

程序会通过数据库驱动和数据库交互

JDBC

SUN公司为了简化开发人员的(对数据库的)操作,提供了一个规范JDBC

第一个JDBC程序

创建测试数据库

  1. CREATE BATABASE jdbcStudy CHARACTER SET utf8 COLLATE utf8_general_ci;
  2. USE jdbcStudy;
  3. CREATE TABLE users(
  4. id INT PRIMARY KEY,
  5. NAME VARCHAR(40),
  6. PASSWORD VARCHAR(40),
  7. email VARCHAR(60),
  8. birthday DATE
  9. );
  10. INSERT INTO users(id,NAME,PASSWORD,email,birthday)
  11. VALUES(1,'zhangsan','123456','zs@sina.com','2222-02-02'),
  12. (2,'lisi','123456','ls@sina.com','2222-02-03'),
  13. (3,'wangwu','123456','ww@sina.com','2222-02-04');

1、创建一个数据库项目

2、导入数据库驱动

3、编写测试代码

  1. package com.hzx.lesson01;
  2. import java.sql.Connection;
  3. import java.sql.DriverManager;
  4. import java.sql.ResultSet;
  5. import java.sql.SQLException;
  6. import java.sql.Statement;
  7. // 我的第一个JDBC程序
  8. public class JdbcFirstDemo {
  9. public static void main(String[] args) throws ClassNotFoundException, SQLException {
  10. //1.加载驱动
  11. Class.forName("com.mysql.jdbc.Driver"); //固定写法 加载驱动
  12. //2.用户信息和url
  13. String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true";
  14. String username = "root";
  15. String password = "123456";
  16. //3.连接成功 数据库对象
  17. Connection connection = DriverManager.getConnection(url,username,password);
  18. //4.执行SQL的对象
  19. Statement statement = connection.createStatement();
  20. //5.执行SQL的对象 去 执行SQL 可能存在结果 查看返回结果
  21. String sql = "SELECT * FROM users";
  22. ResultSet resultSet = statement.executeQuery(sql); //返回的结果集
  23. while(resultSet.next()) {
  24. System.out.println(resultSet.getObject("id"));
  25. System.out.println(resultSet.getObject("NAME"));
  26. System.out.println(resultSet.getObject("PASSWORD"));
  27. System.out.println(resultSet.getObject("email"));
  28. System.out.println(resultSet.getObject("birthday"));
  29. }
  30. //6.释放连接
  31. resultSet.close();
  32. statement.close();
  33. connection.close();
  34. }
  35. }

步骤总结:

  1. 加载驱动
  2. 连接数据库Driver Manager
  3. 获得执行SQL的对象Statement
  4. 获得返回的结果集
  5. 释放连接

DriverManager

  1. //DriverManager.registerDriver(new com.mysql.jdbc.Driver());
  2. Class.forName("com.mysql.jdbc.Driver"); //固定写法 加载驱动
  3. //不建议使用上面一种 看源码 com.mysql.jdbc.Driver执行的就是上面的那种操作
  4. Connection connection = DriverManager.getConnection(url,username,password);
  5. //Connection代表数据库
  6. //数据库设置自动提交
  7. //事务提交
  8. //事务回滚
  9. connection.setAutoCommit();
  10. connection.commit();
  11. connection.rollback();

URL

  1. String url = "jdbc:mysql://localhost:3306/jdbcstudy?
  2. useUnicode=true&characterEncoding=utf8&useSSL=true";
  3. //MySQL默认端口3306
  4. //jdbc:mysql://主机地址:端口号/数据库名?参数1&参数2&参数3
  5. //oralce默认端口1521
  6. //jdbc:oracle:thin:@localhost:1521:sid

Statement    执行SQL的对象

  1. Statement statement = connection.createStatement();
  2. String sql = ""; //编写SQL
  3. statement.executeQuery(sql);//查询操作返回结果集
  4. statement.execute(sql);//执行任何SQL效率低一点
  5. statement.executeUpdate(sql);//更新、插入、删除 都用这个 返回一个受影响的行数
  6. statement.executeBatch(sql); //批处理

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

获取指定的结果类型

  1. ResultSet resultSet = statement.executeQuery(sql); //返回的结果集
  2. resultSet.getObject(); //在不知道列类型的情况下使用
  3. //如果知道列的类型就使用指定的类型
  4. resultSet.getString();
  5. resultSet.getInt();
  6. ......

遍历,指针

  1. resultSet.beforeFirst();// 移动到最前面
  2. resultSet.afterLast();// 移动到最后面
  3. resultSet.next(); // 移动到下一个数据
  4. resultSet.previous(); // 移动到下一行
  5. resultSet.absolute(row); //移动到指定行

释放资源

  1. //6.释放连接
  2. resultSet.close();
  3. statement.close();
  4. connection.close();// 耗资源 用完关掉

statement对象

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

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

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

CRUD操作-create

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

  1. Statement st = conn.createStatement();
  2. String sql = "insert into user(...) values(...)";
  3. int num = st.executeUpdate(sql);
  4. if(num>0) {
  5. System.out.println("插入成功!!!");
  6. }

CRUD操作-delete

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

  1. Statement st = conn.createStatement();
  2. String sql = "delete from user where id = 1";
  3. int num = st.executeUpdate(sql);
  4. if(num>0) {
  5. System.out.println("删除成功!!!");
  6. }

CRUD操作-update

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

  1. Statement st = conn.createStatement();
  2. String sql = "update user set name ='' where name = ''";
  3. int num = st.executeUpdate(sql);
  4. if(num>0) {
  5. System.out.println("修改成功!!!");
  6. }

CRUD操作-read

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

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

代码实现

提取工具类

  1. package com.hzx.lesson02.utils;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.sql.Connection;
  5. import java.sql.DriverManager;
  6. import java.sql.ResultSet;
  7. import java.sql.SQLException;
  8. import java.sql.Statement;
  9. import java.util.Properties;
  10. public class JdbcUtils {
  11. private static String driver = null;
  12. private static String url = null;
  13. private static String username = null;
  14. private static String password = null;
  15. static {
  16. try {
  17. InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
  18. Properties properties = new Properties();
  19. properties.load(in);
  20. driver = properties.getProperty("driver");
  21. url = properties.getProperty("url");
  22. username = properties.getProperty("username");
  23. password = properties.getProperty("password");
  24. //1、驱动只用加载一次
  25. Class.forName(driver);
  26. }catch(Exception e){
  27. e.printStackTrace();
  28. }
  29. }
  30. //获取连接
  31. public static Connection getConnection() throws SQLException {
  32. return DriverManager.getConnection(url,username,password);
  33. }
  34. //释放连接资源
  35. public static void release(Connection connection,Statement statement,ResultSet resultSet) {
  36. if(resultSet!=null) {
  37. try {
  38. resultSet.close();
  39. } catch (SQLException e) {
  40. // TODO Auto-generated catch block
  41. e.printStackTrace();
  42. }
  43. }
  44. if(statement!=null) {
  45. try {
  46. statement.close();
  47. } catch (SQLException e) {
  48. // TODO Auto-generated catch block
  49. e.printStackTrace();
  50. }
  51. }
  52. if(connection!=null) {
  53. try {
  54. connection.close();
  55. } catch (SQLException e) {
  56. // TODO Auto-generated catch block
  57. e.printStackTrace();
  58. }
  59. }
  60. }
  61. }
  62. =========================db.properties===================================
  63. driver = com.mysql.jdbc.Driver
  64. url = jdbc:mysql://localhost:3306/user?useUnicode=true&characterEncoding=utf8&useSSL=true
  65. username = root
  66. password = 123456

SQL注入的问题

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

PrepareStatement对象

PreparedStatement可以防止SQL注入,效率更高

PreparedStatement 防止SQL注入的本质:把传递进来的参数当作字符 假设其中存在转义字符,比如说 "" 会被直接传义

Jdbc操作事务

要么都成功 要么都失败

ACID原则

原子性:要么全部完成 要么都不完成

一致性:总数不变

隔离性:多个进程互不干扰

持久性:一旦提交不可逆,持久化到数据库

隔离性分问题:

脏读:一个事务读取了另一个没有提交的事务

不可重复读:在同一个事务内,重复读取表中的数据,表数据发生改变

虚读(幻读):在一个事务内,读取到了别人插入的数据,导致前后读出来的数据不一致

代码实现

  1. 开启事务 conn.setAutoCommit(false);
  2. 一组业务执行完毕,提交事务
  3. 可以在catch语句中显示的定义回滚语句,但默认失败就会回滚

数据库连接池

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

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

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

常用连接数来设计最小连接数

最小连接数:100

最大连接数:业务最高承载上限

超过最大连接数,排队等待

等待超时

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

开源数据源实现

DBCP

C3P0

Druid:阿里巴巴

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

DBCP

需要用到的jar包

commons-dbcp-x.x、commons-pool-x.x

  1. package com.hzx.lesson02.utils;
  2. import java.io.InputStream;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.ResultSet;
  6. import java.sql.SQLException;
  7. import java.sql.Statement;
  8. import java.util.Properties;
  9. import javax.sql.DataSource;
  10. import org.apache.commons.dbcp.BasicDataSource;
  11. import org.apache.commons.dbcp.BasicDataSourceFactory;
  12. public class JdbcUtils_DBCP {
  13. private static DataSource dataSource = null;
  14. static {
  15. try {
  16. InputStream in = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
  17. Properties properties = new Properties();
  18. properties.load(in);
  19. //创建数据源 工厂模式-->创建
  20. dataSource = BasicDataSourceFactory.createDataSource(properties);
  21. }catch(Exception e){
  22. e.printStackTrace();
  23. }
  24. }
  25. //获取连接
  26. public static Connection getConnection() throws SQLException {
  27. return dataSource.getConnection();
  28. }
  29. //释放资源
  30. public static void release(Connection connection,Statement statement,ResultSet resultSet) {
  31. if(resultSet!=null) {
  32. try {
  33. resultSet.close();
  34. } catch (SQLException e) {
  35. // TODO Auto-generated catch block
  36. e.printStackTrace();
  37. }
  38. }
  39. if(statement!=null) {
  40. try {
  41. statement.close();
  42. } catch (SQLException e) {
  43. // TODO Auto-generated catch block
  44. e.printStackTrace();
  45. }
  46. }
  47. if(connection!=null) {
  48. try {
  49. connection.close();
  50. } catch (SQLException e) {
  51. // TODO Auto-generated catch block
  52. e.printStackTrace();
  53. }
  54. }
  55. }
  56. }
  57. ==============================dbpcconfig.properties==================================
  58. #连接设置 这里的名字 是DBCP数据源中定义好的
  59. driverClassName = com.mysql.jdbc.Driver
  60. url = jdbc:mysql://localhost:3306/user?useUnicode=true&characterEncoding=utf8&useSSL=true
  61. username = root
  62. password = 123456
  63. #初始化连接
  64. initialSize=10
  65. #最大连接数量
  66. maxActive=50
  67. #最大空闲连接
  68. maxIdle=20
  69. #最小空闲连接
  70. minIdle=5
  71. #超时等待时间以毫秒为单位60000毫秒/1000等于60毫秒
  72. maxWait=60000
  73. #JDBC驱动建立连接时附带的连接属性属性的格式必须为这样:[属性名=property;]
  74. #注意:"user"与"password"两个属性会被明确地传递 因此这里不需要包含他们
  75. connectionProperties=useUnicode=true;characterEncoding=UTF8
  76. #指定由连接池所创建的连接的自动提交(auto-commit)状态
  77. defaultAutoCommit=true
  78. #driver default 指定由连接池所创建的连接的只读(read-only)状态
  79. #如果没有设置该值,则"setReadOnly"方法将不被调用(某些驱动并不支持只读模式,如:Informix)
  80. defaultReadOnly=

C3P0

需要用到的jar包

c3p0-x.x.x.x.jar  mchange-commons-java-x.x.jar

  1. package com.hzx.lesson02.utils;
  2. import java.io.InputStream;
  3. import java.sql.Connection;
  4. import java.sql.ResultSet;
  5. import java.sql.SQLException;
  6. import java.sql.Statement;
  7. import java.util.Properties;
  8. import javax.sql.DataSource;
  9. import org.apache.commons.dbcp.BasicDataSourceFactory;
  10. import com.mchange.v2.c3p0.ComboPooledDataSource;
  11. public class JdbcUtils_C3P0 {
  12. private static DataSource dataSource = null;
  13. static {
  14. try {
  15. dataSource = new ComboPooledDataSource("c3p0"); // 配置文件写法
  16. }catch(Exception e){
  17. e.printStackTrace();
  18. }
  19. }
  20. //获取连接
  21. public static Connection getConnection() throws SQLException {
  22. return dataSource.getConnection();
  23. }
  24. //释放资源
  25. public static void release(Connection connection,Statement statement,ResultSet resultSet) {
  26. if(resultSet!=null) {
  27. try {
  28. resultSet.close();
  29. } catch (SQLException e) {
  30. // TODO Auto-generated catch block
  31. e.printStackTrace();
  32. }
  33. }
  34. if(statement!=null) {
  35. try {
  36. statement.close();
  37. } catch (SQLException e) {
  38. // TODO Auto-generated catch block
  39. e.printStackTrace();
  40. }
  41. }
  42. if(connection!=null) {
  43. try {
  44. connection.close();
  45. } catch (SQLException e) {
  46. // TODO Auto-generated catch block
  47. e.printStackTrace();
  48. }
  49. }
  50. }
  51. }
  52. ==================================c3p0config.xml=======================================
  53. <?xml version="1.0" encoding="UTF-8"?>
  54. <c3p0-config>
  55. <!-- 默认配置 -->
  56. <default-config>
  57. <!-- 连接参数 -->
  58. <property name="driverClass">com.mysql.jdbc.Driver</property>
  59. <property name="jdbcUrl">jdbc:mysql://localhost:3306/users</property>
  60. <property name="user">root</property>
  61. <property name="password">123456</property>
  62. <!-- 连接池参数 -->
  63. <!-- 初始化申请的连接数量 -->
  64. <property name="initialPoolSize">5</property>
  65. <!-- 最大的连接数量 -->
  66. <property name="maxPoolSize">10</property>
  67. <!-- 超时时间 -->
  68. <property name="checkoutTimeout">30000</property>
  69. </default-config>
  70. <!--c3p0配置1-->
  71. <named-config name="c3p0">
  72. <!-- 连接参数 -->
  73. <property name="driverClass">com.mysql.jdbc.Driver</property>
  74. <property name="jdbcUrl">jdbc:mysql://localhost:3306/users</property>
  75. <property name="user">root</property>
  76. <property name="password">123456</property>
  77. <!-- 连接池参数 -->
  78. <property name="initialPoolSize">5</property>
  79. <property name="maxPoolSize">10</property>
  80. <property name="checkoutTimeout">30000</property>
  81. </named-config>
  82. </c3p0-config>

结论

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

 

学习Java关注狂神说Java

推荐阅读