debug_AC
debug_AC

javaweb

SQL分类

	1、 DDL(Data Definition Language)数据定义语言：
用来定义数据库对象 ：数据库，表，列等。关键字：create drop alter等
	2、 DML（Data Manipulation Language）数据操作语言
用来对数据库中的表的数据进行增删改。关键字：insert delete update等
	3、DQL（Data Query Language)数据查询语言
用来查询数据库中表的记录（数据）。关键字：select，where等
	4、DCL（Data Control Language）数据控制语言（了解）
用来定义数据库的访问权限和安全级别，及创建用户。关键字：GRANT REVOKE等。

DDL:操作数据库、表

1.操作数据库：CRUD
	- 1. C(Create):创建
	   *创建数据库时判断是否已经存在并指定字符集
		CREATE DATABASE IF NOT EXISTS db3 CHARACTER SET GBK;
	2. R（Retrieve):查询
		*查询所有数据库的名称：
			*show databases;
		*查询某个数据库的字符集,查询某个数据库的创建语句：
			*show create database 数据库名称;
	3. U（update):修改
		*修改数据库的字符集
			alter database 数据库名称 character set 字符集名称
	4. D（Delete）：删除
		*删除数据库
			drop database if exists 数据库名称;
	5.使用数据库
		*查询当前正在使用的数据库名称
			select database();
		*使用数据库
			use 数据库名称;
2.操作表：CRUD
	1.C（Create）：
		*创建
			1.语法：
			create table if not exists 表名(
			列名1 数据类型 ,
			列名2 数据类型,
           ----------,
			列名n 数据类型
			);
		*复制表：
			create table 表名 like 被复制的表名;
	
		
		 
	2.R（Retrieve）:查询
		*查询某个数据库中所有表名称
			*show tables;
		*查询某个数据库中某一张表
			*show table 表名;
		*查询表结构
			*desc 表名
	3.U（update)：修改
		1. 修改表名称：
			alter table 表名 rename to 新表名;
		2. 修改表的字符集:
			alter table 表名 character set 字符集名称
		3. 添加一列：
			alter table 表名 add 列名 类型;
		4. 修改列名称:
		 	alter table 表名 change 列名 新列名 新数据类型;
			alter table 表名 modify 列名 新数据类型;
		5. 删除列
			alter table 表名 drop 列名;
	4.D（Delete）：删除
		drop table if exists 表名;

DML:增删改表中数据

1. 添加数据：
	*语法：
		*insert into 表名（列名1，列名2，...列名n) values(值1，值2，...值n);
	*注意：
		1. 列名和值要一一对应。
		2. 如果列名省略不写，则默认给所有列添加值。
		3. 除了数字类型，其他类型要使用引号（单双都可以）引起来
2. 删除数据：
	*语法：
		delete from 表名 [where 条件];
	*注意：
		1. 如果不加条件，则删除表中所有记录。
		2. 如果要删除所有记录
			1. delete from 表名；不推荐使用，有多少条记录就会执行多少次删除操作。
			2. truncate table 表名；推荐使用， 先删除表，然后在创建一张一样的表。
		
3. 修改数据：
	* 语法：
		* update 表名 set 列名1 = 值1，列名2 = 值2，...列名n = 值n[where 条件];
	* 注意：
		如果不加条件则默认将表中所有记录都修改

DQL

1. 排序查询
	* 语法：order by 子句
	* order by 排序字段1 排序方式1 ， 排序字段2 排序方式2,...,排序字段n 排序方式n;
	* 排序方式：
		* ASC：升序，默认。
		* DESC：降序。
	* 注意：
		* 如果有多个排序条件，则当前面的条件值一样时，才会判断第二条件。
2. 聚合查询：将一列数据作为一个整体，进行纵向的计算。
	1. count：计算个数
	2. max:计算最大值
	3. min:计算最小值
	4. avg:计算平均值
	* 注意：聚合函数的计算排除null值
		解决方案：
				1. 选择不包含非空的列进行计算
				2. IFNULL函数

3. 分组查询：
	1. 语法：group by 分组字段
	2. 注意：
		1. 分组之后查询的字段：分组字段、聚合函数
		2. where 哦having的区别：
			1. where在分组前进行限定，如果不满足条件，则不参与分组。having在分组后进行限定，如果不满足结果，则不会被查询出来。
			2. where后不可以跟聚合函数，having可以进行聚合函数的判断。
