一、数据库介绍

1.1 数据记录的流程

  1. 标记
  2. 用纸张记录
  3. 为了方便存储，提出用计算机硬盘存储
  4. 数据库存储

1.2 数据库的历史流程

  1. 层级模型
  2. 网状模型
  3. 关系模型（将世界全部看成对象及对象的联系组成）
  4. 关系-对象模型

1.3 关系模型（重点）

  1. 概念：将世界上所有的事物都可以抽取成单个实体，将实体与实体进行联系，称为关系型数据。
  2. 实体：用一些关键字对它进行描述，一般关系型数据都是用一张二维表进行表示
  3. 图示：

Mysql数据库 - 图1

解释：

1）在一张二维表中，每行都代表是个独立的实体

2）在一张二维表中，每一列称为字段，字段的作用是用来描述实体的。

3）如果有关联的实体，可以新增一个字段，用来关联上另外一张表中的实体，也称为主外键关联

1.4 安装数据库

  1. 下载好数据库：https://dev.mysql.com/downloads/mysql/
  2. 下载好之后，放到硬盘中然后解压。
  3. 对数据库继续配置环境变量
  4. 在数据库的目录下，新建一个my.ini文件，并设置以下的内容
  1. [mysql]
  2. # 设置数据库的默认全局编码集
  3. default-character-set=utf8
  4. [mysqld]
  5. # 设置数据库的端口
  6. port=3306
  7. # 设置数据库的文件夹(根据自己的文件进行修改)
  8. basedir=D:\mysql\mysql-8.0.22-winx64
  9. # 设置数据库中实际数据存储的文件夹（该文件夹用来存储数据的）(根据自己的文件进行修改)
  10. datadir=D:\mysql\mysql-8.0.22-winx64\data
  11. # 设置数据库的最大链接数
  12. max_connections=20
  13. # 设置服务端的编码
  14. character-set-server=utf8
  15. # 数据库的存储引擎设置
  16. default-storage-engine=INNODB

  1. 安装数据库，在数据库的bin目录，然后进入cmd命令行，在命令上输入：mysqld -install

  2. 生成初始的data文件夹及初始的登录密码
    输入命令：mysqld —initialize —console

  3. 启动MySQL的服务，使用命令：net start mysql

  4. 使用登录名实现数据库的登录，使用命令：mysql -uroot -p2o-(llVL/Kem

  5. 使用之前的旧密码，修改一个新的密码，
    使用：ALTER USER ‘root’@’localhost’ IDENTIFIED WITH mysql_native_password BY ‘root’;

二、数据库的使用

2.1 数据库的基本命令

  1. 安装数据库的命令：mysqld -install

  2. 初始化数据库并获取初始密码，并将其输出在控制台上：mysqld —initialize —console

  3. 卸载数据库的命名：mysqld -remove

  4. 登录数据库：mysql -uroot -p密码
    登录数据库的完整命名：mysql -u用户名 -h主机名或者ip地址 -P端口 -p密码

  5. 开启数据库服务：net start mysql

  6. 关闭数据库服务：net stop mysql

  7. 查看数据库管理系统中有多少数据库：show databases;

  8. 使用到指定的数据库，使用命令：use 数据库名;

  9. 查看所有数据库中有多少表：show tables;

  10. 推出数据库：exit;

2.2 结构化查询语句（SQL）

  1. DDL：数据定义语言，用于创建数据库，删除数据库，创建表结构，删除表结构和修改表结构
  2. DML：数据操作语言，用于数据库增、删、改
  3. DQL：数据查询语言，用于数据库的查询操作，简单查询、条件查询、模糊查询、子查询、连接查询、联合查询
  4. DCL：数据控制语言，用于控制数据库用户的权限，给用户权限和取消用户权限

2.3 SQL和Mysql

  1. SQL称为结构化查询语句，SQL的作用主要是定义规则，不存在实际的产物，停留在理论的阶段
  2. MySql称为数据库管理系统，可以提供给用户使用的管理系统，一般数据库管理系统分为两个端口：客户端和服务端
  3. Mysql的结构图：

Mysql数据库 - 图2

三 数据定义语言DDL

3.1 数据库操作

  1. 创建数据库
  1. -- 创建数据库，名字叫db_woniu,使用命令：create database 数据库名称;
  2. create database db_woniu;
  3. -- 一般在创建数据库的时候，需要指定数据库的编码集
  4. create database db_school charset=utf8;
  1. 删除数据库(慎用)
  1. -- 从数据库管理系统中删除指定的数据库命令：drop database 数据库名;
  2. drop database db_woniu;

3.2 数据表操作

  1. 创建数据表
  1. -- 创建数据表
  2. 使用命令：
  3. create table 表名(
  4.     字段名 数据类型,
  5.     字段名 数据类型,
  6.     字段名 数据类型
  7. );
  8. 举例：创建学生表t_student
  9. create table t_student(
  10.     student_id int,
  11.     student_name varchar(30),
  12.     age int,
  13.     sex char,
  14.     address varchar(30)
  15. );
  1. 删除表
  1. -- 删除指定的表
  2. drop table 表名;
  3. -- 比如：
  4. drop table t_student;
  1. 复制表（只复制结构不复制数据）
  1. -- 复制一张新的表
  2. create table 新表名 like 原表;
  1. 复制一张表（复制结构和数据）
  1. create table 新表名 as (select * from 原表);
  1. 向已经存在的表中新增一个字段
  1. alter table 表名 add column 字段名 数据类型;
  2. 比如：
  3. alter table t_student add column height int;
  1. 向已经存在字段修改其字段对应的数据类型
  1. alter table 表名 modify 字段名称 新数据类型;比如：alter table t_student modify height double;

四、数据操作语言（重点）

  1. 新增数据
  1. -- 向指定表中新增数据（新增指的是新增实体）命令语法：insert into 表名(字段) value(字段对应的值);
  2. -- 新增全部字段
  3. insert into t_student(student_id,student_name,age,sex,address,height) value(1,"张三",18,"男","重庆",180);
  4. -- 如果是新增全部字段，则表名括号里面的内容可以省略
  5. insert into t_student value(2,"李四",19,"男","成都",170);
  6. -- 新增的时候，只有部分字段有数据，表明后面的字段名必须写明，并且value的个数和表名后面的字段个数一致
  7. insert into t_student(student_id,student_name) value(3,"王五");
  8. -- values关键字
  9. insert into t_student(student_id,student_name) values(5,"李雷"),(6,"李华"),(7,"小白");
  1. 修改数据
  1. -- 修改语法：update 表名 set 字段 = 值 where 修改的条件;
  2. -- 可以将已经存在的数据进行修改,下面的命令会导致该中age字段的值都修改成20，一般不采用
  3. update t_student set age = 20;
  4. -- 条件修改
  5. update t_student set age = 25 where student_id = 7;
  1. 删除数据
  1. -- 删除命令：
  2. delete from t_student where student_id = 7;
  3. -- 删除整张表的数据
  4. delete from t_student;
  5. -- 根据条件删除
  6. delete from t_student where student_id = 7;

五、数据库数据类型

  1. 整型
  1. 1、tinyint 最小的整型（迷你整型）
  2. 2、smallint  短整型
  3. 3、middleint 中等整型
  4. 4、int  整型（一般都用int）
  5. 5、long  长整型
  1. 浮点型
  1. 1、float 单精度浮点型  保留7位小数，最后一位不保证正确
  2. 2、double 双精度浮点型  保留15位小数，最后以为不保证正确
  3. 3、decimal(M,D) 定点小数
  1. 字符
  1. 1、char 定长字符
  2. 2、varchar 变长字符 
  3. 两者的区别（重点）：
  4. 定长字符char,如果字段使用char类型，那么内存空间直接给255个内存大小，优点：存储速度快，缺点：会造成一定的空间浪费
  5. 变长字符varchar,如果字段使用varchar，那么数据库会先根据实际存入数据的字符个数进行计算，根据计算的空间大小开辟相应的内存大小，优点：节约内存空间，缺点：数据库操作两次，存储效率相对较低。
  6. 特别说明：varchar使用的时候，需要给定varchar(8),括号里面的值只是设置最大的长度
  1. 时间
  1. 1、date  时间，包括了年月日，时分秒
  2. 2、year  年份
  3. 3、datetime  瞬时时间,包括年月日  时分秒
  1. 二进制（了解）
  1. 1、BOLB
  1. 文本
  1. 1、text 文本数据类型

六、数据库设计

6.1 数据库的健

  1. 唯一键：在一张表中，可以用来识别唯一的一个实体（一行）的字段，比如：学号、身份证号、电话号码
  2. 主键：从唯一键中选出其中的字段作为主键，如果该字段设置为了主键，数据库会自动的判断，在新增数据的时候，不能出现重复的数据，可一般是一个字段，也肯能是组合主键
  3. 候选键：从唯一键中去掉主键字段，剩下的唯一字段都是候选键
  4. 外键：作用是将各个实体之间产生联系，一张表中的外键，是另外一张表中的主键数据，主外键关联

6.2 数据库相关约束

  1. 主键约束：主键的作用是为了保证每一行都是唯一的，因此被设置为主键的字段要求不能出现重复的数据，可以自动递增
  2. 外键约束：一个表中的外键是另外一张表中的主键，要求被设置为外键的数据必须是对应另外一张表主键中已经存在的数据，如果外键中已经使用了主键中的数据，那么主键中的该行数据不能删除。
  3. 非空约束：如果该字段设置为了非空约束，那么该字段必须给值，不能空着
  4. 默认值：当在新增数据的时候，如果没有给值，则直接使用默认值，如果已经给值了，则使用给定的值

6.3 数据库范式

  1. 第一范式：要求保证列的原子性，一张表中，每一个字段只能代表一个实体的属性，只要是关系型数据库，一定满足第一范式
  2. 第二范式：要求保证在表中每一个实体能够被唯一区分，实现第二范式的方式可以是设置主键。
  3. 第三范式：要求普通属性字段必须和主键直接相关而不是间接相关

6.4 表与表之间的关系

  1. 一对一的关系：一张表中一个实体的数据唯一对应另外一张表中的一个实体数据
    图示：
    Mysql数据库 - 图3

  2. 一对多的关系：一张表中的一个实体数据对应另外一张表中多个实体数据
    图示：
    Mysql数据库 - 图4

  3. 多对多的关系：一张表中的一个实体数据对应另外一张表中多个实体数据，反过来，另外一张表中一个实体数据也能对应第一张表中的多个实体数据。
    图示：
    Mysql数据库 - 图5

七、数据查询语言DQL

  1. 数据库脚本内容：
  1. /*
  2. Navicat MySQL Data Transfer
  4. Source Server         : localhost
  5. Source Server Version : 80022
  6. Source Host           : 127.0.0.1:3306
  7. Source Database       : db_school
  9. Target Server Type    : MYSQL
  10. Target Server Version : 80022
  11. File Encoding         : 65001
  13. Date: 2021-04-07 15:37:25
  14. */
  16. SET FOREIGN_KEY_CHECKS=0;
  18. -- ----------------------------
  19. -- Table structure for course
  20. -- ----------------------------
  21. DROP TABLE IF EXISTS `course`;
  22. CREATE TABLE `course` (
  23.   `c_id` varchar(20) NOT NULL,
  24.   `c_name` varchar(20) NOT NULL DEFAULT '',
  25.   `t_id` varchar(20) NOT NULL,
  26.   PRIMARY KEY (`c_id`)
  27. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  29. -- ----------------------------
  30. -- Records of course
  31. -- ----------------------------
  32. INSERT INTO `course` VALUES ('01', '语文', '02');
  33. INSERT INTO `course` VALUES ('02', '数学', '01');
  34. INSERT INTO `course` VALUES ('03', '英语', '03');
  36. -- ----------------------------
  37. -- Table structure for score
  38. -- ----------------------------
  39. DROP TABLE IF EXISTS `score`;
  40. CREATE TABLE `score` (
  41.   `s_id` varchar(20) NOT NULL,
  42.   `c_id` varchar(20) NOT NULL,
  43.   `s_score` int DEFAULT NULL,
  44.   PRIMARY KEY (`s_id`,`c_id`)
  45. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  47. -- ----------------------------
  48. -- Records of score
  49. -- ----------------------------
  50. INSERT INTO `score` VALUES ('01', '01', '80');
  51. INSERT INTO `score` VALUES ('01', '02', '90');
  52. INSERT INTO `score` VALUES ('01', '03', '99');
  53. INSERT INTO `score` VALUES ('02', '01', '70');
  54. INSERT INTO `score` VALUES ('02', '02', '60');
  55. INSERT INTO `score` VALUES ('02', '03', '80');
  56. INSERT INTO `score` VALUES ('03', '01', '80');
  57. INSERT INTO `score` VALUES ('03', '02', '80');
  58. INSERT INTO `score` VALUES ('03', '03', '80');
  59. INSERT INTO `score` VALUES ('04', '01', '50');
  60. INSERT INTO `score` VALUES ('04', '02', '30');
  61. INSERT INTO `score` VALUES ('04', '03', '20');
  62. INSERT INTO `score` VALUES ('05', '01', '76');
  63. INSERT INTO `score` VALUES ('05', '02', '87');
  64. INSERT INTO `score` VALUES ('06', '01', '31');
  65. INSERT INTO `score` VALUES ('06', '03', '34');
  66. INSERT INTO `score` VALUES ('07', '02', '89');
  67. INSERT INTO `score` VALUES ('07', '03', '98');
  69. -- ----------------------------
  70. -- Table structure for student
  71. -- ----------------------------
  72. DROP TABLE IF EXISTS `student`;
  73. CREATE TABLE `student` (
  74.   `s_id` varchar(20) NOT NULL,
  75.   `s_name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT '',
  76.   `s_birth` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT '',
  77.   `s_sex` varchar(10) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT '',
  78.   `age` int DEFAULT NULL,
  79.   `height` int DEFAULT NULL,
  80.   PRIMARY KEY (`s_id`)
  81. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  83. -- ----------------------------
  84. -- Records of student
  85. -- ----------------------------
  86. INSERT INTO `student` VALUES ('01', '赵雷', '1990-01-01', '男', '23', '160');
  87. INSERT INTO `student` VALUES ('02', '钱电', '1990-12-21', '女', '26', '165');
  88. INSERT INTO `student` VALUES ('03', '孙风', '1990-05-20', '男', '20', '155');
  89. INSERT INTO `student` VALUES ('04', '李云', '1990-08-06', '保密', '19', '180');
  90. INSERT INTO `student` VALUES ('05', '周梅', '1991-12-01', '女', '22', '175');
  91. INSERT INTO `student` VALUES ('06', '吴兰', '1992-03-01', '女', '18', '167');
  92. INSERT INTO `student` VALUES ('07', '郑竹', '1989-07-01', '男', '24', '158');
  93. INSERT INTO `student` VALUES ('08', '王菊', '1990-01-20', '女', '25', '176');
  94. INSERT INTO `student` VALUES ('09', '李云龙', '1990-01-20', '男', '26', '163');
  96. -- ----------------------------
  97. -- Table structure for teacher
  98. -- ----------------------------
  99. DROP TABLE IF EXISTS `teacher`;
  100. CREATE TABLE `teacher` (
  101.   `t_id` varchar(20) NOT NULL,
  102.   `t_name` varchar(20) NOT NULL DEFAULT '',
  103.   PRIMARY KEY (`t_id`)
  104. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  106. -- ----------------------------
  107. -- Records of teacher
  108. -- ----------------------------
  109. INSERT INTO `teacher` VALUES ('01', '张三');
  110. INSERT INTO `teacher` VALUES ('02', '李四');
  111. INSERT INTO `teacher` VALUES ('03', '王五');

7.1 单表查询

  1. 简单查询
  1. -- 最简单的查询命令
  2. -- 命令语法：select 字段名称 from 表名;
  3. select * from student; (真实开发，禁止使用)
  4. -- 指定字段的查询命令
  5. select s_id,s_name,s_birth,s_sex,age,height from student;
  6. -- 如果只需要其中部分的字段数据，只用写有需要的字段名称即可
  7. select s_id,s_name from student;
  1. 条件查询
  1. -- 按照一些条件将符合要求的数据查询出来，命令语法：select 字段 from 表名 where 条件;
  2. -- 比如：查询学号为01的学生信息
  3. select s_id,s_name,s_birth,s_sex,age,height from student where s_id = "01";
  4. -- 比如：查询出所有的男学生
  5. select s_id,s_name,s_birth,s_sex,age,height from student where s_sex= "男";
  6. -- 比如：查询出性别不是男的学生
  7. select s_id,s_name,s_birth,s_sex,age,height from student where s_sex <> "男";
  8. -- 多个条件查询
  9. -- 比如：查询出身高低于160的男学生
  10. select s_id,s_name,s_birth,s_sex,age,height from student where height < 160 and s_sex = "男";
  11. -- 比如：查询出身高低于160或者男学生
  12. select s_id,s_name,s_birth,s_sex,age,height from student where height < 160 or s_sex = "男";
  13. -- 数值类型的范围查询
  14. -- 比如：查询出身高在165到175之间的学生，包含165和175
  15. select s_id,s_name,s_birth,s_sex,age,height from student where height >= 165 and height <= 175;
  16. select s_id,s_name,s_birth,s_sex,age,height from student where height between 165 and 175;
  17. select s_id,s_name,s_birth,s_sex,age,height from student where height < 165 or height > 175;
  1. 模糊查询
  1. -- 只知道其中数据的部分内容，其他数据内容随意匹配，命令语法：select 字段 from 表名 where 字段 like 条件
  2. -- 第一种占位符：下划线_   一个下划线代表占用一位字符
  3. -- 比如：查询出姓李的学生信息,只能查询出名字为两个字的学生信息
  4. select s_id,s_name,s_birth,s_sex,age,height from student where s_name like "李_";
  5. -- 第二种占位符：百分号%，如果在后面跟了%，可以同时匹配多个字符，%对个数没有要求
  6. -- 查询出姓李的所有学生信息
  7. select s_id,s_name,s_birth,s_sex,age,height from student where s_name like "%李%";
  1. 排序，在查询的结果中按照指定的字段数据进行排序，升序排列，降序排列
  1. -- 命令语法：select 字段 from 表名 order by 排序字段 排序规则(ASC/DESC)
  2. -- 比如：按照身高的升序排列
  3. select s_id,s_name,s_birth,s_sex,age,height from student order by height ASC;
  4. -- 比如：按照身高的降序排列
  5. select s_id,s_name,s_birth,s_sex,age,height from student order by height DESC;
  6. -- 比如:按照年龄的降序排列
  7. select s_id,s_name,s_birth,s_sex,age,height from student order by age DESC;
  8. -- 一条sql语句中，由两个排序规则
  9. -- 比如：按照年龄的降序排列，按照身高的升序排列
  10. select s_id,s_name,s_birth,s_sex,age,height from student order by age DESC, height DESC;
  1. 分组查询，在查询语句中，将某些字段为条件，分为一个组
  1. -- 命令语法：select 字段 from 表名 group by 分组字段;
  2. -- 在查询成绩表中的数据，按照学号分组
  3. select s_id,c_id,s_score from score group by s_id;
  4. -- 如果使用了分组查询，那么必须配合使用聚合函数
  5. -- count(字段):查询出该分组一共有多少条数据
  6. -- sum(字段):如果字段为数值，可以计算该分组中该字段的总和
  7. -- avg(字段):如果字段为数值，可以计算该分组中该字段的平均数值
  8. -- max(字段):如果字段为数值，可以找出该分组中该字段为最大值的数据
  9. -- min(字段):如果字段为数值，可以找出该分组中该字段为最小值的数据
  10. -- 1、举例：查询出每个学生学习的课程数
  11. select s_id 学号,count(c_id) 选课数 from score group by s_id;
  12. -- 2、举例：查询出每个学生的总成绩
  13. select s_id 学号,sum(s_score) 总成绩 from score group by s_id order by sum(s_score) desc;
  14. -- 3、举例：查询出每个学生的平均成绩
  15. select s_id 学号,avg(s_score) avg from score group by s_id order by avg desc;
  16. -- 4、举例：查询出每个学生的最高成绩
  17. select s_id 学号,max(s_score) 最高成绩 from score group by s_id;
  18. -- 5、举例：查询出每个学生的最低成绩
  19. select s_id 学号,min(s_score) 最低成绩 from score group by s_id;
  1. having关键字，在分组之后，可以将聚合函数作为条件进行筛选，查询出符合条件的结果集
  1. -- 语法：select 字段 from 表名 group by 分组字段 having 聚合函数作为条件筛选
  2. -- 举例：查询出平均成绩不及格的学生信息
  3. select s_id 学号,avg(s_score) avg from score group by s_id having avg < 60;select s_id from score where s_id = "01";
  4. -- where和having的区别：where:作为条件筛选，一般where后面条件跟普通字段作为条件判断having:作为条件筛选，一般having后面跟聚合函数作为条件判断，用having的前提是用了group by
  1. limit关键字，用于在结果集中筛选个数，一般用在分页
  1. -- 命令语法：select 字段 from 表名 limit 起始位置,显示个数;
  2. -- 比如：查询学生信息的前5个数据
  3. select s_id,s_name,s_birth,s_sex,age,height from student limit 2,5;
  1. 去重，在查询的时候，可以通过去重关键字（distinct）将一个字段中相同的数据去掉只留下第一个
  1. -- 命令语法：select distinct 字段 from 表名;
  2. -- 比如：查询出成绩表中有哪些学生
  3. select distinct s_idfrom score;
  1. 将所有的知识点融合成一条完整的sql查询语句
  1. select distinct 字段 from 表名 where 字段条件 group by 分组字段 having 聚合函数条件 order by 排序字段 排序规则 limit 起始位置,显示条数;
  2. 1、from:将数据库中数据加载到内存中
  3. 2、where:从内存中筛选出符合条件的数据
  4. 3、group by:如果查询语句中有分组，则按照字段进行分组，如果没有，将剩下的数据分为一个组
  5. 4、having:如果有聚合函数，执行聚合函数中的内容，如果还有having，则根据聚合函数的条件进行筛选
  6. 5、select:从内存中找到哪些字段的数据是需要显示的
  7. 6、distinct:根据去重的字段，将该字段中相同的数据去掉，只留第一个
  8. 7、order by:根据排序规则进行排序
  9. 8、limit:根据给定的起始位置和显示的条数，进行数据显示的筛选

7.2 子查询

  1. 简单子查询,作用：将一个查询的结果集再次作为条件或者作为新的表，再次查询
  1. -- 举例：查询姓名叫做李云的学生所有成绩
  2. -- 第一条查询语句
  3. select s_id from student where s_name = "李云";---->04
  4. -- 第二条查询语句
  5. select s_id,c_id,s_score from score where s_id = "04";
  6. -- 将上面的两条语句合并成一条查询语句
  7. select s_id,c_id,s_score from score where s_id = (select s_id from student where s_name = "李云");
  9. -- 举例：查询张三老师授课的所有成绩
  10. -- 第一条语句，根据老师姓名张三找出老师的id值
  11. select t_id from teacher where t_name = "张三"; --->01
  12. -- 第二条查询语句，根据老师的id号，查询出对应的课程id号
  13. select c_id from course where t_id = "01";--->02
  14. -- 第三条查询语句，根据课程号，在成绩表中找出对应的数据
  15. select s_id,c_id,s_score from score where c_id = "02";
  16. -- 将上面三条综合成一条子查询
  17. select s_id,c_id,s_score from score where c_id = (select c_id from course where t_id = (select t_id from teacher where t_name = "张三"));
  19. -- 将上面的查询语句写成以下形式：
  20. select s_id,c_id,s_score from score where c_id = (select c_id,c_name,t_id from course where t_id = (select t_name,t_id from teacher where t_name = "张三"));----会报错。
  22. -- 完成子查询的命令语法：
  23. select 字段 from 表名 where 条件字段 = (select 子查询字段 from 表名 where 条件判断);
  24. 要求：子查询字段只能有一个，并且条件字段和子查询字段应该是主外键关联的字段
  1. in子查询
  1. -- 子查询举例：查询出姓李的学生的所有成绩
  2. -- 第一条查询语句,查询出姓李的学生学号
  3. select s_id from student where s_name like "李%";--->04,09
  4. -- 第二条查询语句，查询出学号对应的成绩
  5. select s_id,c_id,s_score from score where s_id = "04，09";
  6. -- 将上面的两句合并成一句子查询
  7. select s_id,c_id,s_score from score where s_id = (select s_id from student where s_name like "李%");
  9. -- 特别注意：如果子查询用的是=判断，那么要求子查询语句的结果集只能是一行一列的数据，如果子查询语句结果集存在一列多行的数据，用=要报错（Subquery returns more than 1 row）
  10. -- 如果子查询结果集存在一列多行的结果，只能使用in子查询
  11. -- in的命令语法：select 字段 from 表名 where 条件判断 in (值1，值2，值3，值4...值n);
  13. -- 将上面的例子进行改造
  14. select s_id,c_id,s_score from score where s_id in (select s_id from student where s_name like "李%");
  16. -- not in,不在子查询结果集里面的其他数据
  17. select s_id,c_id,s_score from score where s_id not in (select s_id from student where s_name like "李%");
  1. exists子查询，表示是否存在结果集
  1. select s_id,s_name s_sex,age,height from student where exists (select t_id,t_name from teacher where t_name = "小明");
  3. -- 命令语法：select 字段 from 表名 where exists (select 子查询字段 from 表名 where 条件判断);
  4. -- exists的作用：当子查询结果集中有数据，则正常的执行主查询语句，如果子查询语句没有结果集，主查询不执行
  1. any和all子查询
  1. -- any子查询命令语法：select 字段 from 表名 字段 > any (select 字段 from where 条件判断);
  2. -- > any() 表示大于最小值
  3. -- < any() 表示小于最大值
  4. select s_id,c_id,s_score from score where s_score > any (select s_score from score where s_id = "02");
  5. select s_id,c_id,s_score from score where s_score < any (select s_score from score where s_id = "02");
  7. -- all子查询命令语法：select 字段 from 表名 字段 > all (select 字段 from where 条件判断);
  8. -- > all() 表示大于最大值
  9. -- < all() 表示小于最小值
  10. select s_id,c_id,s_score from score where s_score > all (select s_score from score where s_id = "02");
  11. select s_id,c_id,s_score from score where s_score < all (select s_score from score where s_id = "02");

7.3 连接查询

  1. 自然连接(开发禁止使用)
  1. -- 将学生表和成绩表连接起来
  2. select s1.s_id,s_name,s_birth,s_sex,age,height,s2.s_id,c_id,s_score from student s1,score s2 where s1.s_id = s2.s_id;
  4. -- 命令语法：select 字段 from 表1，表2 where 主外键条件判断;
  1. 内连接（重点）
  1. -- 命令语法：select 字段 from 表1 inner join 表2 on 主外键条件;
  2. -- 将学生表和成绩表关联
  3. select s1.s_id,s_name,s_sex,s_birth,age,height,s2.s_id,c_id,s_score from student s1 inner join score s2 on s1.s_id = s2.s_id;
  4. -- 将学生表、成绩表和课程表关联
  5. select s1.s_id,s_name,s_sex,s_birth,age,height,s2.c_id,s_score,c_name,t_id from student s1 inner join score s2 on s1.s_id = s2.s_id inner join course c on s2.c_id = c.c_id;
  6. -- 将学生表、成绩表、课程表和教师表关联
  7. select s1.s_id,s_name,s_sex,s_birth,age,height,s2.c_id,s_score,c_name,c.t_id,t_name from student s1 inner join score s2 on s1.s_id = s2.s_id inner join course c on s2.c_id = c.c_id inner join teacher t on c.t_id = t.t_id;
  9. -- 举例：查询姓名叫做李云的学生所有成绩
  10. select s1.s_id,s_name,s_sex,s_birth,age,height,s2.s_id,c_id,s_score from student s1 join score s2 on s1.s_id = s2.s_id where s_name = "李云";
  1. 外连接（重点）
  1. -- 1、左外连接:以左边的表为准，如果左边表的数据较多，右边表没有数据，以null显示
  2. -- 命令语法：select 字段 from 表1 left join 表2 on 关联条件;
  3. -- 将学生表和成绩表进行左外连接关联，左边表为学生表
  4. select s1.s_id,s_name,s_sex,s_birth,age,s2.s_id,c_id,s_score from student s1 left join score s2 on s1.s_id = s2.s_id;
  6. -- 2、右外连接：以右边的表为准，如果右边的表较多，左边表没有数据，以null显示
  7. -- 命令语法：select 字段 from 表1 right join 表2 on 关联条件;

7.4 联合查询

  1. -- 将多个结果集整合成一张表结果
  2. -- 比如：查询所有老师和学生的编号和姓名
  3. select s_id as id,s_name as name from student union select t_id as id,t_name as name from teacher;
  4. -- union关键字会自动的将相同的数据去掉重复的，只留一个
  5. -- nuion all 关键字，全部展示，不会去重
  7. -- 比如：在上面的基础上，进行统计所有的师生个数
  8. select count(t1.id) from (select s_id as id,s_name as name from student union select t_id as id,t_name as name from teacher) as t1;
  10. -- 比如：查询出师生中有叫做张三的编号和姓名
  11. select t1.id,t1.name from (select s_id as id,s_name as name from student union select t_id as id,t_name as name from teacher) t1 where t1.name = "张三";

八、SQL查询练习

8.1 上半部分

  1. -- 1、查询出平均成绩大于60分的学号、姓名和平均成绩分析：最终结果集需要有：学号、姓名和平均成绩（聚合函数）,需要用到分组，对平均成绩进行判断
  2. select s1.s_id,s_name,avg(s_score) avg from student s1 join score s2 on s1.s_id = s2.s_id group by s1.s_id having avg > 60;
  3. -- 2、查询出平均成绩小于60分的学号、姓名和平均成绩，但是要包含没有成绩的学生分析：结果集在学生表和成绩表中，为了保留没有成绩的学生，用外连接，根据学号进行分组再计算平均成绩，筛选出平均成绩小于60分的学生信息
  4. select s1.s_id,s_name,avg(s_score) avg from student s1 left join score s2 on s1.s_id = s2.s_id group by s1.s_id having avg < 60 or avg is null;
  5. -- 3、查询出所有学生的学生编号、姓名、选课总数、每个学生的总成绩分析：结果集在学生表和成绩表中，将两张表连接，通过分组和聚合找到结果集
  6. select s1.s_id,s_name,count(c_id) 选课总数,sum(s_score) 总成绩 from student s1 join score s2 on s1.s_id = s2.s_id group by s1.s_id;
  7. -- 4、查询出学过张三老师课程的学生信息分析：已知条件：t_name="张三",结果集在学生表方式1：将四张表全部连接，在通过t_name进行筛选
  8. -- 方式1
  9. select s1.s_id,s_name,s_sex,s_birth,age,height from student s1 join score s2 on s1.s_id = s2.s_id join course c on s2.c_id = c.c_id join teacher t on c.t_id = t.t_id where t_name = "张三";
  10. -- 方式2：子查询
  11. -- sql1:
  12. select t_id from teacher where t_name = "张三";
  13. -- sql2:
  14. select c_id from course where t_id = ?;
  15. -- sql3:
  16. select s_id from score where c_id = ?;
  17. -- sql4:
  18. select s_id,s_name,s_sex,s_birth,age,height from student where s_id in (?)
  19. -- 综合成一句：
  20. select s_id,s_name,s_sex,s_birth,age,height from student where s_id in (select s_id from score where c_id = (select c_id from course where t_id = (select t_id from teacher where t_name = "张三")));
  21. -- 5、查询出没有学过张三老师课程的学生信息，包括没有成绩的学生
  22. select s_id,s_name,s_sex,s_birth,age,height from student where s_id not in (select s_id from score where c_id = (select c_id from course where t_id = (select t_id from teacher where t_name = "张三")));
  23. -- 6、学习过编号为01课程号并且也学过编号为02课程号的学生信息分析：先找出学过01课程号的学生id，再找出学过02课程的学号
  24. -- 方案1：
  25. select s_id,s_name,s_sex,age,height from student where s_id in (select s_id from score where c_id = "01" and s_id in(select s_id from score where c_id = "02"));
  26. -- 方案2：
  27. SELECT s_id,s_name,s_sex,age from student where s_id in (SELECT s.s_id FROM score LEFT JOIN score s on score.s_id  = s.s_id WHERE score.c_id = '01' AND s.c_id = '02');
  28. -- 方案3：
  29. SELECT s1.s_id,s_name,c_id FROM student s1 JOIN score s2 ON s1.s_id = s2.s_id  WHERE s1.s_id in (SELECT s_id FROM score c_id = "02" ) AND c_id = "01";
  30. -- 7、查询出没有学全所有课程的学生编号，包括没有学过任何课程的学生分析：根据学生分组，统计出每个学生的课程数，再统计课程表中有多少总课程数，判断两个课程数是否相等。
  31. select s1.s_id,s_name,count(c_id) total from student s1 left join score s2 on s1.s_id = s2.s_id group by s1.s_id having total = (select count(c_id) from course);
  32. -- 8、查询出至少有一门课程与学号为01学生所学课程相同的学生信息分析：先找出01学生学过的课程数，再从成绩中找出和01学生有相同的学号
  33. select s_id,s_name,s_sex,age,height from student where s_id in (select distinct s_id from score where c_id in (select c_id from score where s_id = "01")) and s_id <> "01";
  34. -- 9、查询出成绩有两门以上不及格的学生信息分析：
  35. -- 1)先找出不及格的数据
  36. select s_id,c_id,s_score from score where s_score < 60;
  37. -- 2)在上面结果集的基础之上，对学生进行分组，并统计出课程数
  38. select s_id,count(c_id) 课程数 from score where s_score < 60 group by s_id;
  39. -- 3)用having进行过滤
  40. select s_id from score where s_score < 60 group by s_id having count(c_id) >= 2;
  41. -- 4)综合成一句话
  42. select s_id,s_name,s_sex,age,height from student where s_id in(select s_id from score where s_score < 60 group by s_id having count(c_id) >= 2);
  43. -- 10、查询出同一个学生学习课程01成绩比课程02成绩高的学生信息。
  44. -- 方案1：
  45. SELECT st1.s_id,s_name FROM student st1JOIN score sc1 on st1.s_id = sc1.s_id AND sc1.c_id = "01"JOIN score sc2 on st1.s_id = sc2.s_id AND sc2.c_id = "02"WHERE sc1.s_score > sc2.s_score;
  46. -- 方案2：
  47. SELECT s_id,s_name FROM student WHERE s_id in (    SELECT s1.s_id as sid FROM score s1 JOIN score s2 on s1.s_id =s2.s_id    WHERE s1.c_id="01" and     s1.s_score > s2.s_score AND s2.c_id= "02");
  48. -- 方案3：
  49. select s.s_id  from student s left join score con s.s_id=c.s_id where c.c_id=01 and EXISTS(select 1 from score c1 where c1.c_id=02 and c1.s_id=s.s_id and c.s_score>c1.s_score);

8.2 下半部分

  1. -- 1、查询出和学号为"01"学生学习课程完全相同的学生信息
  2. select s_id,count(c_id) from score where s_id not in(select s_id from score where c_id not in(select c_id from score where s_id = "01")) group by s_id having count(c_id) = (select count(c_id) from score where s_id = "01") and s_id <> "01";
  3. -- 2、查询出每个老师所授课程的总成绩，并按照降序排列
  4. select s1.c_id,sum(s_score) sum from score s1 join course c1 on s1.c_id = c1.c_id group by s1.c_id order by sum desc;
  5. -- 3、查询出每门课程的学习学生数，查询出课程名称
  6. select count(s_id) 学习人数,c_name from score s1 join course c1 on s1.c_id = c1.c_id group by s1.c_id;
  7. -- 4、查询出1990年出生的学生信息(提示：可以使用year函数，比如：year(1992-03-01)可以直接获取年份)
  8. select s_id,s_name,s_sex,s_birth,age,height from student where year(s_birth) = 1990;
  9. -- 5、查询学习课程名为“数学”，并且分数低于60分的学生信息
  10. select s_id,s_name,s_sex,s_birth,age,height from student where s_id in (select s_id from score s1 join course c1 on s1.c_id = c1.c_id where s_score < 60 and c_name = "数学");
  11. -- 6、查询学习过张三老师课程的学生中，成绩最高的学生信息
  12. select s2.s_id,s_name,s_sex,s_birth,age,height from student s2 join score s3 on s2.s_id = s3.s_id join course c2 on s3.c_id = c2.c_id join teacher t2 on c2.t_id = t2.t_id where s3.s_score = (select max(s_score) from score s1 join course c1 on s1.c_id = c1.c_id join teacher t1 on c1.t_id = t1.t_id where t1.t_name = "张三") and t2.t_name = "张三";
  13. -- 7、查询和学号为01学生同年的学生信息
  14. select s_id,s_name,age,height,s_birth from student where year(s_birth) = (select year(s_birth) from student where s_id = "01"); 
  15. -- 8、查询每个课程的及格率
  16. select t1.c_id,t1.count1/t2.count2 * 100 及格率 from (select c_id,count(s_id) count1 from score where s_score >= 60 group by c_id ) t1 join (select c_id,count(s_id) count2 from score group by c_id) t2 on t1.c_id = t2.c_id;
  17. -- 9、查询出每门课程的学生人数、总成绩、平均成绩及授课老师
  18. select count(s_id),sum(s_score),avg(s_score),t_name from score s join course c on s.c_id = c.c_id join teacher t on c.t_id = t.t_id group by c.c_id;

九、数据库视图

  1. 概念：将有关联的多张表生成为一张虚拟表，只为了展示关联后的结果集，视图只能做查询、修改和新增，不能实现删除操作。

  2. 视图的优点：可以将复杂的多表查询语句转换成简单的单表查询

  3. 视图的缺点：虚拟表依赖真实表，如果真实表结构做了改动，视图直接损坏，需要重新维护，增加数据库维护成本
    会将一些指令保存在数据库中，占用一定的内存。

  4. 如何创建视图

十、事务管理

10.1 事务的基础概念

  1. 事务的图示

Mysql数据库 - 图6

  1. 在之前使用的数据库只要做增、删、改操作的时候，实际上每次发送完指令，MySQL的客户端在自动的发送提交事务的指令，才能将真实的数据提交到数据库中，实现持久化存储，控制自动提交事务的全局变量为autocommit，默认值为on。如果想要关闭，将值设置为off。

10.2 手动事务

  1. 手动事务，如果在业务中需要有事务的操作，则用命令开启手动事务，如果手动事务开启，自动提交事务将失效，如果继续发送commit或者是rollback指令，手动事务结束，自动提交事务又开始起作用。
  2. 开启手动事务的命令：start transaction;或者begin;
  3. 结束事务：commit或者rollback;

10.3 回滚点

  1. 在一个事务期间，可以对每一句sql指令设置一个回滚点，如果发现需要回滚的数据，则回滚到回滚点即可
  2. 设置回滚点的指令：savepoint 回滚点名称;
  3. 回滚到回滚点的指令：rollback to 回滚点名称;如果使用回滚到指定位置，则事务不会结束

10.4 事务的特性ACID

  1. 原子性：一个事务开启之后，会将该事务中的所有sql指令当成不可分割的整体，处于最小单元
  2. 隔离性：一个事务开启之后，事务与事务之间是独立的，相互之间没有影响
  3. 一致性：一个事务的提交前后，数据的状态变化保持一致。
  4. 持久性：当一个事务完成之后，数据将永久保存，值到下一次对数据的更改。

十一、JDBC开发

11.1 JDBC概念

  1. 概念：JDBC是用来连接数据库，并向数据库发送SQL指令，获取结果集的驱动开发

  2. JDBC本身是Java的应用程序，作用是有Java代码向数据库发送指令并获取结果集的应用程序。

11.2 JDBC涉及的类

  1. Driver:驱动相关类，在Java的应用程序中需要对该驱动进行注册，使用反射技术进行注册Class.forName();

  2. DriverManager:驱动管理，用来注册驱动之后，获取连接数据库的对象。

  3. Connection:获取数据库连接的类，通过该类的对象，可以连接到指定的数据库，并且获取可以发送sql指令的对象

  4. Statement:该类由连接对象获取，向数据库发送sql指令，让数据库执行sql指令。会的到结果集

  5. PreparedStatement:是Statement的子类，在开发中推荐使用的类， 预编译对象，可以解决SQL注入的问题，作用和父类一致，用来发送sql指令并获取结果集。

  6. ResultSet：该类属于结果集的类，该类创建的对象用来接受结果集，里面包含了遍历的方法和获取数据库字段的数据方法。

11.3 JDBC开发步骤

  1. 第一步：注册驱动
    Class.forName(“com.mysql.jdbc.Driver”);

  2. 第二步：通过驱动管理获取数据库的连接

    1. String url = "jdbc:mysql://127.0.0.1:3306/db_bank";
    2. String username = "root";
    3. String password = "root";
    4. Connection conn = DriverManager.getConnection(url,username,password);
  1. 获取可以发送sql指令的对象Statement
    1. Statement statement = conn.createStatement();
  1. 编写要执行的SQL指令
    1. String sql = "select user_id,user_name,money from t_user";
  1. 发送sql指令，并获取结果集
  1. ResultSet rs = statement.executeQuery(sql);

  1. 从结果集中解析出所有的数据

    1. while(rs.next()){
    2.  //获取user_id的值
    3.  int userId = rs.getInt("user_id");
    4.  //获取user_name的值
    5.  String userName = rs.getString("user_name");
    6.  //获取金额
    7.  int money = rs.getInt("money");
    9.  System.out.println("编号："+userId+",姓名："+userName+",余额："+money);
    10. }
  1. 关闭资源
    1. rs.close();
    2. statement.close();
    3. conn.close();

11.4 JDBC的CRUD方法

  1. 新增数据
  1. public class InsertDemo {
  2.     public static void main(String[] args) throws Exception{
  3.         //1、注册驱动
  4.         Class.forName(Config.DRIVER);
  6.         //2、由驱动管理获取连接对象
  7.         Connection conn = DriverManager.getConnection(Config.URL,Config.USER_NAME,Config.PASSWORD);
  9.         //3、编写sql语句
  10.         String sql = "insert into t_user value(?,?,?)";
  12.         //4、获取预编译对象
  13.         PreparedStatement ps = conn.prepareStatement(sql);
  15.         //5、替换占位符？
  16.         ps.setInt(1,10);
  17.         ps.setString(2,"李思思");
  18.         ps.setInt(3,10000);
  20.         //6、调用方法
  21.         int rows = ps.executeUpdate();
  22.         System.out.println("rows = "+rows);
  24.         //关闭资源
  25.         ps.close();
  26.         conn.close();
  28.     }
  29. }
  1. 删除操作
  1. public class DeleteDemo {
  2.     public static void main(String[] args) throws Exception{
  3.         //注册驱动
  4.         Class.forName(Config.DRIVER);
  6.         //获取连接
  7.         Connection conn = DriverManager.getConnection(Config.URL,Config.USER_NAME,Config.PASSWORD);
  9.         //编写sql语句
  10.         String sql = "delete from t_user where user_id = ?";
  12.         //获取预编译对象
  13.         PreparedStatement ps = conn.prepareStatement(sql);
  15.         //填充占位符？
  16.         ps.setInt(1,10);
  18.         //调用方法
  19.         int rows = ps.executeUpdate();
  20.         System.out.println("rows = "+rows);
  22.         //关闭资源
  23.         ps.close();
  24.         conn.close();
  25.     }
  26. }
  1. 更新操作
  1. public class UpdateDemo {    
  2.     public static void main(String[] args) throws Exception{        
  3.         //注册驱动        
  4.         Class.forName(Config.DRIVER);        
  5.         //获取连接        
  6.         Connection conn = DriverManager.getConnection(Config.URL,Config.USER_NAME,Config.PASSWORD);
  7.         //编写sql语句        
  8.         String sql = "update t_user set user_name = ? where user_id = ?";        
  9.         //获取预编译对象        
  10.         PreparedStatement preparedStatement = conn.prepareStatement(sql);        
  11.         //填充占位符？        
  12.         preparedStatement.setString(1,"张三");        
  13.         preparedStatement.setInt(2,9);        
  14.         //执行        
  15.         int rows = preparedStatement.executeUpdate();        
  16.         System.out.println("rows = "+rows);        
  17.         //关闭资源        
  18.         preparedStatement.close();        
  19.         conn.close();    
  20.     }
  21. }
  1. 查询的方法
  1. public class SelectDemo {    
  2.     public static void main(String[] args) throws Exception{        
  3.         //注册驱动        
  4.         Class.forName(Config.DRIVER);       
  5.         //获取连接       
  6.         Connection connection = DriverManager.getConnection(Config.URL,Config.USER_NAME,Config.PASSWORD); 
  7.         //编写sql        
  8.         String sql = "select user_id,user_name,money from t_user";     
  9.         //获取预编译对象     
  10.         PreparedStatement preparedStatement = connection.prepareStatement(sql);   
  11.         //执行方法    
  12.         ResultSet resultSet = preparedStatement.executeQuery();      
  13.         List<User> userList = new ArrayList<>();    
  14.         //循环遍历       
  15.         while(resultSet.next()){            
  16.             int userId =  resultSet.getInt("user_id");    
  17.             String userName = resultSet.getString("user_name");       
  18.             int money = resultSet.getInt("money");       
  19.             //将数据填充到对象中         
  20.             User user = new User();   
  21.             user.setMoney(money);   
  22.             user.setUserId(userId);      
  23.             user.setUserName(userName);    
  24.             userList.add(user);     
  25.         }      
  26.         for(ListIterator<User> it = userList.listIterator();it.hasNext();){  
  27.             System.out.println(it.next());      
  28.         }       
  29.         //关闭资源   
  30.         resultSet.close();   
  31.         preparedStatement.close();  
  32.         connection.close();   
  33.     }
  34. }

11.5 浅封装JDBC

  1. public class JDBCUtils {    
  2.     //定义四个参数，供后续注册驱动和建立连接使用 
  3.     private static final String DRIVER = "com.mysql.jdbc.Driver";   
  4.     private static final String URL = "jdbc:mysql://127.0.0.1:3306/db_book?useUnicode=true&characterEncoding=utf-8";    
  5.     private static final String USER_NAME = "root";   
  6.     private static final String PASSWORD = "root";   
  7.     static{        
  8.         try {         
  9.             //注册驱动        
  10.             Class.forName(DRIVER);   
  11.         }catch (Exception e){  
  12.             e.printStackTrace();    
  13.         }   
  14.     }  
  15.     //获取连接   
  16.     public static Connection getConn(){   
  17.         try {        
  18.             //获取连接    
  19.             Connection conn = DriverManager.getConnection(URL,USER_NAME,PASSWORD);    
  20.             return conn;   
  21.         }catch (Exception e){    
  22.             e.printStackTrace(); 
  23.         }        return null; 
  24.     }    
  25.     //关闭资源   
  26.     public static void close(Connection conn, PreparedStatement ps){   
  27.         try {          
  28.             if(ps != null) { 
  29.                 ps.close();         
  30.             }           
  31.             if(conn != null){    
  32.                 conn.close();   
  33.             }      
  34.         }catch (Exception e){   
  35.             e.printStackTrace();  
  36.         }  
  37.     }   
  38.     //关闭资源三个参数重载形式 
  39.     public static void close(Connection conn, PreparedStatement ps, ResultSet rs){ 
  40.         try {         
  41.             if(rs != null) {    
  42.                 rs.close();     
  43.             }    
  44.         }catch (Exception e){    
  45.             e.printStackTrace();  
  46.         }      
  47.         //调用重载  
  48.         close(conn,ps);
  49.     }
  50. }

11.6 读取properties配置文件

  1. public class ReadDemo{
  2.     public static void main(String[] args)throws Exception{    
  3.         //用来读取properties文件        
  4.         //读取字节流        
  5.         InputStream in = new FileInputStream(new File("D:\\Code\\56Code\\Demo\\db.properties"));    
  6.         //创建Properties对象    
  7.         Properties prop = new Properties();        
  8.         //将输入流读取到properties文件中        
  9.         prop.load(in);                
  10.         //根据key获取value值        
  11.         String username = prop.getProperty("username");        
  12.         String password = prop.getProperty("password");    
  13.         System.out.println(username+","+password);    
  14.     }
  15. }

11.7 深度封装JDBC工具类

  1. public class JDBCTools {   
  2.     //声明四个参数 
  3.     private static String driver;
  4.     private static String url;  
  5.     private static String username;   
  6.     private static String password;   
  7.     //使用静态代码块实现读取properties文件，并且注册驱动 
  8.     static{      
  9.         try {        
  10.             //读取properties  
  11.             //获取输入流：      
  12.             InputStream in = JDBCTools.class.getClassLoader().getResourceAsStream("db.properties");                        //创建Properties文件        
  13.             Properties prop = new Properties();   
  14.             //读取输入流        
  15.             prop.load(in);     
  16.             //解析数据         
  17.             driver = prop.getProperty("driver");
  18.             url = prop.getProperty("url");     
  19.             username = prop.getProperty("username");    
  20.             password = prop.getProperty("password");      
  21.             //注册驱动          
  22.             Class.forName(driver);     
  23.         }catch (Exception e){      
  24.             e.printStackTrace();    
  25.         }   
  26.     }   
  27.     //获取连接 
  28.     public static Connection getConn(){   
  29.         try {     
  30.             //获取连接      
  31.             return DriverManager.getConnection(url,username,password);    
  32.         }catch (Exception e){    
  33.             e.printStackTrace();  
  34.         }    
  35.         return null;  
  36.     }  
  37.     //关闭资源 
  38.     public static void close(Connection conn, PreparedStatement ps){    
  39.         try {         
  40.             if(ps != null){    
  41.                 ps.close();    
  42.             }         
  43.             if(conn != null){    
  44.                 conn.close();  
  45.             }    
  46.         }catch (Exception e){   
  47.             e.printStackTrace();     
  48.         }   
  49.     }   
  50.     //关闭资源重载形式  
  51.     public static void close(Connection conn, PreparedStatement ps, ResultSet rs){   
  52.         try {      
  53.             if(rs != null){     
  54.                 rs.close();     
  55.             }       
  56.         }catch (Exception e){    
  57.             e.printStackTrace();  
  58.         }     
  59.         close(conn,ps); 
  60.     }
  61. }