第七次总结

小题：

1.DQL分页查询：
	分页查询
	select
		字段列表
	from
		表名
		limit 起始行数，每页起始条数
			起始行数=当前页码数-1）*每页显示的条数
	分组查询
	select
		查询的分组字段
		聚合函数
	from 表名
	where 条件
	group by 分组字段
	
		
2.常见的约束有哪些
	默认约束	default
	自增长约束	auto_increment
	唯一约束	unique
	主键约束	primary key
	非空约束	not null
	外键约束	froeign key
				部门表 主表
				员工表 从表
					加入外键约束的语法：
						constraint 外键名称xxx_fk foregin key (从表的dept_id) refenences 主表的主键 部门表（id）

3.delete from和truncate table的区别
	delete from是删除全表数据，不会删除表的结构，而不影响自增长键的位置
	truncate table是删除表以及表中所有数据，重新创建一个一模一样的表，直接影响自增长主键
4.DML语句
	插入数据
		insert into 表名（目标字段） values（值）
		insert into 表名 values（所有字段的赋值）
	删除数据
		delete from 表名 where 条件
	修改数据
		uedet 表名 set 字段=值 where 条件
	查询所有数据
		select * from 表名
	上面的sql语句格式
5.多态的成员特点以及多态的弊端
	成员变量：编译看左，运行看右
	成员方法：编译看左，运行看左
	弊端：不能访问子类的特有功能

级联删除和级联修改

ON  UPDATE CASCADE
添加外键：
ALETR TABLE 主表名 ADD
	CONSTRAINT 主表_fk FOREIGN KEY (从表的id)
	REFERENCES dept(id) ON UPDATE CASCADE 
	
ON DELETE CASCADE 
外键约束
	员工表的id与部门表id关联时，需先改动从表，在修改主表，操作异常繁琐
	mysql提供级联，只要修改主表，从表就会跟着改变

数据库设计原则

什么是范式：设计一些规则来优化数据库的设计和存储，就是范式
三大范式：
	第一范式：1NF：第一范式的每一列不可再才分：原子性操作
	第二范式：2NF：满足第一范式的前提下：表中的每一个字段都完全依赖于主键
	特点：
		一张表只完成一件事
		不产生局部依赖
	第三范式：3NF：不产生传递依赖，表中每一列都直接依赖主键，而不是通过其他列间接依赖主键

表和表之间的关系

一对多：部门与员工
	外键唯一
	外键作为主键
一对一：学生选课表
多对多：
	需要创建三张表

MySQL的多表查询

通过查询两张或者两张以上的表使用
语法格式：
	select * from 表名1，表名2；
	存在问题，产生了笛卡尔乘积：A表中有n条数据，B表中有m条数据，若直接查询，----共有m*n条数据
	解决方案：1）查询哪个表--员工表和部门表
			2）查询每个表中的那些字段--查询所有
			3）这些表的连接条件--员工表的dept_id依赖于部门表的主键id
笛卡尔乘积（有问题的多表查询）
			内连接
				隐式内连接：使用where 后面连接条件
				显式内连接：select 字段 from 表名1 inner join 表名2 on 连接条件
隐式：
	查询所有：	select * from emp，dept where emp.dept_id=dept.id;   :隐式内连接
	查询指定字段：select emp.name,emp.gender,emp.salary...depy.name from emp，dept where emp.dept_id=dept.id;
	使用别名操作：select t1.*,t2.name from emp （as） t1,depy （as） t2 where t1.dept_id=t2.id;
显示：
	select 列名列表 from 表名1 inner（可省略） join 表名2 on 连接条件
	select t1.name,....t2.name from emp t1 inner join dept t2 on t1.dept_id=t2.id;
	
			外连接
				左连接：left outer join
					select 字段列表 from 左表 left outer join 右表 on 连接条件
SELECT t1.*,t2.name FROM emp t1 LEFT OUTER JOIN DEPT T2 ON t1,dept_id=t2.id;
				右连接：right outer join
					select 字段列表 from 右表 rigth outer join 左表 on 连接条件
SELECT t1.name,t2.* FROM dept t1 rigth outer join emp t2 on t1.id=t2.dept_id;

子查询
	select 嵌套select语句
		select 字段列表 from 表名1 where 表达式 
										select 字段列表 from 表名.....
SELECT * FROM emp WHERE salary=(SELECT MAX(salary) FROM EMP);
	