4. 分页查询
	1. 语法：limit 开始的索引，每页查询的条数。
	2. 公式：开始的索引 = （当前的页码 -1 ）* 每条显示的条数
5. 查询表中记录
	* select * from 表名;
	1. 语法：
	  	select 
			字段列表
		from 
			表名列表
		where
			 条件列表
		group by
			分组字段
		having
			分组之后的条件
		order by
			排序
		limit
			分页限定
	2. 基础查询
		1. 多个字段的查询
			1. select 字段名1 ， 字段名2，...from表名
		2. 去除重复
			1. distinct
		3. 计算列
			1. ifnull(表达式1，表达式2）
				1. 表达式1：那个字段需要判断是否为null
				2. 表达式2：如果表达式1字段值为null的替换值
		4. 起别名
			as:as也可以省略
	3. 条件查询
		1. where子句后跟条件
		2. 运算符

约束

* 概念：对表中的数据进行限定，保证数据的正确性、有效性、完整性。
* 分类:
	1. 主键约束：primary key
	2. 非空约束：not null
	3. 唯一约束：unique
	4. 外键约束：foreign key
* 非空约束
	1. 创建表时，添加约束
		create table 表名（
		列名 类型 not null,
			...
			）;
	2. 创建表后，添加约束
	 1. alter table 表名 modify 列名 类型 约束;
	 2. alter table 表名 change 列名 新列名 类型 约束;
	3. 删除非空约束
		1. alter table 表名 modify 列名 类型； 
* 唯一约束: unique,值不能重复
	1. 创建表时，添加唯一约束
		create table 表名(
		 列名 类型 unique,
			...
		);
	*注意 mysql中，唯一约束限定的列的值可以有多个null 
	2. 删除唯一约束
		alter table 表名 drop index 列名
	3. 创建表后，添加唯一约束
		alter table 表名 modify 列名 类型 unique;  

	( sqlyog 执行 "select * from 表名"报错1064，还没解决
		原因是mysql5.5,后不需要更改后缀）
* 主键约束：primary key
	1. 注意：
		1. 含义：非空且唯一
		2. 一张表只能有一个字段为主键
		3. 主键就是表中记录的唯一标识
	2. 在创建表时，添加主键约束
		 create table 表名（
			列名1 类型 primary key ,
				...
		 );
	3. 删除主键
		alter table 表名 drop primary key;
	4. 创建表后，添加主键
		alter table 表名 modify 列名 类型 primary key;
	5. 自动增长：某一列的增长后的值只与上一列的值有关
		1. 概念：如果某一列是数值类型的，使用auto_increment可以来完成值得自动增长。
		2. 在创建表时，添加主键约束，并完成主键自动增长
			create table 表名（
				列名1 类型 primary key auto_increment,
					...
			);
		3. 删除主键
			alter table 表名 modify 列名 类型;
		4. 添加自动增长
			alter table 表名 modify 列名 类型 auto_increment;
* 外键约束: foreign key,让表与表产生关系，从而保证数据的正确性。
	1. 创建表时，添加外键
		* 语法：
			create table 表名（
				...
				外键列
				constraint 外键名称 foreign key （外键列名称）references 主表名称（主表列名称）
			);
	2. 删除外键
		alter table 表名 drop foreign key 外键名;
	3. 创建表后，添加外键
		alter table 表名 add constraint 外键名 foreign key 从表名称（外键列名称）references 主表名称（主表列名称）;
	4. 级联操作（此操作非常危险，慎用）
		1. 添加级联操作
			语法：alter table 表名 add constraint 外键名称 
					foreign key(外键字段名称） references 主表名称（主表列名称）on update cascade on delete cascade;
				-- on update cascade 级联更新
				-- on delete cascade 级联删除
		2. 分类：
			1. 级联更新：on update cascade
			2. 级联删除：on delete cascade

数据库的设计

1. 多表之间的关系：
	1. 分类
		1. 一对一（了解）：如：人和身份证
		2. 一对多（多对一）：如：部门和员工
		3. 多对多：如：学生和课程
	2. 实现关系
		1. 一对多（多对一）：
			*实现方式：在多的一方建立外键，指向一的一方的主键。
		2. 多对多： 
			*实现方式：多对多关系实现需要借助第三张表。中间表至少包含两个字段，这两个字段作为第三张表的外键，分别指向两张表的主键
		3. 一对一：
			* 实现方式：可以在任意一方添加唯一（unique)外键指向另一方的主键。
