JavaWeb笔记 黑马程序员课程
JavaWeb
摘要
主要用于记录JavaWeb的学习过程，希望对大家有所帮助。
该学习是基于黑马的JavaWeb课程，感兴趣的盆友可以在b站搜索javaweb进行观看学习。
Day 01 内容
04/07/2020
* Junit单元测试
* 反射
* 注解
Junit单元测试：
* 测试分类：
* 黑盒测试：不需要写代码，给输入值，看程序能否输出期望值。
* 白盒测试：需要写代码。关注程序具体的执行流程。
* Junit使用：白盒测试
* 步骤：
1. 定义一个测试类(测试用例)
* 建议：
* 测试类名：被测试的类名Test calculatorTest
* 包名：xxx.xxx.xxx.test
2. 定义测试方法：可以独立运行
* 建议：
* 方法名：test测试的方法名 testadd
* 返回值：void
* 参数列表：空参
3. 给方法加@Test
4. 导入Junit依赖环境
* 判定结果：
* 红色：失败
* 绿色：成功
* 一般我们会使用断言操作来处理结果：
* Assert.assertEquals(期望的结果, 运算的结果);
* 补充
* @before：
* 修饰的方法会在测试方法之前被自动执行
* @after：
* 修饰的方法会在测试方法执行之后被自动执行
反射：框架设计的灵魂
* 框架：半成品软件。可以在框架的基础上进行软件开发，简化编码
* 反射：将类的各个组成部分封装为其他对象，这就是反射机制
* 好处：
1. 可以在程序运行过程中，操作这些对象。
2. 可以解耦，提高程序的可扩展性
* 获取Class对象的方式：
1. Class.forName("全类名"); 将字节码文件加载进内存，返回Class对象
* 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
2. 类名.class; 通过类名的属性class来获取
* 多用于参数的传递
3. 对象.getClass(); getClass()方法在Object类中定义
* 多用于对象的获取字节码的方式
* 结论：同一个字节码文件(*.class)在一次程序的运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。
* Class对象功能：
* 获取功能：
1. 获取成员变量们
* Field[] getFileds()
* Filed getFiled(String name)
* Field[] getDeclaredFileds()
* Filed getDeclaredFiled(String name)
2. 获取构造方法们
* Constructor[] getConstructors()
* Constructor\ getConstructor(类\... parameterTypes)
* Constructor[] getDeclaredConstructors()
* Constructor\ getDeclaredConstructor(类\... parameterTypes)
3. 获取成员方法们
* Method[] getMethods()
* Method getMethod(String name)
* Method[] getDeclaredMethods()
* Method getDeclaredMethod(String name)
4. 获取类名
* String getName()
* Field：成员变量
* 操作：
1. 设置值
* void set(Object obj, Object value)
2. 获取值
* get(Object obj)
3. 忽略访问权限修饰符的安全检查
* setAccessible(true)：暴力反射
* Constructor：构造方法
* 创建对象：
* T newInstance(Object... initargs)
* 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法
* Method：方法对象
* 执行方法：
* Object invoke(Object obj, Object... args)
* 获取方法名称：
* String getName()获取方法名
* 案例：
* 需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法。
* 实现：
1. 配置文件
2. 反射
* 步骤：
1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
2. 在程序中去加载读取配置文件
3. 使用反射技术来加载类文件进内存
4. 创建对象
5. 执行方法
注解：
* 概念：说明程序的。给计算机看的。
* 注释：用文字描述程序。给程序员看的。
* 概念描述：
* jdk1.5之后的新特性
* 说明程序的
* 使用注解：@注解名称
* 作用分类
* 编写文档：生成文档【doc文档】
* 代码分析：通过注解对代码进行分析【使用反射】
* 编译检查：让编辑器能实现基本的编译检查【@Override】
* JDK中预定义的一些注解
* @Override：检测被该注解标注的方法是否是继承自父类(接口)的
* @Deprecated：将该注解标注的内容，表示已过时
* @SuppressWarnings：压制警告
* 一般传递参数all @SuppressWarnings("all")
* 自定义注解
* 格式：
* 元注解
* public @interface 注解名称() {
属性列表;
}
* 本质：注解本质上就是一个接口，该接口默认继承Annotation
* public interface 注解名称 extends java.lang.annotation.Annotation {}
* 属性：接口中的抽象方法
* 要求：
1. 属性的返回值类型有下列取值：
* 基本数据类型
* String
* 枚举
* 注解
* 以上类型的数组
2. 定义了属性，在使用时需要给属性赋值
1. 如果定义属性时，使用default关键字给属性默认初始值，则使用注解时可以不进行属性的赋值
2. 如果只有一个属性需要赋值，并且属性的名称为value，则value可以省略，直接定义值即可【@SuppressWarnings】
3. 数组赋值时，值使用{}包裹，如果数组中只有一个值，则{}可以省略
* 元注解：用于描述注解的注解
* @Target：描述注解能够作用的位置
* ElementType取值：
* TYPE：可以作用于类上
* METHOD：可以作用于方法上
* FIELD：可以作用于成员变量上
* @Retention：描述注解被保留的一个阶段
* @Rentention(RententionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
* @Documented：描述注解是否被抽取到api文档中
* @Inherited：描述注解是否被子类继承
* 在程序中使用(解析)注解：获取注解中定义的属性值
1. 获取注解定义的位置的对象 【Class，Method，Field】
2. 获取指定的注解
* getAnnotation(Class)
* public class ProImpl implements Pro{
public String className(){
return "day01.annotation.Demo1";
}
public String methodName(){
return "show";
}
}
3. 调用注解中的抽象方法，获取配置的属性值
* 小结
1. 以后大多数时候，我们会使用注解，而不是自定义注解
2. 注解给谁用？
1. 编译器
2. 给解析程序用
3. 注解不是程序的一部分，可以理解为注解就是一个标签
Day 02 内容
05/07/2020
* 数据库的基本概念
* MySQL数据库软件
* 安装
* 卸载
* 配置
* SQL
数据库的基本概念
1. 数据库的英文单词：DataBase 简称 ： DB
2. 什么是数据库？
* 用于存储和管理数据的仓库。
3. 数据库的特点：
1. 持久化存储数据的。其实数据库就是一个文件系统
2. 方便存储和管理数据
3. 使用了统一的方式来操作数据库 -- SQL
4. 常见的数据库软件
* 参见《MySQL基础.pdf》
MySQL数据库软件
1. 安装
* 参见《MySQL基础.pdf》
2. 卸载
1. 去mysql的安装目录找到my.ini文件
* 复制 datadir="C:/ProgramData/MySQL/MySQL Server 5.5/Data"
2. 卸载MySQL
3. 删除C:/ProgramData目录下的MySQL文件夹。
3. 配置
* MySQL服务启动
1. 手动
2. cmd--> services.msc 打开服务的窗口
3. 使用管理员打开cmd
* net start mysql ：启动mysql的服务
* net stop mysql ：关闭mysql的服务
* MySQL登录
1. mysql -uroot -p【password】
2. mysql -h【ip】 -uroot -p【连接目标的password】
3. mysql --host=【ip】 --user=root --password=【密码】
* MySQL退出
1. exit
2. quit
* MySQL目录结构
1. MySQL安装目录
* 配置文件 my.ini
2. MySQL数据目录
* 几个概念
* 数据库：文件夹
* 表：文件
* 数据：数据
SQL
1. 什么是SQL?
Structured Query Language：结构化编程语言
其实就是定义了操作所有关系型数据库的规则。每一种数据库操作的方式存在不一样的地方，称为"方言"
2. SQL通用语法
1. SQL语句可以单行或多行书写，以分号结尾。
2. 可使用空格和缩进来增强语句的可读性。
3. MySQL数据库的SQL语句不区分大小写，关键字建议使用大写。
4. 3种注释
* 单行注释：-- 注释内容 或 # 注释内容(mysql 特有)
* 多行注释：/* 注释 */
3. 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 数据库名称;
* 创建数据库，判断不存在，再创建：
* create database if not exists 数据库名称;
* 创建数据库，并指定字符集
* create database 数据库名称 character set 字符集名;
* 练习： 创建db4数据库，判断是否存在，并制定字符集为gbk
* create database if not exists db4 character set gbk;
2. R(Retrieve)：查询
* 查询所有数据库的名称:
* show databases;
* 查询某个数据库的字符集:查询某个数据库的创建语句
* show create database 数据库名称;
3. U(Update):修改
* 修改数据库的字符集
* alter database 数据库名称 character set 字符集名称;
4. D(Delete):删除
* 删除数据库
* drop database 数据库名称;
* 判断数据库存在，存在再删除
* drop database if exists 数据库名称;
5. 使用数据库
* 查询当前正在使用的数据库名称
* select database();
* 使用数据库
* use 数据库名称;
2. 操作表
1. C(Create):创建
1. 语法：
create table 表名(
列名1 数据类型1,
列名2 数据类型2,
....
列名n 数据类型n
);
* 注意：最后一列，不需要加逗号（,）
* 数据库类型：
1. int：整数类型
* age int,
2. double:小数类型
* score double(5,2)
3. date:日期，只包含年月日，yyyy-MM-dd
4. datetime:日期，包含年月日时分秒 yyyy-MM-dd HH:mm:ss
5. timestamp:时间戳类型 包含年月日时分秒 yyyy-MM-dd HH:mm:ss
* 如果将来不给这个字段赋值，或赋值为null，则默认使用当前的系统时间，来自动赋值
6. varchar：字符串
* name varchar(20):姓名最大20个字符
* zhangsan 8个字符 张三 2个字符
* 创建表：
create table student(
id int,
name varchar(32),
age int ,
score double(4,1),
birthday date,
insert_time timestamp
);
* 复制表：
* create table 表名 like 被复制的表名;
2. R(Retrieve)：查询
* 查询某个数据库中所有的表名称
* show tables;
* 查询表结构
* 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 表名;
* drop table if exists 表名 ;
-
客户端图形化工具：SQLYog
-
添加数据：
- 语法：
- insert into 表名(列名1,列名2,…列名n) values(值1,值2,…值n);
- 注意：
- 列名和值要一一对应。
- 如果表名后，不定义列名，则默认给所有列添加值
insert into 表名 values(值1,值2,…值n); - 除了数字类型，其他类型需要使用引号(单双都可以)引起来
- 语法：
-
删除数据：
- 语法：
- delete from 表名 [where 条件]
- 注意：
- 如果不加条件，则删除表中所有记录。
- 如果要删除所有记录
- delete from 表名; – 不推荐使用。有多少条记录就会执行多少次删除操作
- TRUNCATE TABLE 表名; – 推荐使用，效率更高 先删除表，然后再创建一张一样的表。
- 语法：
-
修改数据：
-
语法：
- update 表名 set 列名1 = 值1, 列名2 = 值2,… [where 条件];
-
注意：
- 如果不加任何条件，则会将表中所有记录全部修改。
-
-
Day 03 内容
06/07/2020
1. DQL:查询语句
1. 排序查询
2. 聚合函数
3. 分组查询
4. 分页查询
2. 约束
3. 多表之间的关系
4. 范式
5. 数据库的备份和还原
DQL:查询语句
DQL：查询表中的记录
* select * from 表名;
1. 语法：
select
字段列表
from
表名列表
where
条件列表
group by
分组字段
having
分组之后的条件
order by
排序
limit
分页限定
2. 基础查询
1. 多个字段的查询
select 字段名1，字段名2... from 表名;
* 注意：
* 如果查询所有字段，则可以使用*来替代字段列表。
2. 去除重复：
* distinct
3. 计算列
* 一般可以使用四则运算计算一些列的值。（一般只会进行数值型的计算）
* ifnull(表达式1,表达式2)：null参与的运算，计算结果都为null
* 表达式1：哪个字段需要判断是否为null
* 表达式2：如果该字段为null后的替换值。
4. 起别名：
* as：as也可以省略
3. 条件查询
1. where子句后跟条件
2. 运算符
* > 、< 、<= 、>= 、= 、<>
* BETWEEN...AND
* IN( 集合)
* LIKE：模糊查询
* 占位符：
* _:单个任意字符
* %：多个任意字符
* IS NULL
* and 或 &&
* or 或 ||
* not 或 !
-- 查询年龄大于20岁
SELECT * FROM student WHERE age > 20;
SELECT * FROM student WHERE age >= 20;
-- 查询年龄等于20岁
SELECT * FROM student WHERE age = 20;
-- 查询年龄不等于20岁
SELECT * FROM student WHERE age != 20;
SELECT * FROM student WHERE age <> 20;
-- 查询年龄大于等于20 小于等于30
SELECT * FROM student WHERE age >= 20 && age <=30;
SELECT * FROM student WHERE age >= 20 AND age <=30;
SELECT * FROM student WHERE age BETWEEN 20 AND 30;
-- 查询年龄22岁，18岁，25岁的信息
SELECT * FROM student WHERE age = 22 OR age = 18 OR age = 25
SELECT * FROM student WHERE age IN (22,18,25);
-- 查询英语成绩为null
SELECT * FROM student WHERE english = NULL; -- 不对的。null值不能使用 = （!=） 判断
SELECT * FROM student WHERE english IS NULL;
-- 查询英语成绩不为null
SELECT * FROM student WHERE english IS NOT NULL;
-- 查询姓马的有哪些？ like
SELECT * FROM student WHERE NAME LIKE '马%';
-- 查询姓名第二个字是化的人
SELECT * FROM student WHERE NAME LIKE "_化%";
-- 查询姓名是3个字的人
SELECT * FROM student WHERE NAME LIKE '___';
-- 查询姓名中包含德的人
SELECT * FROM student WHERE NAME LIKE '%德%';
中间的部分内容在这里没有给出，因为本人这部分内容已经掌握，所以未给出。
今日内容
1. 多表查询
2. 事务
3. DCL
多表查询
* 查询语法：
select
列名列表
from
表名列表
where....
* 准备sql
# 创建部门表
CREATE TABLE dept(
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(20)
);
INSERT INTO dept (NAME) VALUES ('开发部'),('市场部'),('财务部');
# 创建员工表
CREATE TABLE emp (
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(10),
gender CHAR(1), -- 性别
salary DOUBLE, -- 工资
join_date DATE, -- 入职日期
dept_id INT,
FOREIGN KEY (dept_id) REFERENCES dept(id) -- 外键，关联部门表(部门表的主键)
);
INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('孙悟空','男',7200,'2013-02-24',1);
INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('猪八戒','男',3600,'2010-12-02',2);
INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('唐僧','男',9000,'2008-08-08',2);
INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('白骨精','女',5000,'2015-10-07',3);
INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('蜘蛛精','女',4500,'2011-03-14',1);
* 笛卡尔积：
* 有两个集合A,B .取这两个集合的所有组成情况。
* 要完成多表查询，需要消除无用的数据
* 多表查询的分类：
1. 内连接查询：
1. 隐式内连接：使用where条件消除无用数据
* 例子：
-- 查询所有员工信息和对应的部门信息
SELECT * FROM emp,dept WHERE emp.`dept_id` = dept.`id`;
-- 查询员工表的名称，性别。部门表的名称
SELECT emp.name,emp.gender,dept.name FROM emp,dept WHERE emp.`dept_id` = dept.`id`;
SELECT
t1.name, -- 员工表的姓名
t1.gender,-- 员工表的性别
t2.name -- 部门表的名称
FROM
emp t1,
dept t2
WHERE
t1.`dept_id` = t2.`id`;
2. 显式内连接：
* 语法： select 字段列表 from 表名1 [inner] join 表名2 on 条件
* 例如：
* SELECT * FROM emp INNER JOIN dept ON emp.`dept_id` = dept.`id`;
* SELECT * FROM emp JOIN dept ON emp.`dept_id` = dept.`id`;
3. 内连接查询：
1. 从哪些表中查询数据
2. 条件是什么
3. 查询哪些字段
2. 外链接查询：
1. 左外连接：
* 语法：select 字段列表 from 表1 left [outer] join 表2 on 条件；
* 查询的是左表所有数据以及其交集部分。
* 例子：
-- 查询所有员工信息，如果员工有部门，则查询部门名称，没有部门，则不显示部门名称
SELECT t1.*,t2.`name` FROM emp t1 LEFT JOIN dept t2 ON t1.`dept_id` = t2.`id`;
2. 右外连接：
* 语法：select 字段列表 from 表1 right [outer] join 表2 on 条件；
* 查询的是右表所有数据以及其交集部分。
* 例子：
SELECT * FROM dept t2 RIGHT JOIN emp t1 ON t1.`dept_id` = t2.`id`;
3. 子查询：
* 概念：查询中嵌套查询，称嵌套查询为子查询。
-- 查询工资最高的员工信息
-- 1 查询最高的工资是多少 9000
SELECT MAX(salary) FROM emp;
-- 2 查询员工信息，并且工资等于9000的
SELECT * FROM emp WHERE emp.`salary` = 9000;
-- 一条sql就完成这个操作。子查询
SELECT * FROM emp WHERE emp.`salary` = (SELECT MAX(salary) FROM emp);
* 子查询不同情况
1. 子查询的结果是单行单列的：
* 子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
*
-- 查询员工工资小于平均工资的人
SELECT * FROM emp WHERE emp.salary < (SELECT AVG(salary) FROM emp);
2. 子查询的结果是多行单列的：
* 子查询可以作为条件，使用运算符in来判断
-- 查询'财务部'和'市场部'所有的员工信息
SELECT id FROM dept WHERE NAME = '财务部' OR NAME = '市场部';
SELECT * FROM emp WHERE dept_id = 3 OR dept_id = 2;
-- 子查询
SELECT * FROM emp WHERE dept_id IN (SELECT id FROM dept WHERE NAME = '财务部' OR NAME = '市场部');
3. 子查询的结果是多行多列的：
* 子查询可以作为一张虚拟表参与查询
-- 查询员工入职日期是2011-11-11日之后的员工信息和部门信息
-- 子查询
SELECT * FROM dept t1 ,(SELECT * FROM emp WHERE emp.`join_date` > '2011-11-11') t2
WHERE t1.id = t2.dept_id;
-- 普通内连接
SELECT * FROM emp t1,dept t2 WHERE t1.`dept_id` = t2.`id` AND t1.`join_date` > '2011-11-11'
* 多表查询练习
-- 部门表
CREATE TABLE dept (
id INT PRIMARY KEY PRIMARY KEY, -- 部门id
dname VARCHAR(50), -- 部门名称
loc VARCHAR(50) -- 部门所在地
);
-- 添加4个部门
INSERT INTO dept(id,dname,loc) VALUES
(10,'教研部','北京'),
(20,'学工部','上海'),
(30,'销售部','广州'),
(40,'财务部','深圳');
-- 职务表，职务名称，职务描述
CREATE TABLE job (
id INT PRIMARY KEY,
jname VARCHAR(20),
description VARCHAR(50)
);
-- 添加4个职务
INSERT INTO job (id, jname, description) VALUES
(1, '董事长', '管理整个公司，接单'),
(2, '经理', '管理部门员工'),
(3, '销售员', '向客人推销产品'),
(4, '文员', '使用办公软件');
-- 员工表
CREATE TABLE emp (
id INT PRIMARY KEY, -- 员工id
ename VARCHAR(50), -- 员工姓名
job_id INT, -- 职务id
mgr INT , -- 上级领导
joindate DATE, -- 入职日期
salary DECIMAL(7,2), -- 工资
bonus DECIMAL(7,2), -- 奖金
dept_id INT, -- 所在部门编号
CONSTRAINT emp_jobid_ref_job_id_fk FOREIGN KEY (job_id) REFERENCES job (id),
CONSTRAINT emp_deptid_ref_dept_id_fk FOREIGN KEY (dept_id) REFERENCES dept (id)
);
-- 添加员工
INSERT INTO emp(id,ename,job_id,mgr,joindate,salary,bonus,dept_id) VALUES
(1001,'孙悟空',4,1004,'2000-12-17','8000.00',NULL,20),
(1002,'卢俊义',3,1006,'2001-02-20','16000.00','3000.00',30),
(1003,'林冲',3,1006,'2001-02-22','12500.00','5000.00',30),
(1004,'唐僧',2,1009,'2001-04-02','29750.00',NULL,20),
(1005,'李逵',4,1006,'2001-09-28','12500.00','14000.00',30),
(1006,'宋江',2,1009,'2001-05-01','28500.00',NULL,30),
(1007,'刘备',2,1009,'2001-09-01','24500.00',NULL,10),
(1008,'猪八戒',4,1004,'2007-04-19','30000.00',NULL,20),
(1009,'罗贯中',1,NULL,'2001-11-17','50000.00',NULL,10),
(1010,'吴用',3,1006,'2001-09-08','15000.00','0.00',30),
(1011,'沙僧',4,1004,'2007-05-23','11000.00',NULL,20),
(1012,'李逵',4,1006,'2001-12-03','9500.00',NULL,30),
(1013,'小白龙',4,1004,'2001-12-03','30000.00',NULL,20),
(1014,'关羽',4,1007,'2002-01-23','13000.00',NULL,10);
-- 工资等级表
CREATE TABLE salarygrade (
grade INT PRIMARY KEY, -- 级别
losalary INT, -- 最低工资
hisalary INT -- 最高工资
);
-- 添加5个工资等级
INSERT INTO salarygrade(grade,losalary,hisalary) VALUES
(1,7000,12000),
(2,12010,14000),
(3,14010,20000),
(4,20010,30000),
(5,30010,99990);
-- 需求：
-- 1.查询所有员工信息。查询员工编号，员工姓名，工资，职务名称，职务描述
/*
分析：
1.员工编号，员工姓名，工资，需要查询emp表 职务名称，职务描述 需要查询job表
2.查询条件 emp.job_id = job.id
*/
SELECT
t1.`id`, -- 员工编号
t1.`ename`, -- 员工姓名
t1.`salary`,-- 工资
t2.`jname`, -- 职务名称
t2.`description` -- 职务描述
FROM
emp t1, job t2
WHERE
t1.`job_id` = t2.`id`;
-- 2.查询员工编号，员工姓名，工资，职务名称，职务描述，部门名称，部门位置
/*
分析：
1. 员工编号，员工姓名，工资 emp 职务名称，职务描述 job 部门名称，部门位置 dept
2. 条件： emp.job_id = job.id and emp.dept_id = dept.id
*/
SELECT
t1.`id`, -- 员工编号
t1.`ename`, -- 员工姓名
t1.`salary`,-- 工资
t2.`jname`, -- 职务名称
t2.`description`, -- 职务描述
t3.`dname`, -- 部门名称
t3.`loc` -- 部门位置
FROM
emp t1, job t2,dept t3
WHERE
t1.`job_id` = t2.`id` AND t1.`dept_id` = t3.`id`;
-- 3.查询员工姓名，工资，工资等级
/*
分析：
1.员工姓名，工资 emp 工资等级 salarygrade
2.条件 emp.salary >= salarygrade.losalary and emp.salary <= salarygrade.hisalary
emp.salary BETWEEN salarygrade.losalary and salarygrade.hisalary
*/
SELECT
t1.ename ,
t1.`salary`,
t2.*
FROM emp t1, salarygrade t2
WHERE t1.`salary` BETWEEN t2.`losalary` AND t2.`hisalary`;
-- 4.查询员工姓名，工资，职务名称，职务描述，部门名称，部门位置，工资等级
/*
分析：
1. 员工姓名，工资 emp ， 职务名称，职务描述 job 部门名称，部门位置，dept 工资等级 salarygrade
2. 条件： emp.job_id = job.id and emp.dept_id = dept.id and emp.salary BETWEEN salarygrade.losalary and salarygrade.hisalary
*/
SELECT
t1.`ename`,
t1.`salary`,
t2.`jname`,
t2.`description`,
t3.`dname`,
t3.`loc`,
t4.`grade`
FROM
emp t1,job t2,dept t3,salarygrade t4
WHERE
t1.`job_id` = t2.`id`
AND t1.`dept_id` = t3.`id`
AND t1.`salary` BETWEEN t4.`losalary` AND t4.`hisalary`;
-- 5.查询出部门编号、部门名称、部门位置、部门人数
/*
分析：
1.部门编号、部门名称、部门位置 dept 表。 部门人数 emp表
2.使用分组查询。按照emp.dept_id完成分组，查询count(id)
3.使用子查询将第2步的查询结果和dept表进行关联查询
*/
SELECT
t1.`id`,t1.`dname`,t1.`loc` , t2.total
FROM
dept t1,
(SELECT
dept_id,COUNT(id) total
FROM
emp
GROUP BY dept_id) t2
WHERE t1.`id` = t2.dept_id;
-- 6.查询所有员工的姓名及其直接上级的姓名,没有领导的员工也需要查询
/*
分析：
1.姓名 emp， 直接上级的姓名 emp
* emp表的id 和 mgr 是自关联
2.条件 emp.id = emp.mgr
3.查询左表的所有数据，和 交集数据
* 使用左外连接查询
*/
/*
select
t1.ename,
t1.mgr,
t2.`id`,
t2.ename
from emp t1, emp t2
where t1.mgr = t2.`id`;
*/
SELECT
t1.ename,
t1.mgr,
t2.`id`,
t2.`ename`
FROM emp t1
LEFT JOIN emp t2
ON t1.`mgr` = t2.`id`;
事务
1. 事务的基本介绍
1. 概念：
* 如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败
2. 操作：
1. 开启事务：start transection
2. 回滚：rollback
3. 提交：commit
3. MySQL数据库中事务默认提交
* 事务提交的两种方式：
* 自动提交：
* mysql就是自动提交的
* 一条DML(增删改)语句会自动提交一次事务。
* 手动提交：
* Oracle数据库默认是手动提交事务
* 需要先开启事务，再提交
* 修改事务的默认提交方式：
* 查看事务的默认提交方式：SELECT @@autocommit; -- 1 代表自动提交 0 代表手动提交
* 修改默认提交方式： set @@autocommit = 0;
2. 事务的四大特征
1. 原子性：是不可分割的最小操作单位，要么同时成功，要么同时失败。
2. 持久性：当事务提交或回滚后，数据库会持久化的保存数据。
3. 隔离性：多个事务之间。相互独立。
4. 一致性：事务操作前后，数据总量不变
3. 事务的隔离级别（了解）
* 概念：多个事务之间隔离的，相互独立的。但是如果多个事务操作同一批数据，则会引发一些问题，设置不同的隔离级别就可以解决这些问题。
* 存在问题：
1. 脏读：一个事务，读取到另一个事务中没有提交的数据
2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。
* 隔离级别：
1. read uncommitted：读未提交
* 产生的问题：脏读、不可重复读、幻读
2. read committed：读已提交 （Oracle）
* 产生的问题：不可重复读、幻读
3. repeatable read：可重复读 （MySQL默认）
* 产生的问题：幻读
4. serializable：串行化
* 可以解决所有的问题
* 注意：隔离级别从小到大安全性越来越高，但是效率越来越低
* 数据库查询隔离级别：
* select @@tx_isolation;
* 数据库设置隔离级别：
* set global transaction isolation level 级别字符串;
* 演示：
set global transaction isolation level read uncommitted;
start transaction;
-- 转账操作
update account set balance = balance - 500 where id = 1;
update account set balance = balance + 500 where id = 2;
DCL
* SQL分类：
1. DDL：操作数据库和表
2. DML：增删改表中数据
3. DQL：查询表中数据
4. DCL：管理用户，授权
* DBA：数据库管理员
* DCL：管理用户，授权
1. 管理用户
1. 添加用户：
* 语法：CREATE USER '用户名'@'主机名' IDENTIFIED BY '密码';
2. 删除用户：
* 语法：DROP USER '用户名'@'主机名';
3. 修改用户密码：
UPDATE USER SET PASSWORD = PASSWORD('新密码') WHERE USER = '用户名';
UPDATE USER SET PASSWORD = PASSWORD('abc') WHERE USER = 'lisi';
SET PASSWORD FOR '用户名'@'主机名' = PASSWORD('新密码');
SET PASSWORD FOR 'root'@'localhost' = PASSWORD('123');
* mysql中忘记了root用户的密码？
1. cmd -- > net stop mysql 停止mysql服务
* 需要管理员运行该cmd
2. 使用无验证方式启动mysql服务： mysqld --skip-grant-tables
3. 打开新的cmd窗口,直接输入mysql命令，敲回车。就可以登录成功
4. use mysql;
5. update user set password = password('你的新密码') where user = 'root';
6. 关闭两个窗口
7. 打开任务管理器，手动结束mysqld.exe 的进程
8. 启动mysql服务
9. 使用新密码登录。
4. 查询用户：
-- 1. 切换到mysql数据库
USE myql;
-- 2. 查询user表
SELECT * FROM USER;
* 通配符： % 表示可以在任意主机使用用户登录数据库
2. 权限管理：
1. 查询权限：
-- 查询权限
SHOW GRANTS FOR '用户名'@'主机名';
SHOW GRANTS FOR 'lisi'@'%';
2. 授予权限：
-- 授予权限
grant 权限列表 on 数据库名.表名 to '用户名'@'主机名';
-- 给张三用户授予所有权限，在任意数据库任意表上
GRANT ALL ON *.* TO 'zhangsan'@'localhost';
3. 撤销权限：
-- 撤销权限：
revoke 权限列表 on 数据库名.表名 from '用户名'@'主机名';
REVOKE UPDATE ON db3.`account` FROM 'lisi'@'%';
Day 04 内容：
07/07/2020
1. JDBC基本概念
2. 快速入门
3. 对JDBC中各个接口和类详解
JDBC
1. 概念：Java DataBase Connectivity Java数据库连接，Java语言操作数据库
* JDBC本质：其实是官网(sun公司)定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商可以去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口(JDBC)编程，真正执行的代码是驱动jar包中的实现类
2. 快速入门：
* 步骤：
1. 导入驱动jar包 mysql-connnector-java-x.x.x-bin.jar
1. 复制mysql-connnector-java-x.x.x-bin.jar包到项目libs目录下
2. 右键-->Add as library
2. 注册驱动
3. 获取数据库的连接对象 Connection
4. 定义sql
5. 获取执行sql语句的对象 Statement
6. 执行sql，接收返回结果
7. 处理结果
8. 释放资源
* 代码实现：
// 1.导入驱动jar包
// 2.注册驱动
Class.forName("com.mysql.jdbc.Driver");
// 3.获取数据库连接对象
Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1",
"root", "********");
// 4.定义sql语句
String sql = "insert into test values(1, \"test\")";
// 5.获取执行sql的对象Statement
Statement statement = connection.createStatement();
// 6.执行sql
int count = statement.executeUpdate(sql);
// 7.处理结果
System.out.println(count);
// 8.释放资源
statement.close();
connection.close();
3. 详解各个对象
1. DriverManager: 驱动管理对象
* 功能：
1. 注册驱动：告诉程序该使用哪一个数据库驱动jar包
static void registerDriver(Driver driver): 注册给定的驱动程序 DriverManager
写代码使用: Class.forName("com.mysql.jdbc.Driver");
通过查看源码发现: 在com.mysql.jdbc.Driver类中存在静态代码块
static {
try {
DriverManager.registerDriver(new Driver());
} catch (SQLException var1) {
throw new RuntimeException("Can't register driver!");
}
}
注意：mysql5之后的驱动jar包可以省略注册驱动的步骤
2. 获取数据库连接：
* 方法: static Connerction getConnection(String url, String user, String password)
* 参数：
* url：指定连接的路径
* 语法: jdbc:mysql://ip地址(域名):端口号/数据库名称
* 例子: jdbc:mysql://localhost:3306/db1
* 细节: 如果连接的是本机mysql服务器，并且mysql服务默认端口为3306，则url可以简写为jdbc:mysql:///数据库名称
* user：用户名
* password：密码
2. Connection: 数据库连接对象
1. 功能：
1. 获取执行sql的对象
* Statement createStatement()
* PreparedStatement prepareStatement(String sql)
2。 管理事务：
* 开启事务: void setAutoCommit(boolean autoCommit) : 调用该方法设置参数为false，即开启事务
* 提交事务: void commit()
* 回滚事务: void rollback()
3. Statement: 执行sql的对象
1. 执行sql
1. booleann execute(String sql) : 可以执行任意的sql 了解
2. int executeUpdate(String sql) : 执行DML(insert、update、delete)语句、DDL(create、alter、drop)语句
* 返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功 返回值>0执行成功 反之失败
3. ResultSet executeQuery(String sql) : 执行DQL(select)语句
2. 练习：
1. account表 添加一条记录
2. account表 修改记录
3. account表 删除一条记录
代码:
Connection connection = null;
Statement statement = null;
try {
// 1.注册驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 2.定义sql
String sql = "insert into account values(null, '王五', 3000)";
// 3.获取Connection对象
connection= DriverManager.getConnection("jdbc:mysql:///db1",
"root", "******");
// 4.获取执行sql的对象
statement = connection.createStatement();
// 5.执行sql
int count = statement.executeUpdate(sql);
// 6.处理结果
System.out.println(count);
if(count > 0){
System.out.println("添加成功");
}else{
System.out.println("添加失败");
}
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
} finally {
// 避免空指针异常
if(statement != null){
try {
statement.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(connection != null){
try {
connection.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
4. ResultSet: 结果集对象，封装查询结果
* next()：游标向下移动一行，判断当前行是否是最后一行末尾(是否有数据)，返回boolean值
* getXxx(参数)：获取数据
* Xxx代表数据类型 如: int getInt()
* 参数：
1. int: 代表列的编号，从1开始
2. String: 代表列名称
* 注意：
* 使用步骤：
1. 游标向下移动一行
2. 判断是否有数据
3. 获取数据
while(rs.next()){...}
* 练习：
* 定义一个方法，查询emp表的数据将其封装为对象，然后装载集合，返回。
1. 定义Emp类
2. 定义方法 public List findAll(){}
3. 实现方法 select * from emp;
5. PreparedStatement: 执行sql的对象
1. SQL注入问题: 在拼接SQL时，有一些sql的特殊关键字参与字符串的拼接，会造成安全性问题
1. 输入用户随便，输入密码：a' or 'a' = 'a
2. sql : select * from USER where username = 'xxx' and password = 'a' or 'a' = 'a';
2. 解决sql注入问题：使用PreparedStatement来解决
3. 预编译的SQL：参数使用?作为占位符
4. 步骤：
1. 导入驱动jar包 mysql-connnector-java-x.x.x-bin.jar
2. 注册驱动
3. 获取数据库的连接对象 Connection
4. 定义sql
* 注意：sql的参数使用?作为占位符。如: select * from user where username = ? and password = ?
5. 获取执行sql语句的对象 PreparedStatement Connection.preparedStatement(String sql)
6. 给?赋值:
* 方法：setXxx(参数1, 参数2)
* 参数1: ?的位置编号 从1 开始
* 参数2: ?的值
7. 执行sql，接收返回结果，不需要传递sql语句
8. 处理结果
9. 释放资源
5. 注意：后期都会使用PreparedStatement来完成增删改查的所有操作
1. 可以防止sql注入
2. 效率更高
抽取JDBC工具类 : JDBCUtils
* 目的：简化书写
* 分析：
1. 注册驱动也抽取
2. 抽取一个方法获取连接对象
* 需求：不想传递参数(麻烦)，还得保证工具类的通用性。
* 解决：配置文件
jdbc.properties
url=
user=
password=
3. 抽取一个方法释放资源
* 代码实现：
public class JDBCUtils {
private static String url;
private static String user;
private static String password;
private static String driver;
/**
* 文件的读取只需要读取一次即可拿到这些值，使用静态代码块完成
*/
static {
try {
// 读取资源文件，获取值。
// 1.创建Properties集合类
Properties pro = new Properties();
// 获取src路径下的文件的方式--->ClassLoader 类加载器
ClassLoader classLoader = JDBCUtils.class.getClassLoader();
URL result = classLoader.getResource("jdbc.properties");
String path = result.getPath();
// 2.加载文件
pro.load(new FileReader(path));
// 3.获取属性赋值
url = pro.getProperty("url");
user = pro.getProperty("user");
password = pro.getProperty("password");
driver = pro.getProperty("driver");
// 4.注册驱动
try {
Class.forName(driver);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 获取连接
* @return 连接对象
*/
public static Connection getConnection() throws SQLException {
return DriverManager.getConnection(url, user, password);
}
/**
* 释放资源
* @param statement
* @param connection
*/
public static void close(Statement statement, Connection connection){
if(statement != null){
try {
statement.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(connection != null){
try {
connection.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
public static void close(ResultSet resultSet, Statement statement, Connection connection){
if(statement != null){
try {
statement.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(connection != null){
try {
connection.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(resultSet != null){
try {
resultSet.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
}
* 练习：
* 需求：
1. 通过键盘录入用户名和密码
2. 判断用户是否登录成功
* select * from USER where username = '' and password = '';
* 如果这个sql有查询结果，则成功，反之失败
* 步骤：
1. 创建数据库表 user
CREATE TABLE USER(
id INT PRIMARY KEY AUTO_INCREMENT,
username varchar(32),
password varchar(32)
);
INSERT INTO USER VALUES(NULL,'zhangsan','123');
INSERT INTO USER VALUES(NULL,'lisi','234');
2. 创建一个类
......
JDBC控制事务
1. 事务：一个包含多个步骤的业务操作。如果这个业务操作被事务管理，则者多个步骤要么同时成功，要么同时失败。
2. 操作：
1. 开启事务
2. 提交事务
3. 回滚事务
3. 使用Connection对象来管理事务
* 开启事务: void setAutoCommit(boolean autoCommit) : 调用该方法设置参数为false，即开启事务
* 在执行sql之前开启事务(在获得连接后开启)
* 提交事务: void commit()
* 当所有sql都执行完提交事务
* 回滚事务: void rollback()
* 在catch中回滚事务
Day 05 内容：
1. 数据库连接池
2. Spring JDBC : JDBC Template
数据库连接池
1. 概念：其实就是一个容器(集合)，存放数据库连接的容器
当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。
2. 好处：
1. 节约资源
2. 用户访问高效
3. 实现：
1. 标准接口：DataSource javax.sql包下的
1. 方法：
* 获取连接：getConnection()
* 归还连接：Connection.close()
如果连接对象Connection是从连接池中获取的，那么调用Connection.close()，则不会再关闭连接，而是归还连接。
2. 一般我们不去实现它，由数据库厂商实现
1. C3P0：数据库连接池技术
2. Druid：数据库连接池实现技术，由阿里巴巴提供的
4. C3P0：数据库连接池技术
* 步骤：
1. 导入jar包 (两个)c3p0-0.6.5.2.jar mchange-commons-java-0.2.12.jar
* 不要忘记导入数据库驱动jar包
2. 定义配置文件：
* 名称：c3p0.properties 或者 c3p0-config.xml
* 路径：直接将文件放在src目录下即可
3. 创建核心对象：数据库连接池对象 ComboPooledDataSource
4. 获取连接：getConnection()
5. Druid：数据库连接池实现技术，由阿里巴巴提供的
1. 步骤：
1. 导入jar包 druid-1.0.9.jar
2. 定义配置文件：
* 是properties形式的
* 可以叫任意名称，可以放在任意目录下
3. 加载配置文件 Properties
4. 获取数据库连接池对象：通过工厂类来获取 DruidDataSourceFactory
5. 获取连接：getConnection()
2. 定义工具类
1. 定义一个类 JDBCUtils
2. 提供静态代码块加载配置文件，初始化连接池对象
3. 提供方法
1. 获取连接方法：通过数据库连接池获取连接
2. 释放资源
3. 获取连接池的方法
代码:
/**
* Druid连接池的工具类
*/
public class JDBCUtils {
// 1.定义成员变量 DataSource
private static DataSource ds;
static {
try {
// 1.加载配置文件
Properties pro = new Properties();
pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
// 2.获取DataSource
ds = DruidDataSourceFactory.createDataSource(pro);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取连接
*/
public static Connection getConnection() throws SQLException {
return ds.getConnection();
}
/**
* 释放资源
* @param statement
* @param connection
*/
public static void close(Statement statement, Connection connection){
if(statement != null){
try {
statement.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(connection != null){
try {
connection.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
public static void close(ResultSet resultSet, Statement statement, Connection connection){
if(statement != null){
try {
statement.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(connection != null){
try {
connection.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(resultSet != null){
try {
resultSet.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
/**
* 获取连接池方法
*/
public static DataSource getDataSource(){
return ds;
}
}
Spring JDBC
* Spring框架对JDBC的简单封装。提供了JDBC Template对象简化JDBC的开发
* 步骤：
1. 导入jar包
2. 创建JdbcTemplate对象。依赖于数据源DataSource
* JdbcTemplate template = new JdbcTemplate(ds);
3. 调用JdbcTemplate的方法来完成CRUD的操作
* update(): 执行DML语句。增、删、改语句
* queryForMap(): 查询结果，将结果集封装为Map集合，将列名作为key，将值作为value，将这条记录封装为value
* 注意：这个方法查询的结果集长度只能是1
* queryForList(): 查询结果，将结果集封装为list集合
* 注意：将每一条记录封装为Map集合，再将Map集合装载在List集合中
* query(): 查询结果，将结果封装为JavaBean对象
* query方法的参数：RowMapper
* 一般使用BeanPropertiyRowMapper实现类。可以完成数据到JavaBean的自动封装。
* new BeanPropertyRowMapper<类型>(类型.class)
* queryForObject(): 查询结果，将结果封装为对象
* 一般用于聚合函数的查询
4. 练习：
* 需求：
1. 修改1号数据的 salary 为 10000
2. 添加一条记录
3. 删除刚才添加的记录
4. 查询id为1的记录，将其封装为Map集合
5. 查询所有的记录，将其封装为List集合
6. 查询所有记录，将其封装为Emp对象的List集合
7. 查询总的记录数
Day 06 内容：
1. web概念概述
2. HTML
web概念概述
* JavaWeb：
* 使用Java语言开发基于互联网的项目
* 软件的架构：
1. C/S：Client/Server 客户端/服务器端
* 在用户本地有一个客户端程序，在远程有一个服务器端程序
* 如：QQ，迅雷...
* 优点：
1. 用户体验好
* 缺点：
1. 开发、安装、部署、维护麻烦
2. B/S：Browser/Server 浏览器/服务器端
* 只需要一个浏览器，用户通过不同的网址(URL)，可以访问远程不同的服务器端程序
* 优点：
1. 开发、安装、部署、维护简单
* 缺点：
1. 如果应用过大，用户的体验可能会受到影响
2. 对硬件要求过高
* B/S架构详解
* 资源分类：
1. 静态资源：
* 使用静态网页开发技术发布的资源
* 特点：
* 所有用户访问，得到的结果是一样的
* 如：文本、图片、音频、视频，HTML,CSS,JavaScript
* 如果用户请求的是静态资源，那么服务器会直接将静态资源发送给浏览器，浏览器中内置了静态资源的解析引擎
2. 动态资源：
* 使用动态网页技术发布的资源
* 特点：
* 所有用户访问，得到的结果可能不一样
* 如：jsp/servlet,php,asp...
* 如果用户请求的是动态资源，那么服务器将会执行动态资源，转换为静态资源，再发送给浏览器
* 我们要学习动态资源，必须先学习静态资源！
* 静态资源：
* HTML：用于搭建基础网页，展示页面的内容
* CSS：用于美化页面，布局页面
* JavaScript：控制页面的元素，让页面有一些动态的效果
HTML
1. 概念：是最基础的网页开发语言
* Hyper Text Markup Language 超文本标记语言
* 超文本：
* 超文本是用超链接的方法，将各种不同空间的文字信息组织在一起的网状文本。
* 标记语言：
* 由标签构成的语言。<标签名称> 如html, xml
* 标记语言不是编程语言
2. 快速入门：
* 语法：
1. html文档后缀名 .html 或者 .htm
2. 标签分为
1. 围堵标签：有开始标签和结束标签。如
2. 自闭和标签：开始标签和结束标签在一起。 如
3. 标签可以嵌套：
需要正确嵌套，不能你中有我，我中有你
错误:
正确:
4. 在开始标签中可以定义属性。属性是由键值对组成，值需要用引号(单双都可)引起来
5. html的标签不区分大小写，建议使用小写。
3. 标签学习：
1. 文件标签：构成html最基本的标签
* html:html文档的根标签
* head:头标签。用于指定html文档的一些属性。引入外部的资源
* title:标题标签
* body：体标签
* :html5中定义改文档是html文档
2. 文本标签：和文本有关的标签
* 注释：
* to ：标题标签
* h1~h6字体大小主键递减
*
：段落标签
*
：换行标签
*
：展示一条水平线
* 属性：
* color：颜色
* width：宽度
* size：高度
* align：对齐方式
* center：居中
* left：左对齐
* right：右对齐
* ：字体加粗
* ：字体斜体
* ：字体标签
* 属性：
* color：颜色
* size：大小
* face：字体
* ：文本居中
* 属性定义：
* color：
1. 英文单词：red,green,blue
2. rgb(值1, 值2, 值3):值的范围：0~255 如 rgb(0,0,2555)
3. #值1值2值3：值的范围：00~FF。 如: #FF00FF
* width:
1. 数值：width='20'，数值的单位，默认是 px(像素)
2. 数值% ：占比相对于父元素的比例
* 案例
...
3. 图片标签
* img：展示图片
* 属性：
* src：指定图片位置
* 相对路径：
* 以.开头的路径
* ./: 代表当前目录 ./image/1.jpg
* ../: 代表上一级目录
4. 列表标签：
* 有序列表：
* ol
* li
* 无序标签：
* ul
* li
5. 链接标签
* a：定义一个超链接
* 属性：
* href：指定访问资源的URL(统一资源定位符)
* target：指定打开资源的方式
* _self：默认值，在当前页面打开
* _blank：在空白页面打开
6. div和span：
* div：每个div占满一整行。块级标签
* span：文本信息在一行展示，行内标签，内联标签。
7. 语义化标签：html5中为了提高程序的可读性，提供了一些标签
1. : 页眉
2.