IN语句优化or语句
		可以使用in（）语句优化or语句,in（集合数据）中的关系为或
			dept_id IN（2，3）；
使用虚表查询
SELECT t1.name,t2.name... FROM dept t1 LEFT JOIN (SELECT * FROM emp WHERE join_date>'2011-11-11') t2 on t1.id=t2.dept_id;

	1：单行单列：
		xx<70 ====70 select avg(math) from表名
	2：单行多列
	3：多行多列
		将某个表查询出来的结果作为一个虚表（给虚表起别名），继续查询select 语句嵌套 select语句（性能差）

数据库的备份与还原

dos中的使用
	备份的语法格式：mysqldimp -u用户名 -p密码 数据库名称 > 保存的路径
sqlyog图形界面化中使用
	进入sqlyog工具中----在数据库上面右键 ---选择备份
还原数据库：
1）进入dos后：登录mysql数据库
删除当前的mydb_04这个数据库
source 之前备份的sql文件路径 ---回车
2）图形界面化方式：
在sqlyog中删除当前mydb_04数据库----在数据库上右键选择---以sql的转存文件来导入

musql数据库的事务

transaction:事务
传统事务：将整个业务操作看做一个整体
	举例：一个具体的操作，要么同时成功，要么同时失败
默认数据库的事务：自动提交

事务的特性：
​	ACID
	原子性：（A）每个事务都是一个整体，不可再拆分
	一致性：（C）事务在执行前数据库的状态与执行后数据库的状态保持一致
	隔离性：（I）事务和事务之间是独立的：修改账户，添加/删除账户.....每一个业务都是独立业务
	持久性：（D）一旦事务执行成功，操作持久（永久存储）
模拟转账操作：
	start transaction：开启事务
	rollback：回顾事务---回滚到操作语句之前
	commit：提交数据
查看当前提交方式：
SELECT @@autocommit;--1）----默认自动提交
SET @@autocommit=0；---非自动提交

START TRANSACTION;--开启事务
开始转账，一人减500，一人+500；
一旦出错：回滚事务--回滚到转账之前的状态：
ROLLBACK;--回滚事务
COMMIT;--提交数据

mysql的事务级别

SELECT @@tx_isolation;--查看事务的隔离级别
mwsql的隔离级别：默认第三种：repeatable-read:可重复读
四个隔离级别：
read uncommitted ：读未提交	--安全性最差，会出现脏读现象，读取到未提交的数据
read coommitted：读已提交	--不可重复读，两次的读取数据不一样，能够看出变化
repeatable read：可重复读	--可以防止不可重复读，需要提交事务后，才能显示结果
serializeable ：串行话---隔离级别最高
隔离级别越高，性能越低
SET GLOBAL TRANSACTION ISOLATION LEVEL 隔离级别名称：--语法

JDBC

本质：SUN公司提供的一套接口规范：数据库厂商提供的驱动实现类

1）导入jar包---在java工程下创建lib目录---将所有第三方的jar包放进来
2）注册驱动    获取数据库连接
	注册驱动：Clsaa.forName("com.mysql.jdbc.Driver");
	创建对象：
	java.sql 类 DriverManager：驱动管库类
		Connection conn=DriverManager.getConnection(url,user,password)
		url：jdbc：mysql：//localhost:3306/mydb_05"
		user:"root"
		password:"123456"
3）//准备sql语句
	STring sql="update account set balance = balance +500 where id=1;"
	Statement stmt=conn.createStatement();
	int count =stmt.executeUpdate(sql);
	System.out.println("影响了"+count+"行");
	stmt.close();
	conn.close();
	
	
类 DriverManager
4）通过数据库连接对象获取执行对象
5）执行sql语句，向数据库服务器发送指令
6）返回结果
7）释放资源

小题：

1.事务的隔离级别，mysql的默认隔离级别

四个隔离级别：
read uncommitted ：读未提交	--安全性最差，会出现脏读现象，读取到未提交的数据
read coommitted：读已提交	--不可重复读，两次的读取数据不一样，能够看出变化
repeatable read：可重复读	--可以防止不可重复读，需要提交事务后，才能显示结果
serializeable ：串行话---隔离级别最高
mwsql的隔离级别：默认第三种：repeatable-read:可重复读

2.Mysql事务的特点
事务的特性：
​	ACID
	原子性：（A）每个事务都是一个整体，不可再拆分
	一致性：（C）事务在执行前数据库的状态与执行后数据库的状态保持一致
	隔离性：（I）事务和事务之间是独立的：修改账户，添加/删除账户.....每一个业务都是独立业务
	持久性：（D）一旦事务执行成功，操作持久（永久存储）
	