2. 数据库设计的范式:主要考虑数据是否冗余，添加新的数据是否有问题，删除数据是否有问题。
	1. 定义：设计数据库时，需要遵循的规范，要遵循后面的范式要求，必须遵循前面的所有范式要求。
	2. 分类：
		1. 第一范式（1NF）：每一列都是不可分割的原子数据项
		2. 第二范式（2NF）：在1NF的基础上，非码属性必须完全依赖于候选码（在1NF的基础上消除非主属性对主码的部分函数依赖）
			*概念：
					1. 函数依赖：A-->B,如通过A属性（属性组）的值，可以确定唯一B属性的值，则称B依赖于A。
					2. 完全函数依赖：A-->B ,如果A是一个属性组，则B属性值的确定需要依赖于A属性组中所有的属性值。
					3. 部分函数依赖：A --> B,如果A是一个属性组，则B属性值的确定只需要依赖于A属性组中某一些值即可。
					4. 传递函数依赖： A --> B, B --> C,如果通过A属性（属性组）的值，可以确定唯一B属性的值，再通过B属性（属性组）的值可以确定唯一C属性的值，则称C传递依赖于A。
					5. 码：如果在一张表中，一个属性或属性组，被其他所有属性完全依赖，则称这个属性（属性组）为该表的码。
						1. 主属性：码属性组中的所有属性。
						2. 非主属性：除码属性组外的属性。
		3. 第三范式（3NF）：在2NF基础上，任何非主属性不依赖于其他非主属性（在2NF基础上消除传递依赖）

数据库的备份和还原

1. 命令行：
	1. 语法：
		1. 备份：mysqldump -u用户名 -p密码 [数据库名称] > 保存的路径
		2. 还原：
			1. 登录数据库
			2. 创建数据库
			3. 使用数据库
			4. 执行文件：source sql文件路径
	
2. 图形化工具(以SQLyog为例)：对数据库点击鼠标右键。

多表查询

1. 查询语法：
	select 
			列名列表
	form
			表名列表
	where
		...
2. 笛卡尔积
	1. 定义：有两个集合A，B，取这两个集合的所有组成情况：A（记录条数） * B（记录条数）
	2. 要完成多表查询，需要消除无用的数据
3. 多表查询的分类：
	1. 内连接查询：
		1. 隐式内连接：使用where条件消除无用数据
		2. 显示内连接：
			1. 语法：
				select 字段列表 from 表名1 [inner] join 表名2 on 条件;
		3. 内连接查询需要注意的事项：
			1. 从那些表中查询数据
			2. 条件是什么
			3. 查询哪些字段
	2. 外连接查询：
		1. 外连接的分类：
			1. 左外连接：
				1. 语法：
					select 字段列表 from 表1 left [outer]  join 表2 on 条件
				2. 左外连接查询的是左表所有数据以及其交集部分
			2. 右外连接：
				1. 语法：
					select 字段列表 from 表1 right [outer]  join 表2 on 条件
				2. 右外连接查询的是右表所有数据以及其交集部分
	3. 子查询：
		1. 概念：查询中嵌套查询，称嵌套的查询为子查询
		2. 子查询的分类：
			1. 子查询的结果是单行单列的：
				1. 子查询可以作为条件，使用运算符去判断：>,>=,<,<=...;
			2. 子查询的结果是多行单列的：
				1. 子查询可以作为条件，使用运算符in来判断
			3. 子查询的结果是多行多列的：
				1. 子查询可以作为一张虚拟表。

事务

1. 事物的基本介绍
	1. 概念：
		一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
	2. 操作
		1. 开启事物:start transaction; 
		2. 回滚(执行出错):rollback;
		3. 提交（执行完成）：commit;
	3. MYSQL数据库中事务默认自动提交
		1. 事务提交的两种方式：
			1. 自动提交
				1. mysql默认就是自动提交的，oracle默认手动提交
				2. 一条DML（增删改）语句会自动提交一次事务
			2. 手动提交
				1. 需要先开启事务，再提交
		2. 修改事务的默认提交方式：
			1. 查看事务的默认提交方式：
				select @@autocommit; 返回值：1代表自动提交 0 代表手动提交
			2. 修改事务的默认提交方式
				set @@autocommit = in(0,1);
		 
2. 事物的四大特征
	1. 原子性：不可分割的最小操作单位，要么同时成功，要么同时失败
	2. 持久性：事务提交或回滚后，数据库会持久化的保存数据。
	3. 隔离性：多个事务之间，相互独立。
	4. 一致性：事务操作前后，数据总量不变。
3. 事物的隔离级别（了解）
	1. 概念：多个事务之间隔离的，相互独立。但是如果多个事务操作同一批数据，则会引发一些问题，设置不同的隔离级别就可以解决这些问题。
	2. 存在的问题：
		1. 脏读：一个事务，读取到另一个事务中没有提交的数据。
		2. 不可重复读（虚读）：在同一个事务中，两次读取到的数据不一样
		3. 幻读：一个事务操作（DML）数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。
	3. 隔离级别
		1. read uncommitted: 读未提交
			1. 产生的问题：脏读、不可重复读、幻读
		2. read committed：读已提交（ORACle 默认）
			1. 产生的问题：不可重复读、幻读
		3. repeatable read :可重复读（MYSQL默认）
			1. 产生的问题：幻读
		4. serializable:串行化
			1. 可解决所有问题
	4. 注意：上述第三点中的4种隔离级别，从上到下安全性越来越高，但是效率越来越低。
	5. 语法:
		1. 数据库查询隔离级别:
			select @@tx_isolation;
		2. 数据库设置隔离级别:
			set global transaction isolation level 级别字符串;

DCL

1. 管理用户
	1. 添加用户
		1. 语法：create user '用户名'@'主机名' identified by '密码';
	2. 删除用户
		1. 语法： drop user '用户名'@'主机名';
	3. 修改用户密码
		1. 语法：
			1. update user set password = password('新密码') where user = '用户名';
			2. set password for '用户名'@'密码' = password('新密码');
		2. 注意：忘记root用户的密码该怎么操作：
			1. cmd --> net stop mysql -- 停止mysql服务，需要管理员权限。
			2. mysqld --skip-grant-tables -- 启动无验证方式mysql 服务
			3. 打开新的cmd窗口，直接输入mysql命令，无需输入用户名和密码，就可以登录成功。
			4. 输入修改用户密码的语句，设置新密码
			5. 关闭两个窗口
			6. 在任务管理器中，关闭mysqld进程
			7. 启动mysql服务
			8. 使用新密码登录
	4. 查询用户：
		1. 步骤：
			1. 切换到mysql数据库
			2. 查询user表
			3. 注意：通配符‘%’，表示任意主机可以使用root用户登录数据库。 
2. 授权（权限管理）：
	1. 查询权限
		1. 语法：show grants for '用户名'@'密码';
	2. 授予权限
		1. 语法： grant 权限列表 on 数据库名.表名 to '用户名'@'密码';
	3. 撤回权限
		1. 语法： revoke 权限列表 on 数据库名.表名 from '用户名'@'密码';

JDBC课程笔记

JDBC基本概念

1. 概念：Java DataBase Connectivity Java 数据库连接
2. JDBC的本质：官方定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包，我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类。

快速入门

1. 步骤：
 	1. 导入驱动jar包
 	2. 注册驱动
 	3. 获取数据库的连接对象Connection
 	4. 定义sql
 	5. 获取执行sql语句的对象 Statement
 	6. 执行sql，接收返回结果
 	7. 处理结果
 	8. 释放资源

JDBC中各个接口和类详解