3.JDBC的本质是什么
本质：SUN公司提供的一套接口规范：数据库厂商提供的驱动实现类

4.JDBC的操作步骤是什么
1）导入jar包---在java工程下创建lib目录---将所有第三方的jar包放进来
2）注册驱动    获取数据库连接
3）准备sql语句
4）通过数据库连接对象获取执行对象
5）执行sql语句，向数据库服务器发送指令
6）返回结果
7）释放资源

5.针对数据库事务的基本操作是什么
	start transaction：开启事务
	rollback：回顾事务---回滚到操作语句之前
	commit：提交数据

JDBC中涉及相关的核心类以及核心接口的API

com.mysql.jdbc.Driver ---->Class类
Class.forName("com.mysql.jdbc.Driver");为了保证向下兼容性
com.myaql.jdbc.Driver---->这个类加载，静态代码块也会随之加载
static{
DriverManager.registerDriver(Driver driver)----这里面已经注册过了

}
2.获取数据连接对象
	核心类：
	DriverManager---->驱动管理类---管理JDBC驱动程序服务
		成员方法：
			registerDriver(Driver driver):注册驱动
			getConnection(url,user,passwrd):获取数据库连接对象
3. Connertion -----java.sql.Connertion
	与指定的数据库的一种会话，--通过系统的资源获取 
	成员方法：
		与事务相关的方法：
			setAutoCommit(boolean autoCommit):设置数据库的提交方式
			rollback():事务回滚
			commit（）：事务提交
		与数据库执行对象的相关方法：
			createStatement():创建Statement对象。将指定的sql发送到数据库中
			perpareStatement(String sql)：将类似于
				insert into account values(?,?,?);sql语句进行预编译