1. DriverManager：驱动管理对象
	1. 功能：
		1. 注册驱动
			1. static void registerDriver(Driver driver):注册给定的驱动程序 DriverManager
			2. Class.forName("com.mysql.cj.jdbc.Driver");
			3. 注意：mysql5以后的驱动jar包可以省略注册驱动的步骤，jar会帮助我们注册驱动。
		2. 获取数据库连接
			1. 方法： static Connection getConnection(String url,String user,String password);
			2. 参数：
				1. url：指定连接的路径
					1. 语法：jdbc:mysql://ip地址（域名）:端口号/数据库名称
					2. 细节：如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称；
				2. user:用户名
				3. password密码
		
2. Connection：数据库连接对象
	1. 功能：
		1. 获取执行sql的对象
			1. Statement createStatement();
			2. preparedStatement prepareStatement(String sql);
	2. 管理事务：
		1. 开始事务：void setAutoCommit(boolean autoCommit):调用该方法设置参数为false，即开启事务
		2. 回滚事务：void rollback();
		3. 提交事务：void commit(); 
3. Statement：执行sql的对象
	1. 方法：
		1. boolean execute(String sql):可以执行任意sql.
		2. int executeUpdate(String sql):执行DML（insert , delete , update）语句和DDL(create,alter,drop)语句 
			1. 返回值：影响的行数，可以通过这个返回值判断DML语句是否执行成功，返回值>0则成功，反之则失败。
		3. ResultSet executeQuery(String sql):执行DQL语句（selecte）
4. ResultSet：结果集对象,封装查询结果
	1. 方法：
		1. boolean next():游标向下移动一行，并判断当前行是否是最后一行末尾（当前行是否有数据），如果是，则返回false,反之，则返回true。
		2. Xxx getXxx(参数)：获取某一行某一列的单个值
			1. Xxx代表数据类型。
			2. 参数：
				1. int 代表列的编号，从1开始
				2. String：代表列的名称
		3. 注意：	
			1. 使用步骤：
				1. 游标向下移动一行
				2. 判断是否有数据
				3. 获取数据
			2. 示例：
				1.  while(rs.next){
				 	 };
				 
	
5. PreparedStatement（预编译SQL语句的对象）：执行sql的对象
	1. SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接，会造成安全性问题
	2. 解决SQL注入问题：使用preparedstatement对象来解决
	3. 预编译的SQL：参数使用'？'作为占位符
	4. 使用步骤
		 1. 导入驱动jar包
 		 2. 注册驱动
 		 3. 获取数据库的连接对象Connection
 		 4. 定义sql
	 		 1. 注意：SQL的参数使用？作为占位符
		     2. 例如：select * from user where username = ? and password = ?;
		     3. 而使用Statement对象的语句是：select * from user where username = + 变量 + and ＋password = + 变量 
 		 5. 获取执行sql语句的对象 PreparedStatement
	 		 1. 调用 PreparedStatement Connection.preparedStatement(String SQL);
	 		 2. 注意：在调用 Statement对象时，没有立即传入参数
	 	 6. 给'?'赋值：
		 	 1. 方法：setXxx(参数一，参数二)
		 	 2. 参数：参数一：是问号的位置，参数二：是问号的值，Xxx是参数二的类型
 		 7. 执行sql，接收返回结果，不需要传递SQL语句，因为在获取执行sql语句的对象时就已经将SQL语句传递过了.
 		 8. 处理结果
 		 9. 释放资源
 	5. 后期都会使用preparedStatement来完成增删改查的所有操作
	 	1. 可以防止SQL注入
	 	2. 效率更高

抽取JDBC的工具类： JDBCUtils