4.Statement
	执行对象：执行静态sql语句
	静态sql语句：
		添加表中成员或者修改数据
	成员方法：
		executeUpdate(sql过Statement将静态的sql语句发生带数据库中进行操作
		executeQuery(sql):执行查询语句select
5.PreparSatement：预编译对象
	
			

JDBC的基本使用

1）执行DDL语句	创建表
2）执行DML语句
	insert into...
	update...
	delete...

JDBC操作查询语句

ResultSet----->java.sql.RrsultSet:查询数据表中的结果集

封装工具类：DButils

将重复性代码抽取出来
---将url，user，password，驱动核心类com.myaql.driver----封装到jdbc.properited文件中

Statement/PreparedStatment

后者比前者安全
Statement对象：
弊端：
	1）执行效率差
		每一次发送sql语句之前，获取Statement
		executeUpdate（String sql）
		executQuery（String sql）
	2）存在安全漏洞：sql注入：存在字符串拼接
		一旦后台被攻击，可以sql注入行为串改数据
提供执行效率，以及防止sql注入
sun公司提供了一个接口：
	PreparedStatement
		将参数化的sql语句先进行预编译（在PreparedStatement对象中 内存中）
		参数化的sql语句不存在硬编码的拼接

小题：

1.事务的隔离级别
四个隔离级别：
read uncommitted ：读未提交	--安全性最差，会出现脏读现象，读取到未提交的数据
read coommitted：读已提交	--不可重复读，两次的读取数据不一样，能够看出变化
repeatable read：可重复读	--可以防止不可重复读，需要提交事务后，才能显示结果
serializeable ：串行话---隔离级别最高

2.Statement和PreparedStatement的区别
	执行对象：
	Statement操作的是静态sql语句
		DDL/DML/DQL语句中的数据已经写死
		通过连接对象获取Statement
		Statement发送到sql中，操作sql语句效率低
		存在字符串拼接，造成sql注入
	PerparedStatement：预编译对象
	通过连接对象获取预编译对象的同时将参数化的sql发送数据库进行预编译
		相对于Statement对象，执行效率高
		能够有效防止sql注入
		DDL/DML
			insert into concat values(?,?,?,?)
			update concat set name=.. where id=...；
		DQL
			select * from concat where id=..;
		通过setXXX（占位符索引值）对占位符号进行赋值
		
3.PerparedSatement执行DDL和DQL的基本操作
	1）注册驱动
	2）获取数据库连接
	3）准备参数化的sql语句
	4）通过连接对象获取预编译对象
	5）参数赋值（占位符）
	6）执行
		DDL/DML
		DQL
		查询的话还需要遍历结果集
		dao层
			public list<Concat> findAll（）；：查询所有
	
	
4.原生JDBC的操作步骤
1）导入jar包---在java工程下创建lib目录---将所有第三方的jar包放进来
2）注册驱动    获取数据库连接对象
3）准备sql语句
4）通过数据库连接对象获取执行对象
5）执行sql语句，向数据库服务器发送指令
6）返回结果
7）释放资源

5.jdbc工具类的封装步骤
	静态代码块static{
		将jdbc.propertoes配置文件加载到属性集合中
		获取里面参数信息
		droverClass
		url
		password
		注册驱动
	}
	封装获取连接对象的方法getConnection（）
	封装释放资源的方法close（）

jdbc方式处理事务

在处理异常的catch中添加：
	if(count!=null){
		count.rollback();
	}

连接池技术

生成字段参与连接池的Connection对象
连接对象可以重复利用
	固定的，可重用的----使用完毕后，会再次归还到连接池中
自动参与连接

sun提供了接口：
	java.sql.DataSource:物理数据源的连接----代替了DriverManager工具
		成员方法：
			getConnection（）；			
驱动类的厂商提供：
	c3p0核心jar包	---日志记录
	druid核心jar包
	dbcp核心jar包
c3p0连接池：---相关jar包
1）导入jar包
	c3p0-0.9.5.2.jar --核心jar包
	mchange-commons-java-0.2.12.jar --依赖包
2）需要将c3p0核心配置文件存储在src目录下	自动读取
	两种方式
		c3p0.properties
		c3p0-config/xml ------sprong,springmvc,mybatis主流xml文件读取框架
3）配置文件中提供了一些基本参数
	driverClass：驱动实现
	jdbcUrl：裂解特定的数据库
	user：用户名
	password：密码
	连接池参数信息
	initialPooSize：初始化连接数量
	maxPoolSize：最大连接数量
	checkoutTimeout：超时时间，如果超过指定时间没连接上，就会出现异常
	
	

封装工具类

获取的连接对象---使用连接池来获取连接对象
	创建c3p0连接池对象
		ComboPooledDataSource dataSource=new ComboPooledDataSource（）；
		dataSource.getConnection();//获取日志（可直接用输出语句输出）
	
关闭释放资源方法
静态代码块：
	读取配置文件

Dbutils的引入-- apacje开

1）导入dbutils-1.7.jar包
2）创建执行对象：QueryRunner（DataSourer ds）
3）准备sql语句：参数化的sql
4）执行
	update（String sql，object...params）
	query（String sql，ResultSetHandler rsu，Obiect....params）

HTML

基础：
	常用的文本标签
		水平线
		标题标签
		换行
		段落
		滚动：marquee
		列表标签
			无序：ul li
			有序：ol li
		上下标标签
		图像标签：img
		超链接：a
			href=“url”
			target
		表格标签：table
			属性：boreder bgColor algin
			行标签：tr
			使用单元格：lie 
		表单：form
			get方式提交数据
			1）直接将数据提交url地址栏上
			2）不适合提交隐私数据
			2）由于是提交到地址栏上，提交的诗句大小有限制
			put方式提交数据
			1）不会将用户数据提交在地址栏上
				存在 请求头先
				提交方式：get/post 密码数据---使用MD5加密
			2）相对于get方式，相对安全
			3）不是直接提交在地址栏上，提交的数据大小没有限制
			
			input标签：字跟在后表示可选的点（前提，有复选框），跟在前表示框
				type=“text”文本输入框
					=“password”密码输入框
					=“date”日期组件
					=“radio”单项按钮
					=“submit”提交按钮
					=“checkbox”复选框value=“默认值”可以选中
					=“reset”重置按钮
					=“button” value=“按钮名字”：单击按钮
					=“hide” name=“id” 隐藏域：没有效果，可以携带数据到后台
			select标签：name=“pro”：下拉菜单
				option：下拉选项：可添加多个表示并列

小题：

1.原生JDBC的步骤操作
1）导入jar包
2）注册驱动
3）获取数据库连接
4）准备sql语句
5）获取数据库连接对象，获取执行对象
6）执行sql语句（预编译）
7）返回结果
8）释放资源
2.DButils工具类中ResiltsetHandler接口下
	BeanHandler和BeanListHandler子实现类的区别
		BeanHandler针对将某条记录数据封装到一个实体对象
		BeanListHandler将查询的记录封装到一个集合List
		
3.获取字节码文件的方式
1）任意类的getClass属性
2）任意java类型的Class属性
3）Class.forName("类的全限定名称")
4.PerparedStatement针对参数化sql的执行操作
准备参数化的sql
select*from user where id=？
预编译
	Connection
		PreparStatement stmt=PreparStatement（String sql）；
		给参数赋值
		stmt.setXXX(1,实际参数)
		执行sql
		executeUpdate（）
		executeQuery（）
5.多态的成员访问特点以及多态的前提条件
成员变量：编译看左，运行看左
成员方法：编译看左，运行看右
前提：存在继承关系
	有方法的重写
	父类引用指向子类对象

CSS基本使用

Cacading Style Sheet：层叠样式
修饰html标签
1）行类样式，在html标签中使用
	每个html标签都有style属性
	弊端：
		1)只针对一个html进行修饰
		2）css代码和html、标签混到一块