1. 目的：简化书写
2. 分析：
	1. 注册驱动
	2. 抽取一个方法获取连接对象
		1. 需求：不想传递参数（麻烦），还得保证工具类的通用性。
		2. 解决方案：配置文件
			1. 自己定义一个名为jdbc.properties的配置文件
			2. 在其中记录
				1. url = "";
				2. user = "";
				3. password = ""; 
				4. 文件具体内容：
					1. url = jdbc:mysql:///db3?serverTimezone=GMT%2B8
					2.	user = root
					3.	password = mysql
					4.	driver =com.mysql.cj.jdbc.Driver
		3. 将来只要读取这个配置文件就能拿到对应的值
		4. 采用静态代码块来读取配置文件的值，代码如下：
			1. /**
				 * 使用静态代码块来读取配置文件
			   * */
			    static {
			        try {
			            //1.创建properties集合类对象
			            Properties pro = new Properties();
			            //2.加载文件
			            pro.load(new FileReader("src/jdbc.properties"));
			            //3.获取属性，赋值
			            url = pro.getProperty("url");
			            user = pro.getProperty("user");
			            password = pro.getProperty("password");
			            driver = pro.getProperty("driver");
			            //4.注册驱动
			            Class.forName(driver);
			        } catch (IOException e) {
			            e.printStackTrace();
			        } catch (ClassNotFoundException e) {
			            e.printStackTrace();
			        }
			    }
			2. 代码改进：
				1. 在上述代码的第一步与第二步间添加一步获取配置文件路径的步骤
				2. 代码如下
					//2. 获取src路径下的文件的方式 ->ClassLoader 类加载器
					ClassLoader classloader = JDBCUtils.class.getClassLoader();
					URL res = classloader.getResource("jdbc.properties");//这个参数是以src为相对路径
					String path = res.getPath();//path即为物理存储地址
		5. 拿到值后的代码如下：
			1.  /**
 					* 获取连接
				    * @return 链接对象
				 * */
		        public static Connection getConnection() throws SQLException {
		            return DriverManager.getConnection(url,user,password);
		        }
		
	3. 抽取一个方法释放资源
		1. 因为DML和DQL使用到的资源不同，所以采用复写的方法来实现，共有两个函数：
			1. (DML) /**
			     * 释放资源
			     * @param stmt
			     * @param conn
			     * @return void
			    * */
   			 public static void close(Statement stmt , Connection conn){...}
			2. (DQL)  /**
					     * 释放资源
					     * @param rs
					     * @param stmt
					     * @param conn
					     * @return void
					    * */
					public static void close(ResultSet rs , Statement stmt, Connection conn){...}

JDBC控制事务

1. 事务：一个包含多个步骤的业务操作。如果这个业务操作被事务管理，则这多个步骤要么同时成功，要么同时失败。
2. 事务的操作：
	1. 开启事务
	2. 提交事务
	3. 回滚事务

3. 使用Connection对象来管理事务
	1. 开启事务：setAutoCommit(Boolean autocommit):参数设置为false，即开启事务
	2. 提交事务：commit();
	3. 回滚事务：rollback();

数据库连接池

1. 定义：数据库连接池就是一个容器（集合），存放数据库连接的容器。
2. 工作过程：但系统初始化后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取链接对象，当用户访问完后，会将连接对象归还给容器。
3. 优点：
	1. 节约资源
	2. 用户访问高效
4. 实现：
	1. 标准接口：DataSource java.sql包下的
		1. 方法：
			1. 获取连接：getConnection();
			2. 归还连接：如果连接对象Connection是从连接池获取的，那么调用Connection.Close()方法，则不会关闭连接了，而是归还连接。
	2. 一般我们不去实现getConnection（），由数据库厂商来实现
		1. 两种数据库连接池的实现技术：
			1. c3p0：数据库连接池技术
			2. Druid:数据库连接池实现技术，由阿里巴巴提供
5. 学习两种数据库连接池的实现技术
	1. C3p0:
		1. 使用步骤：
			1. 导入jar包 c3p0-0.9.5.5.jar，mchange-commons-java-0.2.19.jar（C3p0包及其依赖jar包，共两个）及mysql相对应的驱动jar包
			2. 定义配置文件，不使用硬编码的方式
				1. 文件名称：c3p0.properties 或 c3p0-config.xml
				2. 路径： 直接将文件放在src目录下即可。
				3. c3p0-config.xml（一般都使用这个文件格式）配置文件代码如下：
					
				    
				    
				        
				        com.mysql.cj.jdbc.Driver
				        jdbc:mysql://localhost:3306/db3?serverTimezone=GMT%2B8
				        root
				        mysql
				
				        
				        5
				        30
				        
				        3000
				    
				
				    
				        
				        com.mysql.cj.jdbc.Driver
				        jdbc:mysql://localhost:3306/db3?serverTimezone=GMT%2B8
				        root
				        mysql
				
				        
				        5
				        8
				        1000
				    
				
			3. 创建核心对象：数据库连接池对象CombopooledDataSource
				//        1.创建数据库连接池对象
   						  DataSource ds = new ComboPooledDataSource();
			4. 获取默认配置的连接：getConnection();
				//        2.获取连接对象
    					  Connection conn = ds.getConnection();
			5. 想获取其他配置的连接就使用：CombopoolDataSource.getConnection(配置文件的相对应的name);
	2. Druid:
		1. 步骤：
			1. 导入jar包
			2. 定义配置文件
				1. properties形式的
				2. 可以叫任意名称，可以放在任意目录下
				3. 注意：
					1. 相较c3p0而言：c3p0的配置文件必须是指定名称和放在指定的根目录下（即src），但c3p0可以有两种文件格式。
				4. 配置文件的具体内容
					 #数据库驱动
					driverClassName=com.mysql.cj.jdbc.Driver
					#数据库的连接路径，链接本地主机可以将url=jdbc:mysql:///db3
					url=jdbc:mysql://127.0.0.1:3306/db3?serverTimezone=GMT%2B8
					#数据库用户
					username=root
					#数据库密码
					password=mysql
					#数据库初始化连接数量
					initialSize=5
					#数据库最大连接数量
					maxActive=10
					#设置连接超时时间（最大等待时间）
					maxWait=3000
			3. 加载配置文件：Properties
				1. 具体内容
					 Properties pro = new Properties();
				     InputStream is = DruidDemo1.class.getClassLoader().getResourceAsStream("Druid.properties");
				     pro.load(is);
			4. 获取数据库连接池对象： 通过工厂来获取：DruidDataSourceFactory
				1. 具体内容：
					DataSource ds= DruidDataSourceFactory.createDataSource(pro);
			5. 获取连接：getConnection();
				1. 具体内容：
					Connection conn =  ds.getConnection();
		2. 定义Druid工具类
			1. 定义一个类，类名为：JDBCUtils
			2. 提供静态代码块加载配置文件，初始化连接池对象】
				1. 代码如下（抛出的异常catch即可）：
					private static DataSource ds = null;
					static{
						//      1.加载配置文件
			            Properties pro = new Properties();
			            InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("Druid.properties");
			            pro.load(is);
			            //   获取DetaSource
			            ds = DruidDataSourceFactory.createDataSource(pro);
					}
			3. 提供方法	
				1. 获取连接方法：通过数据库连接池获取连接
				2. 释放资源
				3. 获取连接池的方法

spring JDBC：JDBC Temp

1. spring框架提供的对JDBC简单封装 。提供了一个JDBCTemplate对象的开发
2. 步骤：
	1. 导入jar包
	2. 创建JDBCTemplate对象。依赖于数据源DataSource
		1. 例：JdbcTemplate template = new Jdbctemplate(new DataSource);
		2. 例：JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource); -- JDBCUtils类是对Druid定义的工具类
	3. 调用jdbcTemplate的方法来完成CRUD的操作。
		1. updateXXX（）：执行DML语句，即增删改操作
		2. queryXXX()：
			1. queryForMap():查询结果并将结果集封装为map集合，将列名作为key，将值作为value，将该条记录封装为一个map集合。
				1. 注意：这个方法查询的结果集长度只能为1
			2. queryForList():查询结果并将结果集封装为list集合
				1. 注意：这个方法将每一条记录封装为一个Map集合，再将Map集合封装在一个List集合中。
			3. query():查询结果并将结果封装为JavaBean对象
				1. 有两种实现方法：
					1. 自己实现RowMapper<>类，可见虽然实现了“查询所有记录，将其封装为Account对象的List集合中”，这一功能但代码量并没有减少
						 /**
					         * 注释的代码部分是自己实现RowMapper类，并实现功能的部分
					         * */
					//        List list = template.query("select * from account", new RowMapper() {
					//                    private Account account = null;
					//
					//                    @Override
					//                    public Account mapRow(ResultSet rs, int i) throws SQLException {
					//                        account = new Account();
					//
					//                        int id = rs.getInt("id");
					//                        String book_name = rs.getString(2);
					//                        int balance = rs.getInt(3);
					//                        account.setId(id);
					//                        account.setBook_name(book_name);
					//                        account.setBalance(balance);
					//                        return account;
					//                    }
					//                }
					//                );
					//        for(Account account:list){
					//            System.out.print(account.getId()+"_");
					//            System.out.print(account.getBook_name()+"_");
					//            System.out.println(account.getBalance());
					//        }
					//        return account;
				2. 使用JDBCTemplate提供的BeanPropertyRowMapper<类型>(类型.class)类来实现，可见代码量大大减少
					 List list = template.query("select * from account", new BeanPropertyRowMapper(Account.class));
			4. queryForObject：查询结果并将结果封装为对象，一般是用来使用对聚合函数的查询。
				1. 例： Long total = template.queryForObject(sql语句，Long.class);