2）在held标签中定义style标签
3）外部方式
在css文件夹下单独创建一个.css文件
在当前html页面引入css文件
在head标签体中指定link href=“引入css文件”

css选择器

1）标签选择器
选中所有同名标签
	标签名称{
	样式代码
	}
	<style>{
		div{
		font-size:30px;
		color:blank;
		}.class{}
	}
	<style />
2）class类选择器
可以选中页面标签中所有的同名属性
	.class{属性}
类选择器大于标签选择器
3）id选择器
在页面标签中必须指定唯一的id属性值
	id属性值不能重复
	格式：
	#选择器名{
	属性
	}
交集选择器--子元（后代）素选择器
	选择1 选择2{
		css样式代码
	}
	选中当前标签下所有标签
	#d1 span{
	属性
	}
	<div>
		<span>
			<span>
	选中div下的所有子标签
通用选择器
	*：通配符
	*{
		属性
	}
	
描述标签状态：
	link：鼠标没有访问的状态
	hover：鼠标经过标签的状态
	active：激活状态  鼠标点击没有松开的状态
	visited：已经访问过的：点击松开后的状态
	格式：
		选择器：状态{
			css样式代码
		}
	提示：在 CSS 定义中，a:hover 必须被置于 a:link 和 a:visited 之后，才是有效的。
	提示：在 CSS 定义中，a:active 必须被置于 a:hover 之后，才是有效的。
 /*访问过的状态,点击了并松开了 visited*/
			 a:visited{
				 font-size: 20px;
				 color: darkgray;
				 text-decoration: none;
			 }

小题：

1.HTML常用文本标签，列举
	div：块标签
	span：行内标签
	ul li：无序列表
	ol li：有序
	p：段落
	br：换行
	font：字体
	.....
2.表单标签form中的method提交方式与get和post的区别
	get是默认提交方式
	常用的：get/post	（表单中的表单项，必填的属性name）
		get：直接在地址栏上访问，
			1）将数据提交在地址栏上显示
			2）不适合提交隐私数据
			3）提交的数据大小有限制
		post：
			1）数据不会显示在地址栏上
				浏览器--调试器中可以看到
				request headers
				请求头信息
				from Data 实体内容
			2）相对安全，适合私密数据
			3）提交的数据大小没有限制
3.常见的表单标签子项列举
	select
		option
	input
		type：radio单选按钮
			 checkbox复选框
			 text文本输入框
			 password密码输入框
			 date日期组件
			 email邮箱组件
			 hidden隐藏域
			 file文件上传
			 sumit提交按钮
			 button	value=“xxx”单击按钮
			 reset重置按钮
4.CSS的常用选择器，以及id，标签，类选择器的优先级
	标签选择器
	类选择器
	id选择器
	子元素选择器
		selector1 selecter2
	优先级：id选择器>类选择器>标签选择器
5.frameset框架标签rows和cols的区别
rows：横向划分（由上而下每一部分占的百分比）
cols：由左到右，每一个部分占的百分比
frameset集合frame使用

css一些属性样式

选择器{
样式属性：属性值
}
css字体样式
	文本样式
	背景样式
	列表样式
	边框样式
	表格样式
	浮动属性
	定位属性
		相对定位
		固定定位
		绝对定位
	

css盒子模型

万物皆盒子
将黑一个标签用div包裹起来
css属性	控制标签样式
div+Css---层级分布
盒子模型
	盒子侯东--border 边框大小

Javascript引入