HTML、CSS、JavaScript

HTML:搭建基础网页

1. web概念概述
	1. JavaWeb
		1. 使用Java语言开发基于互联网的项目
	2. 软件架构：
		1. C/S：Client/Server 客户端/服务器端
			1. 定义：在用户本地有一个客户端程序，在远端有一个服务器端程序
			2. 优点：用户体验好
			3. 缺点：开发、安装、部署、维护麻烦
		2. B/S：Browser/Server 浏览器/服务器端
			1. 定义：只需要一个浏览器，用户通过不同的URL，访问不同的服务器程序
			2. 优点：开发、安装、部署、维护简单
			3. 缺点：
				1. 如果应用过大，用户体验稍差
				2. 对硬件要求过高
	3. B/S架构详解
		1. 资源分类：	
			1. 静态资源：使用静态网页开发技术发布的资源
				1. 特点：
					1. 所有用户访问，得到的结果是一样的。如：文本，图片，HTML，CSS，JavaScript。
					2. 如果用户请求的是静态资源，那么服务器会直接将静态资源发送给浏览器，浏览器中内置了静态资源的解析引擎，可以展示静态资源。
			2. 动态资源：使用动态网页开发技术发布的资源
				1. 特定：
					1. 每个用户看到的结果可能不一样。如：jsp/servlet,php,asp...
					2. 如果用户请求的是动态资源，那么服务器会执行动态资源，转换为静态资源再发送给浏览器。
					3. 所有，我们要学习动态资源，必须先学习静态资源。
		4. 我们要学习的静态资源：
			1. HTML:用于搭建基础网页，展示页面的内容
			2. CSS:用于美化页面，页面布局
			3. JavaScript:控制页面的元素，让页面有一些动态的效果
2. HTML
	1. 概念：最基础的网页开发语言
		1. Hyper Text Markup Language 超文本标记语言
			1. 超文本：超文本是用超链接的方法，将各种不同空间的文字信息组织在一起的网状文本。
			2. 标记语言：由标签构成的语言
				1. 注意：标记语言不是编程语言
	2. 快速入门
		1. 语法
			1. html文档的后缀名为 .html或.htm
			2. 标签分类：
				1. 围堵标签：有开始和结束标签,如
				2. 自闭和标签:开始标签和结束标签在一起，如

			3. 标签是可以嵌套的：
				1. 注意：标签要正确嵌套，不能我中有你，你中有我。
			4. 在开始标签中可以定义属性。属性由键值对构成，值需要用引号（单双引号都可以）引起来	
			5. html的标签不区分大小写，建议使用小写
	3. 标签学习：
		1. 文件标签：构成html最基本的标签
			1. html:html文档的根标签
			2. head：头标签。用于指定html文档的一些属性，引入外部资源
			3. title：标题标签
			4. body：体标签
			5. :html5中定义该文档是一个html文档
		2. 文本标签：和文本有关的标签
			1. 
到
：标题标签，从1到6字体大小逐渐变小
			2. 
：段落标签
			3. 
：换行
			4. 
：显示一条水平线
			5. ：字体加粗
			6. ：字体斜体
			7. (已被h5抛弃)：字体标签
			8. 
（过时标签）:文本居中
		3. 图片标签
			1. :展示图片，通过src属性设置图片的URL
			2. src下路径的设置方法：
				1. 相对路径：
					1. ./ ：代表当前目录
					2. ../:代表上一级目录
				2. 绝对路径：物理路径
		4. 列表标签
			1. 有序列表：
				1. 
    :定义有序列表
				2. 
  1. :定义列表的项目
			2. 无序列表：
				1.