JavaWeb笔记

最新推荐文章于 2024-07-20 23:55:03 发布

薙切洛

最新推荐文章于 2024-07-20 23:55:03 发布

阅读量466

点赞数

文章标签： java javaweb

本文链接：https://blog.csdn.net/m0_50510305/article/details/119913956

版权

JavaWeb笔记

Junit单元测试

测试分类

黑盒测试：不需要写代码
白盒测试：需要写代码

Junit（白盒测试的一种）使用：

步骤：

定义一个测试类（测试用例）

建议：

测试类名：被测试的类名 + Test
包名：xxx.xxx.xx.test

定义测试方法：可以独立运行

建议：

方法名：test + 测试的方法名
返回值：void
参数列表：空参

给方法加@Test

导入junit环境依赖

判定结果

红色：失败
绿色：成功
一般我们会使用断言操作来处理这个结果

补充：@Before：修饰的方法会在测试方法之前被自动执行

@After:修饰的方法会在测试方法执行之后被自动执行

反射：框架设计的灵魂

框架：半成品软件。可以在框架的基础山进行软件开发，简化代码
反射：将类的各个组成部分封装为其他对象，这就是反射机制

反射的好处：

可以在程序的运行过程中，操作这些对象
可以解耦，提高程序的可扩展性

获取Class对象的方式：
1. Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象
  
  多用于配置文件，将类名定义在配置文件中，读取文件，加载类
2. 类名.class：通过类名的属性class获取
  
  多用于参数的传递
3. 对象.getClass()：getClass()方法在Object类
  
  多用于对象的获取字节码的方式
结论：同一个字节码文件（*.class）在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的class对象都是同一个

Class对象的功能

获取成员变量们

Field[] getFields();
Field getField();
Field[] getDeclaredFields();
Field getDeclaredField(String name);

获取构造方法们

Constructor<T> getConstructor(类<?>... parameterTypes);
Constructor<?>[] getConstructors();
Constructor<T> getDeclaredConstructor(类<?>... parameterTypes);
Constructor<?>[] getDeclaredConstructors();

获取成员方法们

Method getMethod(String name, 类<?>... parameterTypes);
Method[] getMethods();
Method getDeclaredMethod(String name, 类<?>... parameterTypes);
Method[] getDeclaredMethods();

获取类名
```
Class.forName("全类名");
```

注解

概念：
注释：用文字描述程序的，给程序员看的

注解：说明程序的，给计算机看的

定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。

概念描述：
1. JDK1.5之后的新特性
2. 说明程序的
作用分类：
1. 编写文档：通过代码里标识的元数据生成文档【生成doc文档】
2. 代码分析：通过代码里标识的元数据进行分析【使用反射】
3. 编译检查：通过代码里标识的元数据让编译器能够实现基本的编译检查【Override】
JDK中预定义的一些注解

@Override: 检测被该注解标注的方法是否继承自父类（接口）的

@Deprecated：该注解标注的内容，表示已过时

@SuppressWarnings：压制警告

一般传递参数all@SuppressWarnings(“all”)
自定义注解

格式：

元注解

public @interface 注解名称{

属性列表；

}

本质：注解本质上就是一个接口，该接口默认继承Annotation接口

public interface 注解名称 extends java.lang.annotation.Annotation

**属性：**接口中的抽象方法
要求
1. 属性的返回值类型
  1. 基本数据类型
  2. String
  3. 枚举
  4. 注解
  5. 以上类型的数组
2. 定义了属性，在使用时，需要给属性赋值
  1. 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值
  2. 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可
  3. 数组赋值时，值使用{ }包裹。如果数组中只有一个值，则{ }可以省略
**元注解：**用于描述注解的注解
- @Target：描述注解能够使用的位置
  - ElementType取值：
    - TYPE：可以作用于类上
    - FIELD：可以作用于成员变量上
    - METHOD：可以作用于成员方法上
- @Retention：描述注解被保留的阶段
  - @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
- @Documented：描述注解是否被抽取到API文档中
- @Inherited:描述注解是否被子类继承
在程序中使用（解析）注解：获取注解中定义的属性值
1. 获取注解定义的位置的对象（Class，Method，Field）
2. 获取指定的注解
  1. getAnnotation(Class)
3. 调用注解中的抽象方法获取配置的属性值
小结：
1. 以后大多数时候，我们会使用注解，而不是自定义注解
2. 注解给谁用：
3. 编译器
4. 给解析程序用
5. 注解不是程序的一部分，可以理解为注解就是一个标签

数据库的基本概念

数据库的英文单词：DataBase 简称：DB
什么是数据库：用于存储和管理数据的仓库
数据库的特点：
1. 持久化存储数据。其实数据库就是一个文件系统。
2. 方便存储和管理数据
3. 使用了同意的方式操作数据库–SQL
常见的数据库软件

MySQL、Oracle、SQL server、SQLite、DB2、

MySQL数据库软件

安装
卸载
1. 去mysql的安装目录找到my.ini文件
  1. 复制：datadir=C:/ProgramData/MySQL/MySQL Server 8.0\Data（如果没有做特别的更改的情况下，一般是这个）
2. 卸载MySQL
3. 删除C:/ProgramData目录下的MySQL文件夹
配置
- MySQL服务启动
  1. 手动
  2. cmd–>services.msc 打开服务的窗口
  3. 使用管理员打开cmd
    1. net start mysql80：启动MySQL服务
    2. net stop mysql80：关闭MySQL服务
- MySQL登录
  - ```
  mysql -uroot -p //第一种方式
  mysql -uroot -p6317977369 //第二种方式
  //以上两种在黑窗中的操作默认是连接本地的MySQL服务器
```
- ```
mysql -h127.0.0.1 -uroot -p6317977369//IP可以更改，可以连接别人的MySQL服务器，连谁的就填谁的密码
```
  - ```
  mysql --host=127.0.0.1 --user=root --password=6317977369
```
- MySQ退出
  - exit
  - quit
- MySQL目录结构
  - MySQL安装目录
    - 配置文件 my.ini
  - MySQL数据目录
    - 几个概念
      
      数据库：文件夹
      
      表：文件
      
      数据：文件中的信息

SQL

什么是SQL？

Structured Query Language：结构化查询语言。其实就是定义了操作所有关系型数据库的规则。每一种数据库操作的方式存在不一样的地方，称为“方言”
SQL通用语法
- SQL语句可以单行或多行书写，以分号结尾
- 可以使用空格和缩进来增强语句的可读性
- MySQL数据库的SQL语句不区分大小写，但是关键字建议使用大写
- 三种注释
  
  单行注释：-- 注释内容（两个横线后面有空格，一定要加）
  
  单行注释： # 注释内容（MySQL特有 #后面可以不加空格）
  
  多行注释：/* 注释 */
SQL分类
- DDL（Data Definition Language）数据定义语言
  
  用来定义数据库对象：数据库、表、列等。关键字create，drop，alter等
- DML（Data Manipulation Language）数据操作语言
  
  用来对数据库表中的数据进行增删改。关键字：insert，delete，update等
- DQL（Data Query Language）数据查询语言
  
  用来查询数据库中表的记录（数据）。关键字：select，where等
- DCL（Data Control Language）数据控制语言（了解）
  
  用来定义数据库的访问权限和安全级别，及创建用户。关键字：GRANT，REVOKE等
DDL：操作数据库、表
- 操作数据库：CRUD
- C（create）：创建
  
  创建数据库
  
  create database 数据库名称;
  
  创建数据库，判断是否存在
  
  create database if not exists 数据库名称;
  
  创建数据库，并指定字符集
  
  create database 数据库名称 character set 字符集名;
  
  创建nakiri_luo数据库，判断是否存在，并指定字符集GBK
  
  create database if not exists nakiri_luo character set gbk;
- R（retrieve）：查询
  1. 查询所有数据库的名称
    
    show databases;
  2. 查询某个数据库的字符集(查询某个数据库的创建语句)
    
    show create database 数据库的名称;
- U（update）：修改
  1. 修改数据库的字符集
    
    alter database 数据库名称 character set 字符集名称;
- D（delete）：删除
  1. 删除数据库
    
    drop database 数据库名称;
  2. 判断数据库是否存在，存在再删除
    
    drop database if not exists 数据库名称;
- 使用数据库
  1. 查询当前正在使用的数据库名称
    
    select database();
  2. 使用数据库
    
    use 数据库名称;
- 操作表
- C（create）：创建
  1. 语法：
```
create table 表名（
	列名1 数据类型1，
	列名2 数据类型2，
	列名3 数据类型3，
	···
	列名n 数据类型n
）；
#z注意：最后一列，不需要加逗号
```
    数据库类型：
    
    int：整数类型
    
    double：小数类型
    
    score duble(5,2)//小数一共5位，保留2位
    
    date：日期，只包含年月日,YYYY-MM-dd
    
    datetime：日期，包含年月日时分秒，YYYY-MM-dd HH:mm:ss
    
    timestamp：日期，包含年月日时分秒，YYYY-MM-dd HH:mm:ss
    
    datetime和timestamp的区别：
    
    对于timestamp类型，如果将来不给这个字段赋值，或者赋值为null，则默认使用当前的系统时间，来自动赋值
    
    varchar：字符串
    
    name varchar(20)：姓名最大20个字符
  2. 创建表
```
create table student(
	id int,
    name varchar(32),
    age int,
    score double(4,1),
    birth date,
    insert_time timestamp
);
```
    复制表：
    
    create table 表名 like 被复制的表名;
- R（retrieve）：查询
  1. 查询某个数据库中所有的表名称
    
    show tables;
  2. 查询表结构
    
    desc 表名;
- 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 列名;
- D（delete）：删除
  1. drop table if not exists 表名;
  2. drop table 表名;
DML：增删改表中的数据
1. 添加数据
  - 语法：
    
    insert into 表名(列名1,列名2...列名n) values(值1,值2...值n);
2. 删除数据
  - 语法：
    
    delete from 表名[where 条件]
    - 注意：如果不加条件，则删除表中所有记录。但是不推荐使用这种方法。有多少条记录就会执行多少次删除操作，效率低。
  - truncate table 表名;：删除表，然后再创建一个一模一样的空表。推荐使用，效率更高。
3. 修改数据
  - 语法：
    
    update 表名 set 列名1=值1,列名2=值2，···[where 条件];
    - 注意：如果不加任何条件，则会将表中所有的记录全部修改

DQL：查询表中的记录

select * form 表名;
注意:
- 列名和值要一一对应
- 如果表名后，不定义列名，则默认给所有的列添加值
- 除了数字类型，其他类型需要使用引号（单双引号都可以）引起来

排序查询
1. 语法：order by 子句
  
  order by 排序字段1 排序方式1,排序字段2 排序方式2...
排序方式：

ASC：升序，默认的

DESC：降序

注意：如果有多个排序条件，则当前面的条件值都一样时，才会判断第二条件
聚合函数：将一列数据作为一个整体，，进行纵向的计算
count：计算个数
```
  1. 一般选择非空的列：主键
  2. COUNT(*)，但是不推荐这么写
```
max：计算最大值

min：计算最小值

sum：计算和

avg：计算平均值

注意：
- 聚合函数的计算，会排除null值
- 解决方案：
  - 选择不包含null的列
  - 使用IFNULL()函数
分组查询
- 语法：group by 分组字段;
- 注意：
  - 分组之后查询的字段：分组字段、聚合函数
  - 在where和having的区别：
    - where 在分组之前进行限定，如果不满足条件，则不参与分组。having在分组之后进行限定，如果不满足结果，则不会被查询出
    - where后不可以跟聚合函数，having后可以进行聚合函数的判断

分页查询
- 语法：limit 开始的索引，每页查询的条数;
- 公式：开始的索引 = （当前页数 - 1） * 每页显示的条数
- 分页操作是一个MySQL的“方言”

基础查询

多个字段的查询

select 字段名1,字段名2,...FROM 表名;

**注意：**如果查询所有的字段，则可以使用*来替代字段的列表

去除重复

distinct

计算列

一般可以使用四则运算计算一些列的值，一般只会进行数值型计算

IFNULL(表达式一，表达式二)：null参与的运算，计算结果都是null

表达式一：哪个字段需要判断是否为null

表达式二：如果该字段为null后的替换值

起别名

as：as也可以省略

CREATE TABLE student(
id INT, #编号
name VARCHAR(20), #姓名
age INT, #年龄
sex VARCHAR(5), #性别
address VARCHAR(100), #地址
math INT, #数学
english INT #英语
);

INSERT INTO student(id,name,age,sex,address,math,english) VALUES(1,'MAYUN',55,'MAN','HANGZHOU',66,78),(2,'MAHUATENG',45,'WOMAN','SHENZHEN',98,87),(3,'MAJINGTAO',55,'MAN','HONGKONG',55,77),(4,'LIUYAN',20,'WOMAN','HUNAN',76,65),(5,'LIUQING',20,'MAN','HUNAN',86,NULL),(6,'LIUDEHUA',57,'MAN','HONGKONG',99,99),(7,'MADE',22,'WOMAN','HONGKONG',99,99),(8,'DEMAXIYA',18,'MAN','NANJING',56,65);

SELECT * FROM student;

#查询姓名和年龄
SELECT `name`,age FROM student;

#去除重复的结果集
SELECT DISTINCT address FROM student;

#查询姓名和地址
SELECT `name`,address FROM student;

#计算math和English分数之和
SELECT `name`,math,english,math+IFNULL(english,0) FROM student;
#如果有null参与运算，计算结果都是null

#起别名
SELECT `name`,math,english,math+IFNULL(english,0) AS 总分 FROM student;

条件查询
- where子句后跟条件
- 运算符
  - >、<、<=、>=、=、<>
  - BETWEEN…AND
  - IN
  - LIKE：模糊查询
    - 占位符：
      
      _：单个任意字符
      
      %：任意多个字符
  - IS NULL
  - and 或 &&
  - or 或 ||
  - not 或 !

SELECT * FROM student;

#查询年龄大于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;

#查询英语成绩不为空
SELECT * FROM student WHERE english IS NOT NULL;

#查询姓MA的人有哪些
SELECT * FROM student WHERE `name` LIKE 'MA%';

#查询名字中带HUA的人
SELECT * FROM student WHERE `name` LIKE '%HUA%';

#查询名字中的字母是七个的人
SELECT * FROM student WHERE `name` LIKE '_______';

#查询姓名中包含MA的人
SELECT * FROM student WHERE `name` LIKE '%MA%';

约束

概念：对表中的饿数据进行限定，保证数据的正确性、有效性、完整性
分类：
1. 主键约束：primary key
2. 非空约束： not null
3. 唯一约束：unique
4. 外键约束：foreign key

非空约束：not null，值不能为null

创建表时添加约束

CREATE TABLE stu(
	id INT,
	name VARCHAR(20) NOT NULL -- name为非空
);

创建表之后添加非空约束

ALTER TABLE stu MODIFY NAME VARCHAR(20) NOT NULL;

删除非空约束

ALTER TABLE stu MODIFY NAME VARCHAR(20);

唯一约束：unique，值不能重复，有时也称之为唯一索引
- 创建表，添加唯一约束
```
CREATE TABLE stu(
	id INT,
	phone_number VARCHAR(20) UNIQUE -- 添加了唯一约束
);
```
- 删除唯一约束
```
ALTER TABLE stu DROP INDEX phone_number;
```
- 创建表后添加唯一约束
```
ALTER TABLE stu MODIFY phone_number VARCHAR(20) UNIQUE; 
```
- 注意：在MySQL中，唯一约束限定的列的值可以有多个null
主键约束：primary key
- 注意
  1. 含义：非空且唯一
  2. 一张表只能由一个字段为主键
  3. 主键就是表中记录的唯一标识
- 在创建表时，添加主键约束
```
CREATE TABLE stu(
	id INT PRIMARY KEY, -- 给id添加主键约束
    name VARCHAR(20)
);
```
- 删除主键
```
ALTER TABLE stu DROP PRIMARY KEY;
```
- 创建完成表后添加主键
```
ALTER TABLE stu MODIFY id INT PRIMARY KEY;
```
- 自动增长：
  1. **概念：**如果某一列时数值类型的，使用auto_increment可以来完成值的自动增长
  2. 在创建表时，添加主键约束，并且完成主键的自动增长
```
CREATE TABLE stu(
	id INT PRIMARY KEY auto_increment, 
    name VARCHAR(20)
);
```
  3. 删除自动增长
```
ALTER TABLE stu MODIFY id INT;
```
  4. 创建表完成后添加自动增长
```
ALTER TABLE stu MODIFY id INT AUTO_INCREMENT;
```

外键约束：foreign key，让表与表产生关系，从而保证数据的正确性

在创建表时，可以添加外键

语法：

CREATE TABLE 表名(
	...
    外键列
    constraint 外键名称 foreign key(外键列名称) references 主表名称(主表列名称)
);

#例如
CONSTRAINT emp_dept_fk FOREIGN KEY(dep_id) REFERENCES department(id);

删除外键

ALTER TABLE 表名 DROP FOREIGN KEY 外键名称;

创建表之后，添加外键

ALTER TABLE 表名 ADD CONSTRAINT 外键名称 FOREIGN KEY(外键字段名称) REFERENCES 主表名称(主表列的名称);

级联操作

添加级联操作：

ALTER TABLE 表名 ADD CONSTRAINT 外键名称 FOREIGN KEY(外键字段名称) REFERENCES 主表名称(主表列的名称) ON UPDATE CASCADE ON DELETE CASCADE;

分类

级联的更新： ON UPDATE CASCADE

级联的删除：ON DELETE CASCADE;

多表之间的关系
1. 一对一：
  
  如：人和身份证的关系
  
  分析：一个人只有一个身份证，一个身份证只能对应一个人
2. 一对多（多对一）：
  
  如：部门和员工
  
  分析：一个部门有多个员工，一个员工只能对用一个部门
3. 多对多
  
  如：学生和课程的关系
  
  分析：一个学生可以选择很多们课程，一个课程也可以被很多学生选择
实现关系
- 一对多：
  
  实现方式：在多的一方建立外键，指向一的一方的主键。
- 多对多：
  
  实现方式：需要借助第三张中间表。中间表至少包含两个字段，这两个字段作为第三张表的外键，分别指向两张表的主键。（用联合主键更合适）
- 一对一（了解）
  
  实现方式：可以在任意一方添加唯一外键指向另一方的
范式
- 概念：涉及数据库时，需要遵循的一些规范。要遵循后边的范式要求，必须先遵循前面的所有的范式要求
- 设计关系数据库时，遵从不同的规范要求，设计出合理的关系型数据库，这些不同的规范要求被称为不同的范式，各种范式呈递次规范，越高的范式数据库冗余越小。
  
  目前关系数据库有六种范式：第一范式（1NF）、第二范式（2NF）、第三范式（3NF）、巴斯-科德范式（BCNF）、第四范式(4NF）和第五范式（5NF，又称完美范式）。
- 分类：
  - 第一范式（1NF）：
    
    每一列都是不可分割的原子数据项
  - 第二范式（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. 码：如果在一张表中，一个属性或者属性组被其他所有属性所完全依赖，则称这个属性（属性组）为该表的码
      主属性：码组属性中所有的属性
      非主属性：除过码属性组中的属性
  - 第三范式（3NF）：
    
    在2NF基础上，任何非主属性不依赖于其它非主属性（在2NF基础上消除传递依赖）
数据库的备份和还原
- 命令行：
  
  语法：
  
  备份：mysqldump -u用户名 -p密码数据库名称 > 保存的路径
  
  还原：
  1. 登录数据库
  2. 创建数据库
  3. 使用数据库
  4. 执行文件
    
    语法：source 文件路径
- 图形化工具
多表查询
- 查询语法
```
SELECT
	列名列表
FROM
	表名列表
WHERE
	...
```
- 笛卡尔积：
  
  有两个集合A、B，取这两个集合的所有组成情况
  
  要完成多表查询，需要消除无用的数据
- 分类：
  1. 内连接查询：
    1. 隐式内连接：使用WHERE条件来消除无用的数据
    2. 显式内连接
      - 语法：
        
        SELECT 字段列表 FROM 表名1 INNER JOIN 表名2
        
        或者
        
        SELECT 字段列表 FROM 表名1 JOIN 表名2
    3. 内连接查询：
      1. 从哪些表中查询数据
      2. 条件是什么
      3. 查询哪些字段
  2. 外连接查询
    1. 左外连接
      - 语法：SELECT 字段列表 FROM 表1 LEFT [OUTER] JOIN 表2 ON 条件;
      - 查询的是左表所有的数据以及其交集的部分
    2. 右外连接
      - 语法：SELECT 字段列表 FROM 表1 RIGHT [OUTER] JOIN 表2 ON 条件;
      - 查询的是右表所有的数据以及其交集的部分
  3. 子查询
    1. 概念：查询中嵌套查询，称嵌套查询为子查询
    2. 子查询的不同情况：
      1. 结果是单行单列的：
        
        子查询可以作为条件，使用运算符去判断。运算符：> < >= <= =
      2. 结果是多行单列的：
        
        子查询可以作为条件，使用运算符IN来判断
      3. 结果是多行多列的：
        
        子查询可以作为一张虚拟表参与查询。也可以使用内连接

事务的基本介绍

概念：

如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败

操作：

开启事务：start transaction;
回滚：rollback;
提交：commit;

CREATE TABLE account(
	id INT PRIMARY KEY auto_increment,
	name VARCHAR(10),
	balance DOUBLE
);

#添加数据
INSERT INTO account (`name`,balance) VALUES('zhangsan',1000),('lisi',1000);
SELECT * FROM account;

UPDATE account SET balance = 1000;

-- 张三给李四转账500
-- 开启事务
START TRANSACTION;
-- 1.张三账户-500
UPDATE account SET balance = balance - 500 WHERE account.`name` = 'zhangsan';
-- 2.李四账户+500
UPDATE account SET balance = balance + 500 WHERE account.`name` = 'lisi';
-- 发现执行没有问题，提交事务
COMMIT;
-- 发现执行出问题了，回滚事务
ROLLBACK;

MySQL数据库中事务默认自动提交

事务提交的两种方式：
1. 自动提交
  
  MySQL就是自动提交的
  
  一条DML（增删改）语句会自动提交一次事务
2. 手动提交
  
  需要先开启事务，再提交
  
  Oracle数据库默认是手动提交事务的
修改事务的默认提交方式

查看事务的默认提交方式：

select @@autocommit;-- 1代表自动提交 0代表手动提交

修改默认提交方式：

set @@autocommit = 0;

事务的四大特征（面试题）
1. 原子性：是不可分割的最小操作单位，要么同时成功，要么同时失败
2. 持久性：当事务提交或回滚后，数据库会持久化的保存数据
3. 隔离性：多个事务之间，相互独立
4. 一致性：事务操作前后，数据总量不变
事务的隔离级别（了解）
- 概念：多个事务之间是隔离的，相互独立的。但是如果多个事务操作同一批数据，则会引发一些问题，设置不同的隔离级别，就可以解决这些问题
- 存在的问题：
  1. **脏读：**一个事务读取到另一个事务中没有提交的数据
  2. **不可重复读（虚读）：**在同一个事务中，两次读到的数据不一样
  3. **幻读：**一个事务操作（DML）数据表中的所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改
- 隔离级别：
  1. read uncommited：读未提交
    
    产生的问题：脏读、不可重复读、幻读
  2. read commited：读已提交（Oracle数据库默认）
    
    产生的问题：不可重复读、幻读
  3. repeatable read：可重复读（MySQL默认）
    
    产生问题：幻读
  4. serializable：串行化
    
    可以解决所有的问题
  注意：隔离级别从小到大安全性越来越高，但是效率越来越低
  
  数据库查询隔离级别：
  
  select @@tx_isolation;
  
  数据库设置隔离级别：
  
  set global transaction isolation level 级别字符串;
DCL：管理用户、授权
- 管理用户
  - 添加用户
    
    语法：CREATE USER '用户名'@'主机名' IDENTIFIED BY '密码';
  - 删除用户
    
    语法：DROP USER '用户名'@'主机名';
  - 修改用户密码
    mysql中忘记root用户密码：
    1. cmd–>net stop mysql 停止MySQL服务
    2. 使用无验证方式启动MySQL服务：mysql --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. 使用新密码登录
  - 查询用户
```
-- 切换MySQL数据库
USE mysql;
-- 查询user表
SELECT * FROM `user`;
```
    通配符：%表示可以在任何主机使用用户登录数据库
- 授权
  - 查询权限
    
    SHOW GRANTS FOR '用户名'@'主机名';
  - 授予权限
    
    语法：grant 权限列表 on 数据库.表名 to '用户名'@'主机名';
    
    为用户授予所有权限操作任意数据库上的任意表的权限：
    
    GRANT ALL ON *.* to '用户名'@'主机名';
  - 撤销权限
    
    语法：revoke 权限列表 on 数据库名.表名 from '用户名'@'主机名';

JDBC

概念：Java Database Connectivity（Java数据库连接，Java语言操作数据库）
JDBC本质

其实是官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类
快速入门
- 步骤
  1. 导入驱动jar包
    1. 复制mysql-connector-java-8.0.25.jar到项目的libs目录下（libs目录是方便管理后期自己建的，也可以不建）
    2. 右键–>添加到库
  2. 注册驱动
  3. 获取数据库连接对象 Connection
  4. 定义sql
  5. 获取执行sql语句的对象 Statement
  6. 执行sql，接收返回结果
  7. 处理结果
  8. 释放资源
- 详解各个对象
  DriverManager：驱动管理对象
  
  功能：
  1. 注册驱动：告诉程序该使用哪一个数据库驱动jar
    
    注意：在MySQL5之后的驱动jar包，可以省略注册驱动的步骤
  2. 获取数据库连接
    
    方法：static Connection getConnection(String url, String user, String password)
    
    参数：
    
    url：指定连接路径
    
    语法：jdbc:mysql://ip地址（域名）:端口号/数据库名称
    
    例子：jdbc:mysql://localhost:3306/nakiri
    
    细节：如果连接的是本机的MySQL服务，并且MySQL服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称
    
    user：用户名
    
    password：密码
  Connection：数据库连接对象
  1. 功能：
    - 获取执行sql的对象
      
      Statement createStatement()
      
      PreparedStatement prepareStatement(String sql)
    - 管理事务
      
      开启事务：void setAutoCommit(boolean autoCommit) 调用方法设置参数为false，即开启事务
      提交事务：void commit()
      回滚事务：void rollback()
  Statement：执行sql对象
  - 执行sql
    - boolean execute(String sql)：可以执行任意的sql
    - int executeUpdate(String sql)：执行DML语句（insert、update、delete）和DDL语句（create、alter、drop）
      
      此方法的返回值是影响的行数，可以通过影响的行数判断DML语句是否执行成功。返回值>0则执行成功，反之则失败
    - ResultSet executeQuery(String sql)：执行DQL语句（select）
  ResultSet：结果集对象，封装查询结果
  - boolean next()：游标向下移动一行，判断当前行是否是最后一行末尾（是否有数据），如果是，则返回false，如果不是则返回true
  - getXxx(参数)：
    
    获取数据，Xxx代表数据类型如：getInt()、getString()
    
    参数：
    1. Int：代表列的编号，从1开始如getString(1)
    2. String：代表列的名称，如getDouble(“balance”)
    注意：
    
    使用步骤：
```
	1. 游标向下移动一行
	2. 判断是否有数据
	3. 获取数据
```
  PrepareStatement：执行sql对象
  - sql注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接，会造成安全性的问题
  - 解决sql注入问题：使用PrepareStatement对象来解决
  - 预编译的sql：参数使用？作为占位符
  - 步骤：
    1. 导入驱动jar包
    2. 注册驱动
    3. 获取数据库连接对象 Connection
    4. 定义sql
      注意sql的参数使用?作为占位符
    5. 获取执行sql语句的对象 PrepareStatement PreparedStatement prepareStatement(String sql)
    6. 给？赋值
      方法：使用setXxx(参数一,参数二)
      参数一：?的位置编号，从1开始
      参数二：?的值
    7. 执行sql，接收返回结果，不需要传递sql语句
    8. 处理结果
    9. 释放资源
  - 后期会使用PrepareStatement 来完成增删改查的所有操作
    - 可以防止sql注入
    - 效率更高
抽取JDBC工具类：JDBCUtils
- 目的：简化书写
- 分析：
  1. 注册驱动
  2. 抽取一个方法获取连接对象
    - 不传递参数的情况下保证工具类的通用性
      
      解决方案：配置文件
  3. 抽取一个方法释放资源
JDBC控制事务
- 操作：
  1. 开启事务
  2. 回滚事务
  3. 提交事务
- 使用Connection对象来管理事务
  1. 开启事务：setAutoCommit(boolean autoCommit)：调用该方法设置参数为false，即开启事务
    
    在执行sql前开启事务
  2. 回滚事务：commit()
    
    当所有sql执行完毕后提交事务
  3. 提交事务：rollback()
    
    在catch中回滚事务

数据库连接池

***概念：***其实就是一个容器（集合），存放数据库连接的容器。当系统初始化好后，容器被创建，容器会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。
好处
- 节约资源
- 高效
实现
- 标准接口：DataSource javax.sql包下的
  - 方法：
    - 获取连接：getConnection()
    - 归还连接：Connection.close() 如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法则不会再关闭连接了，而是归还连接
- 一般我们不去实现它，由数据库厂商来实现
  - C3P0：数据库连接池实现技术
  - Druid：数据库连接池实现技术，由阿里巴巴实现
C3P0：数据库连接池实现技术
- 步骤：
  1. 导入jar包 c3p0-0.9.5.5-sources.jar和mchange-commons-java-0.2.19-sources.jar
  2. 不要忘记导入数据库的驱动jar包
  3. 定义配置文件
    1. 名称c3p0.properties 或者 c3p0-config.xml
    2. 路径：直接将文件放在src目录下即可
  4. 创建核心对象，数据连接池对象ComboPooledDataSource
  5. 获取连接：getConnection
Druid：数据库连接池实现技术，由阿里巴巴实现
- 步骤：
  1. 导入jar包：druid-1.0.9.jar
  2. 定义配置文件
    1. 是properties形式的
    2. 可以叫任意名称，可以放在任意目录下
  3. 加载配置文件
```
Properties properties = new Properties();
        InputStream resource = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
        properties.load(resource);
```
  4. 获取数据库连接池对象：通过工厂类来获取DruidDataSourceFactory
  5. 获取连接getConnection
- 定义工具类
  - 定义一个类 JDBCUtils
  - 提供静态代码块加载配置文件，初始化连接池对象
  - 提供方法
    - 获取连接方法：通过数据库连接池获取连接
    - 释放资源
    - 获取连接池的方法

Spring JDBC

Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
步骤：
- 导入jar包
- 创建JdbcTemplate对象。依赖于数据源DataSource
  
  JdbcTemplate template = new JdbcTemplate(dataSource);
- 调用JdbcTemplate的方法来完成CRUD的操作
  
  update()：执行DML语句。增删改语句
  
  queryForMap()：查询结果，将结果集封装为Map对象。将列名作为key，将值作为value将这条记录封装为一个map集合
  - 注意：这个方法查询的结果集长度只能是1
  queryForList()：查询结果，将结果封装为List对象
  - 注意：将每一条记录封装为一个map集合，再将map集合装载到list集合中
  query()：查询结果，将结果封装为JavaBean对象
  - query的参数：RowMapper
    - 一般我们使用BeanPropertyRowMapper实现类，可以完成数据到JavaBean的自动封装
    - ```
    jdbcTemplate.query(sql, new BeanPropertyRowMapper<类型>(类型.class));
```
queryForObject()：查询结果，将结果封装为对象
- 一般用于聚合函数的查询
- 练习：
  需求:
  1. 修改1号数据math为78
  2. 添加一条记录
  3. 删除刚才加的记录
  4. 查询id为1的记录，将其封装为Map集合
  5. 查询所有记录，将其封装为list
  6. 查询所有记录，将其封装为Student对象的List集合
  7. 查询总记录数

web概念概述

JavaWeb

使用Java语言开发基于互联网的项目
软件架构
- C/S：client/server 客户端/服务器端
  
  在用户本地有一个客户端程序，在远程有一个服务器端程序
  
  优点：
  
  用户体验好
  
  缺点：
  
  开发、安装、部署、维护麻烦
- B/S：browser/server 浏览器/服务器
  
  只需要一个浏览器，用户通过不同的网址（url），客户访问不同的服务器端程序
  
  优点：
  
  开发安装部署维护简单
  
  缺点：
  
  如果应用过大，用户的体验可能受到影响
  
  对硬件要求过高
- B/S架构详解
  - 资源分类
    1. 静态资源
      
      使用静态网页开发技术发布的资源
      
      特点：
      - 所有用户访问，得到的结果都是一样的
      - 如：文本、图片、音频、视频，html，css，JavaScript
      - 如果用户请求的是静态资源，那么服务器会直接将静态资源发送给浏览器，浏览器内置了静态资源的解析引擎，可以展示静态资源
      分类：
      - HTML：用于搭建基础网页，展示页面的内容
      - CSS：用于美化页面，布局页面
      - javascrip：控制页面的元素，让页面有一些动态的效果
    2. 动态资源
      
      使用动态网页技术发布的资源
      
      特点：
      - 所有用户访问，得到的结果可能不一样
      - 如：jsp/servlet、php、asp…
      - 如果用户请求的是动态资源，服务器会执行动态资源，转换为静态资源，再发送给浏览器
      我们要学习动态资源，必须先学习静态资源

HTML

概念：hyper text markup language 超文本标记语言，是最基础的网页开发语言
- 超文本：超文本是用超链接的方法，将各种不同空间的文字信息组织在一起的网状文本。
- 标记语言：由标签构成的语言。如：HTML、xml
- 标记语言不是编程语言
快速入门：
- 后缀名：.html或者.htm
- 标签分为
  - 围堵标签：有开始标签和结束标签
  - 自闭标签：开始标签和结束标签在一起
- 标签可以嵌套
  
  需要正确嵌套，不能你中有我，我中有你
- 在开始标签中可以定义属性。属性是由键值对构成，值需要用引号引起来（单双都可以）
- HTML的标签不区分大小写，建议使用小写

标签

文件标签：构成html最基本的标签
- html：html文档的根标签
- head：投标前。用于指定html文档的一些属性，引入外部的资源
- title：标题标签
- body：体标签
- <!DOCTYPE html>:html5中定义该文档是html文档

文本标签：和文本有关的标签

标签	功能
`<h1>` to `<h6>`	标题标签字体大小逐渐递减
`<p>`	段落标签
`<br>`	换行
`<hr>`	显示一条水平线。属性：color（颜色）、width（宽度）、size（高度）、align（对齐方式 center–居中、left–左对齐、right–右对齐）
`<b>`	字体加粗
`<i>`	字体斜体
`<font>`	字体标签（已废弃）
`<!-- -->`	注释
`<center>`	文本居中（已废弃）

属性定义：

color:

英文单词：red、green等等
rgb(值1，值2，值3)：值的范围0-255
值1值2值3：值的范围00-FF之间

width：

数值：width = ‘20’，数值的单位默认是px(像素)
数值%：表示占比，相对于

图片标签：

属性：src：指定图片的位置

相对路径：以 . 开头的图片。

‘./’代表当前目录。

‘…/’代表上一级目录。
列表标签：
链接标签：
表格标签：

JavaScript

概念：一门客户端脚本语言
- 运行在客户端浏览器中。每一个浏览器都要JavaScript的解析引擎
- 脚本语言：不需要编译，直接就可以被浏览器解析执行
功能：
- 可以来增强用户和html页面的交互过程，可以控制html元素，让页面有一些动态的效果，增强用户的体验
JavaScript = ECMAScript + JavaScript自己特有的东西(BOM + DOM)
ECMAScript：客户端脚本语言的标准
- 基本语法：
  - 与html结合的方式
    - 内部JS
      
      定义

BOM

概念：Browser Object Modle 浏览器对象模型
- 将浏览器的各个组成部分封装成对象
组成：
- Window：窗口对象
- Navigator：浏览器对象
- Screen：显示器屏幕对象
- History：历史记录对象
- Location：地址栏对象

Window：窗口对象

1.创建
2.方法
   a.与弹出框有关的方法
      * alert()  显示带有一段消息和一个确认按钮的警告框。
      * confirm()    显示带有一段消息以及确认按钮和取消按钮的对话框。
         如果用户点击确定按钮，则方法返回true
         如果用户点击取消按钮，则方法返回false
      * prompt() 显示可提示用户输入的对话框。
         返回值：获取用户输入的值
   b.与打开关闭有关的方法
      * close()  关闭浏览器窗口。
         谁调用关谁
      * open()   打开一个新的浏览器窗口或查找一个已命名的窗口。
         返回一个新的window对象
   c.与定时器有关的方法
      * setTimeout() 在指定的毫秒数后调用函数或计算表达式。
         参数：
            1.js代码或者方法对象
            2.毫秒值
         返回值：返回唯一标识，用于取消定时器
      * clearTimeout()   取消由 setTimeout() 方法设置的 timeout。

      * setInterval()    按照指定的周期（以毫秒计）来调用函数或计算表达式。
      * clearInterval()  取消由 setInterval() 设置的 timeout。
3.属性
   1.获取其他BOM对象
      history
      location
      navigator
      screen
   2.获取DOM对象
      document
4.特点
   Window对象不需要创建可以直接使用 window使用。window.方法名();
   window引用可以省略。方法名();

Location：地址栏对象
- 创建（获取）：
  - window.location
  - location
- 方法
  - reload() 重新加载当前文档。
- 属性
  - href 设置或返回完整的 URL。

DOM

概念：Document Object Model 文档对象模型
- 将标记语言文档的各个部分，封装为对象。可以使用这些对象，对标记语言文档进行CRUD的动态操作
W3C DOM 标准被分为 3 个不同的部分：
- Core DOM - 所有文档类型的标准模型
  - Document：文档对象
  - Element：元素对象
  - Attribute：属性对象
  - Text：文本对象
  - Comment：注释对象
  - Node：节点对象，其他五个的父对象
- XML DOM - XML 文档的标准模型
- HTML DOM - HTML 文档的标准模型
Core DOM模型
- Document：文档对象
  - 创建（获取）：在html dom模型中可以使用window对象来获取
    1. window.document
    2. document
  - 方法
    - 获取Element对象：
      1. getElementById() 根据id属性值获取元素对象，id属性值一般唯一
      2. getElementsByTagName() 根据元素名称获取元素对象们。返回值为数组
      3. getElementsByClassName() 根据Class属性获取元素对象们。返回值是一个数组
      4. getElementsByName() 根据Name属性值获取元素对象们。返回值是一个数组
    - 创建其他DOM对象：
      - createAttribute(name)
      - createComment()
      - createElement()
      - createTextNode()
  - 属性
- Element：元素对象
  - 获取/创建：通过document来获取和创建
  - 方法：
    - removeAttribute()：删除属性
    - setAttribute()：
- Node：节点对象，其他五个的父对象
  - 特点：所有dom对象都可以被认为是一个节点
  - 方法：
    
    CRUD dom树：
    - appendChild()：向节点的子节点列表的结尾添加新的子节点
    - removeChild()：删除（并返回）当前节点的指定子节点
    - replaceChild()：用新节点替换一个子节点
  - 属性：
    - parentNode 返回节点的父节点
HTML DOM
- 标签体的设置和获取：innerHTML
- 使用html元素对象的属性
- 控制样式
  - 使用元素的style属性来设置
  - 提前定义好类选择器的样式，通过元素的className属性来设置其class属性值

事件监听机制

概念某些组件被执行了某些操作后，出发某些代码的执行
- 事件：某些操作，如：单击，双击，键盘按下，鼠标移动
- 事件源：组件。如：按钮，文本输入框……
- 监听器：代码。
- 注册监听：将事件，事件源，监听器结合在一起。当事件源上发生了某个事件，则触发执行某个监听器代码
常见的事件
- 点击事件：
  - onclick：单击事件
  - ondblclick：双击事件
- 焦点事件：
  - onblur：失去焦点
    
    一般用于表单验证
  - onfocus：获得焦点
- 加载事件：
  - onload：一张页面或衣服图像完成加载
- 鼠标事件：
  - onmousedown：鼠标按钮被按下
    
    定义方法时，定义一个形参，接收event对象
    
    even对象的button属性可以获取鼠标按钮键被点击了
  - onmousemove：鼠标被移动
  - onmouseout：鼠标从某元素移开
  - onmouseover：鼠标移动到某元素之上
  - onmouseup：鼠标按键被松开
- 键盘事件：
  - onkeydown：某个键盘按键被按下
  - onkeyup：某个键盘按键被松开
  - onkeypress：某个键盘按键被按下并松开
- 选中和改变
  - onchange：域的内容被改变
  - onselect：文本被选中
- 表单事件
  - onsubmit：确认按钮被点击
    
    可以阻止表单的提交
    
    方法返回false，则表单被阻止
  - onreset：重置按钮被点击

BootStrap

概念：一个前端开发的框架Bootstrap是美国Twitter公司的设计师Mark Otto和Jacob Thornton合作基于HTML、CSS、JavaScript 开发的简洁、直观、强悍的前端开发框架，使得 Web 开发更加快捷。。
- 框架：一个本成品软件，开发人员可以在框架基础上，再进行开发，简化编码
- 好处：
  - 定义了很多的CSS样式和JS插件。我们开发人员可以直接使用这些样式和插件得到丰富的页面效果
  - 响应式布局。
    - 同一套页面可以兼容不同分辨率的设备

快速入门

下载bootstrap
在项目中将这三个文件夹复制
创建html页面，引入必要的资源文件

<!doctype html>
<html lang="zh-CN">
<head>
   <meta charset="utf-8">
   <meta http-equiv="X-UA-Compatible" content="IE=edge">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
   <title>Bootstrap 101 Template</title>

   <!-- Bootstrap -->
   <link rel="stylesheet" href="css/bootstrap.min.css" integrity="sha384-HSMxcRTRxnN+Bdg0JdbxYKrThecOKuH5zCYotlSAcp1+c8xmyTe9GYg1l9a69psu" crossorigin="anonymous">

   <!-- jQuery (Bootstrap 的所有 JavaScript 插件都依赖 jQuery，所以必须放在前边) -->
   <script src="js/jquery.min.js" integrity="sha384-nvAa0+6Qg9clwYCGGPpDQLVpLNn0fRaROjHqs13t4Ggj3Ez50XnGQqc/r8MhnRDZ" crossorigin="anonymous"></script>
   <!-- 加载 Bootstrap 的所有 JavaScript 插件。你也可以根据需要只加载单个插件。 -->
   <script src="js/bootstrap.min.js" integrity="sha384-aJ21OjlMXNL5UyIl/XNwTMqvzeRMZH2w8c5cRVpzpU8Y5bApTppSuUkhZXN0VxHd" crossorigin="anonymous"></script>
</head>
<body>
<h1>你好，世界！</h1>


</body>
</html>

响应式布局
- 同一套页面可以兼容不同分辨率的设备
- 实现：依赖于栅格系统：将一行平均分成12个格子，可以指定元素占几个格子
- 步骤：
  - 定义容器。相当于之前的table
    - 容器分类
      
      container：两边留白
      
      container-fluid：100%宽度
  - 定义行。相当于之前的tr 样式：row
  - 定义元素。指定该元素在不同的设备上，所占格子的数目样式：col-设备代号-格子数目
    - 设备代号
      - xs：超小屏幕 手机 (<768px)
      - sm：小屏幕 平板 (≥768px)
      - md：中等屏幕 桌面显示器 (≥992px)
      - lg：大屏幕 大桌面显示器 (≥1200px)
  - 注意：
    - 一行中如果格子数目超过12，则超出部分自动换行
    - 栅格类向上兼容。栅格类适用于屏幕宽度大于或等于分界点大小的设备
    - 如果真实设备宽度小于了设置栅格类属性的设备代码的最小值，会一个元素沾满一整行
CSS样式和JS插件
- 全局CSS样式：
  - 按钮：class=“btn btn-default”
  - 图片：
    - class=“img-responsive”：图片在任意尺寸都占100%
    - 图片形状
```
<img src="..." alt="..." class="img-rounded">：方形
<img src="..." alt="..." class="img-circle">：圆形
<img src="..." alt="..." class="img-thumbnail">：相框
```
  - 表格
    - table
    - table-bordered
    - table-hover
  - 表单
    
    给表单项添加：class=“form-control”
- 组件：
  - 导航条
  - 分页条
- 插件：
  - 轮播图

XML

概念：Extensible Markup Language 可拓展标记语言
- 可扩展：标签都是自定义的
功能
- 存储数据
  - 配置文件
  - 在网络中传输
与HTML的区别
- xml标签都是自定义的，HTML标签都是预定义的
- xml的语法非常严格，HTML语法松散
- xml是存储数据的，HTML是展示数据的
语法：
- 基本语法
  - 后缀名：.xml
  - 第一行必须定义文档声明 <?xml version='1.0'?>
  - xml文档中有且仅有一个根标签
  - 属性值必须使用引号引起来、
  - 标签必须正确关闭
  - xml标签区分大小写
- 快速入门
```
<?xml version='1.0'?>
<users>
	<user id='1'>
		<name>zhangsan</name>
		<age>23</age>
		<gender>male</gender>
	</user>
	
	<user id='2'>
		<name>lisi</name>
		<age>24</age>
		<gender>female</gender>
	</user>
	
</users>
```
- 组成部分
  - 文档声明
    - 格式：<?xml 属性列表 ?>
    - 属性列表：
      - version：版本号，必须的属性
      - encoding：编码方式。告知解析引擎当前文档使用的字符集，默认值：ISO-8859-1
      - standalone：是否独立
        取值：
        yes：不依赖于其他文件
        no：依赖于其他文件
  - 指令(了解)：结合CSS <?xml-stylesheet type="text/css" href="a.css"?>
  - 标签：标签名称自定义
    - 规则：
      - 名称可以包含字母、数字以及其他字符
      - 名称不能以数字或者标点符号开始
      - 名称不能以字母xml(或者XML、Xml等等)开始
      - 名称不能包含空格
  - 属性
    - id属性值唯一
  - 文本
    - CDATA区：在该区域中的数据会被原样展示
      - 格式：<![CDATA[数据]]>
- 约束：规定xml文档的书写规则
  - 作为框架的使用者（程序员）：
    - 能够在xml中引入约束文档
    - 能够简单的读懂约束文档
  - 分类：
    - DTD：一种简单的约束技术
    - Schema：一种复杂的约束技术
  - DTD：
    - 引入dtd文档到xml文档中
      - 内部dtd：将约束规则定义在xml文档中
      - 外部dtd：将约束的规则定义在外部的dtd文档中
        本地：
        网络：
  - Schema：
    - 引入：
      - 填写xml文档的根元素
      - 引入xsi前缀 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      - 引入xsi文件命名空间 xsi:schemaLocation="http://www.itcast.cn/xml student.xsd"
      - 为每一个xsd约束声明一个前缀，作为标识 xmlns="http://www.itcast.cn/xml"
        
        <studens xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.itcast.cn/xml student.xsd" xmlns="http://www.itcast.cn/xml">
    - 解析：操作xml文档，将文档中的数据读取到内存中
      - 操作xml文档
        解析（读取）：将文档中的数据读取到内存中
        写入：将内存中的数据保存到xml文档中。持久化的储存
      - 解析xml的方式：
        DOM：将标记语言文档一次性加载进文档，在内存中形成DOM树
        优点：操作方便，可以对文档进行CRUD的所有操作
        缺点：消耗内存
        
        SAX：逐行读取，基于事件驱动
        优点：不占内存
        缺点：只能读取，不能增删改
      - xml常见的解析器：
        JAXP：SUN公司提供的解析器，支持dom和sax两种思想
        DOM4J：一款非常优秀的解析器
        Jsoup：jsoup 是一款 Java 的 HTML 解析器，可直接解析某个 URL 地址、HTML 文本内容。它提供了一套非常省力的 API，可通过 DOM、CSS 以及类似于 JQuery 的操作方法来取出和操作数据。
        PULL：Android操作系统内置的解析器，sax方式
  - Jsoup
    - 快速入门：
      - 步骤：
        导入jar包
        获取document对象
        获取对应的标签Element对象
        获取数据
    - 对象的使用：
      - Jsoup：工具类，可以解析html或者xml文档，获得document对象
        
        parse：解析html或xml文档，返回Document
        parse(File in,String charsetName)：解析xml或html文件的
        parse(String html)：解析一个字符串的
        parse(URL url, int timeoutMillis)：通过网络路径获取指定的html或xml的文档对象
      - Document对象：文档对象。代表内存中的dom树
        
        获取Element对象
        getElementsByTag(String tagName)：根据标签名称获取元素对象集合
        getElementsByAttribute(String Key)：根据属性名称获取元素对象集合
        getElementsByAttribute(String Key,String value)：根据对应的属性名和属性值获取元素对象集合
        getElementById(String id)：根据ID属性值获取唯一的Element对象
      - Elements：元素Element对象的集合，可以当做ArrayList来使用
      - Element：元素对象
        
        获取子元素对象
        
        getElementsByTag(String tagName)：根据标签名称获取元素对象集合
        getElementsByAttribute(String Key)：根据属性名称获取元素对象集合
        getElementsByAttribute(String Key,String value)：根据对应的属性名和属性值获取元素对象集合
        getElementById(String id)：根据ID属性值获取唯一的Element对象
        
        获取属性值
        
        String attr(String key)：根据属性名称获取属性值
        
        获取文本内容
        
        String text()：获取文本内容
        String html()：获取标签体的所有内容（包括子标签的字符串内容）
      - Node：节点对象
        
        是Document和Element对象的父类
    - 快捷查询方式：
      - selector：选择器
        使用的方法：Elements select(String cssQuery)
        语法：参考Selector类中定义的语法
      - XPath：XPath即为XML路径语言，它是一种来确定XML（标准通用标记语言的子集）文档中某部分位置的语言
        使用Jsoup的Xptah需要额外的jar包
        查询w3school参考手册，使用XPath的语法完成查询

web相关概念回顾

软件架构
- C/S：客户端/服务器端
- B/S：浏览器/服务器端
资源分类
- 静态资源：所有用户访问后，得到的结果都是一样的，成为静态资源。静态资源可以直接被浏览器解析
  - html css JavaScript
- 动态资源：每个用户访问相同资源后，得到的结果可能不一样。动态资源被访问后，需要先转化为静态资源，再返回给浏览器
  - servlet/jsp, php, asp
网络通信三要素
- IP：电子设备再网络中的唯一标识
- 端口：应用程序在计算机中的唯一标识 0-65536
- 传输协议：规定了数据传输的规则
  - 基础协议：
    - tcp：安全协议，三次握手
    - udp：不安全的广播协议

web服务器软件

服务器：安装了服务器软件的计算机
服务器软件：接收用户的请求，处理请求，做出响应
web服务器软件：
- 在web服务器软件中，可以部署web项目，让用户通过浏览器来访问这些项目
- web容器
常见的Java相关的web服务器软件：
- webLogic：Oracle公司。大型JavaEE服务器，收费。支持所有的JavaEE规范。
- webSphere：IBM公司。大型JavaEE服务器，收费。支持所有的JavaEE规范。
- JBOSS：JBOSS公司的，大型JavaEE服务器，收费。支持所有的JavaEE规范。
- Tomcat：apache基金组织，中小型JavaEE服务器，仅仅支持少量的JavaEE规范。servlet/jsp。开源的，免费的。
JavaEE：Java语言在企业级开发中使用的技术规范的总合，一共规定了13项大的规范
tomcat：web服务器软件
- 下载
- 安装：解压压缩包即可
  - 注意：安装目录不要有中文和空格
- 卸载：删除安装目录
- 启动：
  - bin/startup.bat，双击运行该文件
  - 访问：浏览器输入：http://localhost 回车访问访问自己
    
    http://别人的ip 访问别人
  - 可能遇到的问题：
    - 黑窗口一闪而过：
      - 原因：没有正确配置JAVA_HOME环境变量
      - 解决方案：重新配置JAVA_HOME环境变量
    - 启动报错：
      - 暴力：找到占用的端口号，并且找到对应的进程，杀死该进程
        netstat -ano
      - 温柔：修改自身的端口号
        conf/server.xml
        一般会将tomcat的端口号修改为80。80端口号是http协议的默认端口号
        好处：在访问时不用输入端口号
- 关闭：
  - 正常关闭：
    - bin/shutdown.bat
    - ctrl+c
  - 强制关闭：
    - 点击启动窗口的×
- 配置
  - 部署项目的方式：
    - 直接将项目放在webapps目录下即可
      - /hello：项目的访问路径（虚拟目录）
      - 简化部署：将项目打成war包，再将war包放置在webapps下，war包会自动解压缩
    - 配置conf/server.xml文件
      
      再标签体中配置：
      
      docBase指的是项目存放的路径
      
      path指的是虚拟目录
    - 在conf\Catalina\localhost创建任意名称的xml文件。在文件中编写<Context docBase=""/>【热部署】
      
      虚拟目录：文件的名称
  - 静态项目和动态项目
    - 目录结构：
      - Java动态项目的目录结构
        
        – 项目的根目录
        
        --WEB-INF目录
        
        --web.xml：web项目的核心配置文件
        
        --classes目录：防止字节码文件的目录
        
        --lib目录：防止依赖的jar包
  - 将tomcat集成到idea中，并且创建JavaEE的项目，部署项目

Servlet：server applet

概念：运行在服务器端的小程序
- servlet就是一个接口，定义了Java类被浏览器访问到（tomcat识别）的规则
- 将来我们自定义一个类，实现servlet接口，复写方法

快速入门：

创建JavaEE项目
定义一个类，实现servlet接口
实现接口中的抽象方法

配置servlet 在web.xml中配置

<!--    配置servlet-->
    <servlet>
        <servlet-name>demo1</servlet-name>
        <servlet-class>com.nakiri.web.servlet.ServletDemo1</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>demo1</servlet-name>
        <url-pattern>/demo1</url-pattern>
    </servlet-mapping>

执行原理：
- 当服务器接收到客户端浏览器的请求后，会解析请求的URL路径，获取访问的servlet的资源路径
- 查找web.xml文件，是否有对应的标签体内容。
- 如果有，则再找到对应的全类名
- tomcat会将字节码文件加载进内存，并且创建其对象
- 调用其方法
servlet中的声明周期：
- 被创建：执行init方法，只执行一次
  - servlet什么时候被创建？
    
    默认情况下，第一次被访问时，servlet被创建
    
    可以配置执行servlet的创建时机
    
    在标签下配置
    
    1.第一次被访问时创建
    值为负数，一般是-1（默认）
    2.在服务器启动时创建
    值为0或者正整数，一般设置为5或者10
  - servlet的init方法只执行一次，说明一个servlet在内存中只存在一个对象，servlet时单例的
    - 多个用户同时访问时，可能存在线程安全问题
      
      解决：尽量不要再servlet中定义成员变量。即使定义了成员变量，也不要对其修改值
- 提供服务：执行service方法，执行多次
  - 每次访问servlet时，service方法都会被调用一次
- 被销毁：执行destroy方法，只执行一次
  - servlet被销毁时执行。服务器关闭时，servlet被销毁
  - 只有服务器正常关闭时，才会执行destroy方法
  - destroy方法在servlet被销毁之前执行，一般用于释放资源
servlet3.0
- 好处：
  - 支持注解配置。可以不需要web.xml
- 步骤：
  - 创建JavaEE项目，选择servlet的版本3.0以上，可以不创建web.xml
  - 定义一个类，实现servlet接口
  - 复写方法
  - 在类上使用@webservlet注解，进行配置
    
    @webservlet(“资源路径”)、
servlet体系结构

servlet接口

|

GenericServlet --> 抽象类

|

HttpServlet -->抽象类
1. GenericServlet：将servlet接口中其他的方法做了默认实现，只将service()方法作为抽象
  1. 将来定义servlet类时，可以继承GenericServlet，实现service方法即可
2. HttpServlet：对HTTP协议的一种封装，简化操作
  1. 定义类继承HttpServlet
  2. 复写doGet/doHost
servlet相关配置
- urlpartten：servlet访问路径
  - 一个servlet可以定义多个访问路径：@WebServlet({"/d4","/dd4","/ddd4"})
  - 路径定义规则：
    - /xxx
    - /xxx/xxx：多层路径，目录结构
    - *.do

IDEA与tomcat的相关配置

IDEA会为每一个tomcat部署的项目单独建立一份部署文件
- 查看控制台的log：Using CATALINA_BASE: “H:\ideaIU-2019.3.1\bin\Idea\system\tomcat\Tomcat_10_0_4_20tomcat_2”
工作空间项目和tomcat部署的web项目
- tomcat真正访问的是“tomcat部署的web项目”，“tomcat部署的web项目”对应着工作空间下的web目录下的所有资源
- WEB-INF目录下的资源不能被浏览器直接访问
断点调试：使用debug启动

HTTP

概念： Hyper Text Transfer Protocol 超文本传输协议
- 传输协议：定义了客户端和服务器端通信时，发送数据的格式
- 特点：
  - 基于TCP/IP的高级协议
  - 默认端口号：80
  - 基于请求/响应模型的：一次请求对应一次响应
  - 无状态的：每次请求之间相互独立，不能交互数据
- 历史版本：
  - 1.0：每一次请求响应都会建立新的连接
  - 1.1：复用连接
请求消息数据格式
- 请求行
  
  请求方式请求url 请求协议/版本
  
  GET /login.html HTTP/1.1
  - 请求方式：
    - HTTP协议中有7中请求方式，常用的有2种
      - GET：
        请求参数在请求行中，在url后
        请求的url长度有限制
        不太安全
      - POST
        请求参数在请求体中
        请求的url成都没有限制
        相对安全
- 请求头：客户端浏览器告诉服务器一些信息
  
  请求头名称：请求头值
  
  常见的请求头
  User-Agent：浏览器告诉服务器，我访问你使用的浏览器版本信息
  
  可以在服务器段获取该头的信息，解决浏览器的兼容性问题
  
  Referer：http://localhost/21servlet_war_exploded/login.html
  
  告诉服务器当前请求从哪里来
```
  1. 防盗链：
  2. 统计工作：
```
- 请求空行
  
  空行，用于分割POST请求的请求头和请求体的
- 请求体（正文）
  - 封装POST请求消息的请求参数的
字符串格式：
```
GET /login.html HTTP/1.1
HTTP/1.1 200
Date: Thu, 12 Aug 2021 03:00:27 GMT
Accept-Ranges: bytes
ETag: W/"239-1628694950000"
Last-Modified: Wed, 11 Aug 2021 15:15:50 GMT
Content-Type: text/html
Content-Length: 239

username=nakiri
```
响应消息数据格式
- 响应行
  - 组成：协议/版本响应状态码状态码描述
  - 响应状态码：服务器告诉客户端浏览器本次请求和响应的一个状态
    - 状态码都是三位数字
    - 分类
      - 1xx：服务器接收客户端消息，但是没有接收完成，等待一段时间后，发送1xx状态码
      - 2xx：成功。代表：200
      - 3xx：重定向。代表：302(重定向)，304(访问缓存)
      - 4xx：客户端错误。代表：404(请求路径没有对应的资源) 405：请求方式没有对应的doXxx方法
      - 5xx：服务器端错误。代表：500(服务器内部出现异常)
- 响应头
  - 格式：头名称：值
  - 常见的响应头
    
    Content-Type:服务器告诉客户端本次响应体数据格式以及编码格式
    
    Content-disposition:服务器告诉客户端以什么格式打开响应体数据
    
    值：
    
    inline：默认值，在当前页面打开
    
    attachment;filename=xxx：以附件形式打开响应体。文件下载
- 响应空行
- 响应体
  - 传输的数据
  响应字符串格式
  
  HTTP/1.1 200
  
  Content-Type: text/html;charset=UTF-8
  
  Content-Length: 99
  
  Date: Sat, 14 Aug 2021 11:39:52 GMT
  
  Keep-Alive: timeout=20
  
  Connection: keep-alive

Request

request对象和response对象的原理
- request和response对象是由服务器创建的。我们来使用它
- request对象是来获取请求消息，response对象是来设置响应消息
request对象继承体系结构：

ServletRequest -->接口

|

HttpServletRequest -->接口

|

org.apache.catalina.connector.RequestFacade -->类(tomcat)
request：
- 获取请求消息数据
  - 获取请求行数据
    - GET /day14/demo1?name=nakiri HTTP/1.1
    - 方法：
      - 获取请求方式： GET
        
        String getMethod()
      - 获取虚拟目录： /day14
        
        String getConextPath()
      - 获取servlet路径：demo1
        
        String getServletPath()
      - 获取get方式的请求参数：name=nakiri
        
        String getQueryString()
      - 获取请求的URI：/day14/demo1
        
        String getRequestUri()：/day14/demo1
        
        StringBuffer getRequestURL()：http://localhost/day14/demo1
        
        URL：统一资源定位符
        
        URI：统一资源标识符
      - 获取协议及版本：HTTP/1.1
        
        String getProtocol()
      - 获取客户机的IP地址
        
        String getRemoteAddr()
  - 获取请求头数据
    - 方法：
      
      String getHeader(String name)：通过请求头的名称获取请求头的值
      
      Enumeration getHeaderNames()：获取所有的请求头的名称
  - 获取请求体数据
    - 请求体：只有POST请求方式才有请求体，在请求体中封装了POST请求的请求参数
    - 步骤：
      - 获取流对象
        
        BufferReader getReader()：获取字符输入流，只能操作字符数据
        
        ServletInputStream getInputStream()：获取字节输入流，可以操作所有类型数据
      - 再从流对象中拿数据
- 其他功能
  - 获取请求参数通用方式：不论get还是post请求方式都可以使用下列方法来获取请求参数
    - String getParameter(String name)：根据参数名称获取参数值 username=nakiri&password=123
    - String[] getParameterValues(String name)：根据参数名称获取参数值的数组 hobby=xx&&hobby=yy
    - Enumeration getParameterNames()：获取所有请求的参数名称
    - Map getParameterMap()：获取所有参数的map集合
      
      中文乱码问题：
      
      get方式：tomcat8已经将get方式乱码问题解决了
      
      post方式：在获取参数前，设置request的编码req.setCharacterEncoding(“utf-8”);
  - 请求转发
    - 步骤：通过request对象获取请求转发器对象：
      - RequestDispatcher getRequestDispatcher(String path)
      - 使用RequestDispatcher对象进行转发：forward(ServletRequest request, ServletResponse response)
    - 特点：
      - 浏览器地址栏路径没有发生变化
      - 只能转发到当前的服务器内部的资源中
      - 转发是一次请求
  - 共享数据
    - 域对象：一个有作用范围的对象，可以在范围内共享数据
    - request域：代表了一次请求，一般用于请求转发的多个资源中共享数据
    - 方法：
      - setAttribute(String name, Objet obj)：存储数据
      - Object getAttribute(String name)：通过键获取值
      - removeAttribute(String name)：通过键移除键值对
  - 获取ServletContext
    - ServletContext getServletContext()
BeanUtils工具类，简化数据封装
- 用于封装JavaBean的
  - JavaBean：标准的Java类
    - 类必须被public修饰
    - 必须提供空参的构造器
    - 成员变量必须使用private修饰
    - 提供公共的getter和setter方法
  - 功能：封装数据
- 概念：
  - 成员变量
  - 属性：setter和getter方法截取后的产物
- 方法：
  - setProperty()
  - getProperty()
  - populate()

Response

功能：设置响应消息
- 设置响应行
  - 格式：HTTP/1.1 200 ok
  - 设置状态码：setStatus(int sc)
- 设置响应头
  - setHeader(String name, String value)
- 设置响应体
  - 使用步骤：
    - 获取输出流
      - 字符输出流：PrintWriter getWriter()
      - 字节输出流：ServletOutputStream getOutputStream()
    - 使用输出流，将数据输出到客户端浏览器中
- 案例：
  - 完成重定向
    - 重定向：资源跳转的方式
    - 代码实现
```
        //访问/responseDemo1资源，会自动跳转到/responseDemo2资源
        // 1.设置状态码302
        resp.setStatus(302);
        //2.设置响应头location
        resp.setHeader("location", "/22Rsponse_war_exploded/responseDemo2");
        
        //简单的重定向方法
        resp.sendRedirect("/22Rsponse_war_exploded/responseDemo2");
```
    - 重定向的特点
      - 地址栏发生变化
      - 重定向可以访问其他站点的资源
      - 重定向是两次请求，不可以使用request对象来共享数据
    - 转发的特点：
      - 转发地址栏路径不变
      - 转发只能访问当前服务器下的资源
      - 转发是一次请求，可以使用request对象来共享数据
    - forward和redirect区别
    - 路径的写法：
      - 路径的分类：
        
        相对路径：通过相对路径不可以确定唯一资源
        
        如：./index.html
        不以/开头的，以.开头
        规则：找到访问的当前资源和目标资源之间的相对位置关系
        ./：当前目录
        …/：后退一级目录
        
        绝对路径：通过绝对路径可以确定唯一资源
        
        如：/22Rsponse_war_exploded/responseDemo2
        
        以 / 开头的路径
        
        规则：判断定义的路径是给谁用的？判断请求将来从哪发出
        
        给客户端浏览器使用：需要加虚拟目录（项目的访问路径）
        
        建议虚拟目录动态获取
        
        reqs.getContextPath()
        
        ，，重定向
        
        给服务器用：不需要加虚拟路径
  - 服务器输出字符数据到浏览器
    - 步骤：
      - 获取字符输出流
      - 输出数据
    - 注意：
      - 乱码问题：
        
        PrintWriter writer = resp.getWriter();获取的流的默认编码是ISO-8859-1
        
        设置该流的默认编码
        
        告诉浏览器响应体使用的编码
        
        resp.setContentType("text/html;charset=utf-8"); //在获取流之前设置
  - 服务器输出字节数据到浏览器
    - 步骤：
      - 获取字节输出流
      - 输出数据
  - 验证码
    - 本质上是一张图片
    - 目的：防止恶意表单注册

ServletContext对象

概念：代表整个web应用，可以和程序的容器(服务器)来通信
获取：
- 通过requst对象获取
  
  reqs.getServletContext()
- 通过HttpServlet来获取
  
  getServletContext()
功能：
- 获取MIME类型
  - MIME：在互联网通信过程中定义的一种文件数据类型
    - 格式：大类型/小类型 text/html image/jpeg
    - 获取：String getMimeType(String file)
- 域对象：共享数据
  - setAttribute(String name,Object value)
  - getAttribute(String name)
  - removeAttribute(String name)
  - ServletContext对象范围：所有用户所有请求的数据
- 获取文件的真实路径（服务器路径）
  - 方法：String getRealPath(String path)
案例：
- 文件下载需求：
  - 页面显示超链接
  - 点击超链接后弹出下载提示框
  - 完成图片文件下载
- 分析：
  - 超链接指向的资源如果能够被浏览器解析，则在浏览器中展示，如果不能解析，则弹出下载提示框。不满需求
  - 任何资源都必须弹出下载提示框
  - 使用响应头设置资源的打开方式
    - content-disposition:attachment;filename=xxx
- 步骤
  - 定义页面，编辑超链接的href属性，指向servlet，传递资源名称filename
  - 定义servlet
    - 获取文件名称
    - 使用字节输入流加载文件进内存
    - 指定response的响应头：content-disposition:attachment;filename=xxx
    - 将数据写出到response输出流
  - 问题：
    - 中文文件名
      - 获取客户端使用的浏览器版本信息
      - 根据不同的版本信息，响应不同的数据，设置filename的编码方式不同

会话技术

会话：一次会话中包含多次请求和响应
- 一次会话：浏览器第一次给服务器资源发送请求，会话建立。直到有一方断开为止
- 功能：在一次会话的范围内的多次请求间，共享数据
- 方式
  - 客户端会话技术：cookie
  - 服务器端会话技术：session
Cookie
- 概念：客户端会话技术，将数据保存在客户端
- 快速入门：
  - 使用步骤
    - 创建Cookie对象，绑定数据
      
      new Cookie(String name,String value)
    - 发送Cookie对象
      
      resp.addCookie(Cookie cookie)
    - 获取Cookie对象，拿到数据
      
      Cookie[] reqs.getCookies
- 实现原理：基于响应头set–cookie和请求头cookie实现
- cookie细节
  - 一次可不可以发送多个cookie？
    
    可以。可以创建多个cookie对象，使用response调用多次addCookie方法发送cookie即可
  - cookie再浏览器中保存多长时间？
    
    默认情况下，当浏览器关闭以后，cookie数据被销毁
    
    设置cookie的声明周期，持久化存储
    
    setMaxAge(int seconds)
    - 正数：将cookie数据写道硬盘的文件中。持久化存储。cookie存活时间
    - 负数：默认值
    - 零：删除cookie信息
  - cookie能不能存中文？
    
    在tomcat8之前， cookie不能直接存储cookie数据
    
    需要将中文数据转码，一般采用url编码
    
    在tomcat8之后，cookie支持中文数据
  - cookie共享问题？
    1. 假设在一个tomcat服务器中，部署了多个web项目，那么这些web项目中的cookie能不能共享？
      
      默认情况下cookie不能共享
      
      setPath(String path)：设置cookie范围。默认情况下，设置当前的虚拟目录。如果要共享，可以将路径设置为“/”
    2. 不同的tomcat服务器间cookie共享问题
      
      setDomain(String path)：如果设置一级域名相同，那么多个服务器间cookie共享
      
      setDomain(".nakiri.com")，那么do.nakiri.com和so.nakiri.com中cookie可以共享
  - cookie存储的特点和作用
    - cookie存储数据在客户端浏览器
    - 浏览器对于单个cookie的大小有限制（4kb），以及对同一个域名下的总cookie数量有限制（限制在20个以内）
    - 作用
      cookie一般用于存储少量的不太敏感的数据
      在不登陆的情况下，完成服务器对客户端的身份识别
  - 案例：记住上一次访问时间
    - 需求：
      - 访问一个servlet，如果是第一次访问，则提示：您好，欢迎您首次访问
      - 如果不是第一次访问，则提示：欢迎回来，您上次访问时间为：显示时间字符串
    - 分析：
      - 可以采用cookie来完成
      - 在服务器的servlet判断是否有一个名为lasTime的cookie
        有：不是第一次访问
        响应数据：欢迎回来，您上次访问时间为：显示时间字符串
        写回cookie：lastTime=（时间）
        
        没有：是第一次访问
        响应数据：您好，欢迎您首次访问
        写回cookie：lastTime=（时间）

JSP

概念：Java server pages：Java服务器端页面
- 可以理解为一个特殊的页面，其中既可以定义html标签，又可以定义Java代码。用于简化书写。
原理：本质上就是一个servlet
JSP的脚本
1. JSP来定义Java代码的方式
2. 种类
  1. <% 代码 %>：定义的Java代码，在service代码中。service方法中可以定义什么，该脚本中就可以定义什么
  2. <%! 代码 %>：定义的Java代码，在jsp转换后的Java类的成员位置。
  3. <%= 代码 %>：定义的Java代码会输出到页面上。输出语句中可以定义什么，脚本中就可以定义什么
JSP指令
- 作用：用于配置JSP页面，导入资源文件
- 格式：
  
  <%@ 指令名称属性名1=属性值1 属性名2=属性值2 … %>
- 分类：
  - page：用于配置jsp页面
    
    content-type：等同于response.setContentType()
    
    设置响应体的mime类型以及字符集
    
    设置当前jsp页面的字符集（只能是高级的IDE才能生效，如果是使用低级工具，则需要设置pageEncoding属性设置当前页面的字符集）
    
    buffer：缓冲区大小。默认8kb
    
    import：导包
    
    errorPage：当前页面发生异常后，会自动跳转到指定的错误页面
    
    isErrorPage：标示当前页面是否是错误页面
    
    true：是，可以使用内置对象exception
    
    false：否。默认值。不可以使用内置对象exception
  - include：页面包含的。导入页面的资源文件
    
    <%@include file=“xxx.jsp”%>
  - taglib：导入资源
```
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
```
    prefix：前缀，自定义的
注释：
- html注释：只能注释html代码片段
- jsp注释
  
  <%-- --%>：可以注释所有。推荐使用
JSP的内置对象
- 在jsp页面中不需要获取和创建，可以直接使用的对象
- jsp一共有9个内置对象
  - request：一次请求访问的多个资源（转发）
  - response：响应对象
  - out：字符输出流对象。可以将数据输出到页面上。和response.getWriter()类似
    
    response.getWriter().write()和out.write()的区别：
    
    response.getWriter().write()数据输出永远在out.write()之前
    
    在tomcat服务器真正给客户端做出相应之前，会先找response缓冲区数据，再找out缓冲区数据
  - pageContext：当前页面共享数据，还可以获取其他八个内置对象
  - session：一次会话的多个请求间
  - application：所有用户间共享数据（唯一）
  - page：当前页面（servlet）的对象 this
  - config：servlet的配置对象
  - exception：异常对象
  - 真实类型
    
    pageContext PageContext
    
    request HttpServetRequest
    
    session HttpSession
    
    application ServletContext
    
    response HttpServletResponse
    
    page Object
    
    out JspWriter
    
    config ServletConfig
    
    exception Throwable

Session

概念：服务器端会话技术，在一次会话的多次请求间共享数据，将数据保存在服务器端的对象中。HttpSession
快速入门：
- HttpSession对象
  - Object getAttribute(String name)
  - void setAttribute(String name, Object value)
  - void removeAttribute(String name)
原理：session的实现是依赖于cookie的
细节：
- 当客户端关闭后，服务器不关闭，两次获取session是否为同一个？
  
  默认情况下不是。
  
  如果需要相同，则可以创建cookie，键为JSESSIONID，设置最大存活时间，让cookie持久化保存
```
HttpSession session = req.getSession();
//期望客户端关闭后session也能相同
Cookie c = new Cookie("JSESSIONID", session.getId());
c.setMaxAge(60*60);
resp.addCookie(c);
System.out.println(session);
```
- 客户端不关闭，服务器关闭后，两次获取的session是同一个么？
  
  不是同一个，但是要确保数据不丢失
  
  session的钝化
  
  在服务器正常关闭之前，将session对象系列化到硬盘上
  
  session的活化
  
  zai 服务器启动后，将session文件转化为内存中的session对象
- session的失效时间
  
  服务器关闭
  
  session对象调用invalidate()
  
  session默认失效时间 30分钟
  
  选择性配置修改
```
<session-config>
    <session-timeout>30</session-timeout>
</session-config>
```
session的特点：
- session用于存储一次会话的多次请求的数据。存在服务器端
- session可以存储任意类型，任意大小的数据
- session与cookie的区别
  
  session存储数据在服务器端，cookie在客户端
  
  session没有数据大小限制，cookie有
  
  session数据安全，cookie相对于不安全

MVC开发模式

MVC：
- M：model，模型（JavaBean）
  - 业务逻辑操作。如查询数据库，封装对象
- V：view，视图（JSP）
  - 展示数据
- C：controller，控制器（servlet）
  - 获取客户端的输入
  - 调用模型
  - 将数据交给视图展示
- 优缺点
  - 优点
    - 耦合性低，方便维护，可以利于分工协作
    - 重用性高
  - 缺点
    - 使得项目架构变得复杂。对开发人员要求高

EL表达式

概念：Expression Language 表达式语言
作用：替换和简化jsp页面中Java代码的编写
语法：${表达式}
注意：
- jsp默认支持el表达式。
  - 如果要忽略el表达式：
    - 设置JSP中page指令中的isELIgnored=“true”
    - \${表达式}：掳掠当前这个el表达式
使用：
- 运算
  - 运算符
    - 算术运算符：+ - * / (div) %(mod)
    - 比较运算符： > < >= <= == !=
    - 逻辑运算符：&&（and） ||（or）！（not）
    - 空运算符：empty
      - 功能：用于判断字符串、集合和数组对象是否为null并且长度是否为0
      - ${empty list}：判断字符串、集合、数组对象是否不为null并且长度>0
      - ${not empty list}：表示判断字符串、集合、数组对象是否不为null并且长度>0
- 获取值
  - el表达式只能从域对象中获取值
  - 语法：
    - ${域名称.键名称}：从指定域中获取指定键的值
      - 域名称
        
        pageScope–>pageContext
        
        requestScope–>request
        
        sessionScope–>session
        
        applicationScope–>application(ServletConetxt)
        
        举例：在request域中存储了name=张三
        
        获取：${requestScope.name}
    - ${键名}：表示依次从最小的域中查找是否有该键对应的值，直到找到为止
  - 获取对象、list集合、map集合的值
    - 对象：${域名称.键名.属性名}
      
      本质上会调用对象的getter方法
    - List集合：${域名称。键名[索引]}
    - Map集合：
      - ${域名称.键名.key名称}
      - ${域名称.键名[“key名称”]}
  - 隐式对象：
    
    el表达式中有11个隐式对象
    
    pageContext：
    1. 获取jsp其他8个内置对象
    2. ```
    <h4>在jsp页面动态获取虚拟目录</h4>
    ${pageContext.request.contextPath}<br>
```

JSTL标签

概念：JavaServer pages tag library JSP标准标签库
- 是由apache组织提供的开源的免费的jsp标签
作用：用于简化和替换jsp页面上的Java代码
使用步骤：
- 导入jar包
- 引入标签库：taglib指令：<%@ taglib %>
- 使用标签
常用的JSTL标签
- if：相当于Java代码的if语句
- choose：相当于switch语句
- foreach：相当于for语句

三层架构：软件架构设计

界面层（表示层）web：用户看得到的界面。用户可以通过界面上的组件和服务器进行交互。接收用户参数，封装数据，调用业务逻辑层完成处理，转发jsp页面完成显示
业务逻辑层（service层）service：处理业务逻辑。组合Dao层中的简单方法，形成复杂的功能（业务逻辑操作）
数据访问层（dao层）dao：操作数据存储文件【dao：Data Access Object】。定义了对于数据库基本的CRUD操作
案例
- 需求：用户信息的增删改查操作
- 设计：
  - 技术选型：servlet + jsp + mysql + JDBCTempleat+druid+BeanUtils+tomcat
  - 数据库设计：
```
create database test1;

use test1;

create table user(
id int primary key auto_increment,
name varchar(20) not null,
gender varchar(5),
age int,
address varchar(32),
qq varchar(20),
email varchar(50)
);
```
- 开发：
  - 环境搭建
    - 创建数据库环境
    - 创建项目，导入需要的jar包
  - 编码
- 测试
- 部署运维

Filter：过滤器

web中的过滤器：当访问服务器资源时，过滤器可以将请求拦截下来，完成一些特殊的功能
作用：
- 一般用于完成通用的操作。如：登陆验证、统一编码处理、敏感字符的过滤
快速入门：
- 步骤
  1. 定义一个类，实现接口Filter
  2. 复写方法
  3. 配置拦截路径
    1. web.xml
    2. 注解
过滤器细节：
- web.xml配置
```
<filter>
        <filter-name>demo1</filter-name>
        <filter-class>com.nakiri.web.filter.FilterDemo1</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>demo1</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
```
- 过滤器执行流程
  - 执行过滤器
  - 执行放行后的代码
  - 回来执行过滤器放行代码下边的代码
- 过滤生命周期方法
  - init
  - destroy
  - doFilter
- 过滤器配置详解
  - 拦截路径配置
    - 具体资源路径：/index.jsp 只有访问index.jsp资源时，过滤器才会被执行
    - 拦截目录：/user/* 只有访问/user下的所有资源时，过滤器才会被执行
    - 后缀名拦截：*.jsp 访问所有后缀名为.jsp资源时，过滤器会被执行
    - 拦截所有资源：/* 访问所有资源时，过滤器都会被执行
  - 拦截方式配置：资源被访问的方式
    - 注解配置
      - 设置dispatcherTypes
        REQUEST：默认值。浏览器直接请求资源
        FORWARD：转发访问资源
        INCLUDE：包含访问资源
        ERROR：错误跳转资源
        ASYNC：异步访问资源
    - web.xml配置
      - 设置
- 过滤器链（配置多个过滤器）
  - 执行顺序：如果有两个过滤器：过滤器1和过滤器2
    - 过滤器1
    - 过滤器2
    - 资源执行
    - 过滤器2
    - 过滤器1
  - 过滤器先后顺序问题
    - 注解配置：an找类型的字符串比较规则进行比较，值小的先执行
      - AFilter和BFilter AFilter先执行
    - web.xml配置：
      - 谁定义在上面，谁先执行
  - 增强对象的功能
    - 设计模式：一些通用的解决固定问题的方式
      - 装饰模式
      - 动态模式
        概念：
        真实对象：被代理的对象
        代理对象
        代理模式：代理对象代理真实对象，达到增强真实对象功能的目的
        
        实现方式：
        动态代理：在内存中形成代理类
        实现步骤：代理对象和真实对象实现相同的接口
        代理对象 = Proxy.newProxyInstance();
        使用代理对象调用方法
        增强方法
        
        静态代理：在有一个类文件描述代理模式
        
        增强方式：
        增强参数列表
        增强返回值类型
        增强方法体执行逻辑

Listener：监听器

概念：web的三大组件之一
- 事件监听机制
  - 事件：一件事情
  - 事件源：事情发生的地方
  - 监听器：一个对象
  - 注册监听：将事件、事件源、监听器绑定在一起。当事件源上发生某个事件后，执行监听器代码
ServletContextListener：监听ServletContext对象的创建和销毁
- 方法
  - void contextDestoryed(ServletContextEvent sce)：ServletContext对象被销毁之前会调用该方法
  - void contextIntitialized(ServletContextEvent sce)：ServletContext对象被创建后会调用该方法
- 步骤：
  - 定义一个类，实现ServletContextListener接口
  - 复写方法
  - 配置
    - web.xml
```
<listener>
    <listener-class>com.nakiri.web.listener.ContextLoaderListener</listener-class>
</listener>


    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/classes/applicationContext.xml</param-value>
    </context-param>
```
    - 注解配置

JQuery

概念：一个JavaScript框架，简化JavaScript的开发
快速入门：
- 步骤：
  - 下载jQuery
  - 导入js文件
  - 使用
jQuery对象和js对象区别与转换

jquery对象在操作时更加方便
jQuery对象和js对象的方法是不通用的
两者互相转换
1. jq->js: jq[索引] 或者 jq对象.get(索引)
2. js->jq: $(js对象)
选择器：筛选具有相似特征的元素（标签）
- 基本语法：
  - 事件绑定
  - 入口函数
  - 样式控制
- 分类：
  - 基本选择器
    - 标签选择器（元素选择器）
      
      $(“html标签名”) 获得所有匹配标签名称的元素
    - id选择器
      
      $("#id的属性值") 获得与指定id属性值匹配的元素
    - 类选择器
      
      $(".class的属性") 获得与指定的class属性匹配的元素
    - 并集选择器
      
      $(“选择器1，选择器2…”) 获取多个选择器选中的所有元素
  - 层级选择器
    - 后代选择器
      
      $(“A B”) 选择A元素内部的所有B元素
    - 子选择器
      
      $(“A > B”) 选择A元素内部的所有子元素
  - 属性选择器
    - 属性名称选择器
      
      $(“A[属性名]”) 包含指定属性的选择器
    - 属性选择器
      
      $(“A[属性名称=‘值’]”) 包含指定属性等于指定值的选择器
    - 复合属性选择器
      
      $(“A[属性名=‘值’][ ]…”) 包含多个属性条件的选择器
  - 过滤选择器
    - 首元素选择器
      
      :first 获得选择的元素中的第一个元素
    - 尾元素选择器
      
      :last 获得选择的元素中的最后一个元素
    - 非元素选择器
      
      :not(selecter) 不包括指定内容的选择器
    - 偶数选择器
      
      :even 偶数，从0开始计数
    - 奇数选择器
      
      :odd 奇数，从0开始计数
    - 等于索引选择器
      
      :eq(index) 指定索引元素
    - 大于索引选择器
      
      :gt(index) 大于指定索引元素
    - 小于索引选择器
      
      :lt(index) 小于指定索引元素
    - 标题选择器
      
      :header 获得标题元素（h1-h6），固定写法
  - 表单过滤选择器
    - 可用元素选择器
      
      :enable 获得可用元素
    - 不可用元素选择器
      
      :disable 获得不可用元素
    - 选中选择器
      
      :checked 获得单选/复选框选中的元素
    - 选中选择器
      
      :selected 获得下拉选框中的元素
DOM操作
- 内容操作
  - html()：获取/设置元素的标签体内容
  - text()：获取/设置元素的纯文本内容
  - val()：获取/设置元素的value属性值
- 属性操作
  - 通用属性操作
    - attr()：获取/设置元素的属性
    - removeAttr()：删除属性
    - prop()：获取/设置元素的属性
    - removeProp()：删除属性
      attr和prop的区别
      
      如果操作的是元素的固有属性，则建议用prop
      如果操作的是自定义属性，建议使用attr
  - 对class属性操作
    - addClass()：添加class属性值
    - removeClass()：删除class属性值
    - toggleClass()：切换class属性（有该属性就删除，没有该属性就添加）
- CRUD操作
  - append()：父元素将子元素追加到末尾
    - 对象1.append(对象2)：将对象2添加到对象1元素的内部，并且在末尾
  - prepend()：父元素将子元素追加到开头
    - 对象1.prepend(对象2)：将对象2添加到对象1元素的内部，并且在开头
  - appendTo()：
    - 对象1.appendTo(对象2)：将对象1添加到对象2内部，并在末尾
  - prependTo()：
    - 对象1.prependTo(对象2)：将对象1添加到对象2内部，并在开头
  - after()：添加元素到元素后边
    - 对象1.after(对象2)：将对象2添加到对象1后边。对象1，对象2是兄弟关系
  - before()：添加元素到元素前边
    - 对象1.before(对象2)：将对象2添加到对象1前边。对象1，对象2是兄弟关系
  - insertAfter()：
    - 对象1.insertAfter(对象2)：将对象2添加到对象1后边
  - insertBefore()：
    - 对象1.insertBefore(对象2)：将对象2添加到对象1前面
  - remove()：移除元素
    - 对象.remove()：将对象删除掉
  - empty()：清空元素的所有后代元素
- 动画
  - 三种方式显示和隐藏元素
    - 默认显示和隐藏方式
      - show([speed],[easing],[fn])
        参数：
        speed：速度（slow，normal，fast或者毫秒值）
        easing：指定切换效果（默认swing，可以切换linear）。swing：先慢，中间快，最后慢。linear：执行速度匀速
        fn：在动画完成时执行的函数，每个元素执行一次
      - hide([speed],[easing],[fn])
      - toggle([speed],[easing],[fn])
    - 滑动显示和隐藏方式
      - slideDown([speed],[easing],[fn])
      - slideUp([speed],[easing],[fn])
      - slideToggle([speed],[easing],[fn])
    - 淡入淡出显示和隐藏方式
      - fadeIn([speed],[easing],[fn])
      - fadeOut([speed],[easing],[fn])
      - fadeToggle([speed],[easing],[fn])
- 遍历
  - js遍历方式
    - for(初始化值;循环结束条件;步长)
  - jq遍历方式
    - jq对象.each(callback)
      - callback：回调函数。可以在回调函数中定义参数index(索引)，element（元素对象）
      - 如果要跳出当前循环，则可以return false; (break) return true;则是继续循环（continue）
    - $.each(object,[callback])
    - for…of：jQuery3.0之后提供的方式
      - for(list of element){…}
- 事件绑定
  - jquery标准的绑定方式
    - jq对象.事件方法(回调函数);
  - on绑定事件/off接触绑定
    - jq对象.on(“事件名称”,回调函数)
    - jq对象.off(“事件名称”)
  - 事件切换：toggle
    - jq对象.toggle(fn1,fn2…)
      - 当单击jq对象对应的组件后，会执行fn1，第二次点击会执行fn2…（此方法在1.9版本后被删除）
- 插件：增强jQuery功能
  - $fn.extend(object)
    - 增强通过jQuery获取的对象的功能 $("#id")
  - $.extend(object)
    - 增强jQuery对象自身的功能 $/jQuery

AJAX

概念：asynchronous JavaScript And XML 异步的JavaScript和xml
- 异步和同步：在客户端和服务器互相通信的基础上：
  - 同步：客户端必须等待服务器端的响应。在等待的期间客户端不能做其他操作
  - 异步：客户端不需要等待服务器端的响应。在服务器处理请求的过程中，客户端可以进行其他的操作
实现方式：
- 原生的JS实现方式(了解)
- jQuery的实现方式
  - $.ajax()
    - 语法： $. a j a x (u r l, [s e t t i n g s]) 一般来说是这样写：$ .ajax({键值对})
  - $.get()：发送get请求
    - 语法：$.get(url,[data],[callback],[type])
      - url：请求路径
      - data：请求参数
      - callback：回调函数
      - type：响应结果的类型
  - $.post()：发送post请求
    - 语法：$.post(url,[data],[callback],[type])

JSON

概念：JavaScript object notation JavaScript对象表示法
- json现在多用于存储和交换文本信息的语法
- 进行数据的传输
- json比xml更小、更快、更易解析
语法
- 基本规则
  - 数据在名称/值对中：json数据是由键值对构成的
    - 键用引号引起来，也可以不使用引号
    - 值的取值类型
      - 数字（整数或浮点数）
      - 字符串（双引号中）
      - 逻辑值（true或者false）
      - 数组（在方括号中）
      - 对象（在花括号中）
      - null
  - 数据由逗号分隔：多个键值对由逗号分隔
  - 花括号保存对象：使用{}来定义json格式
  - 方括号保存数组：[]
- 获取数据
  - json对象.键名
  - json对象[“键名”]
  - 数组对象[索引]
  - 获取person对象中所有的键和值：遍历：for in 循环
```
for(var key in person){
    altert(key + ":" + person[key]);
}
```
- json数据和Java对象的相互转换
  
  json解析器：
  
  Jsonlib，Gson，fastjson，Jackson
  - json转为Java对象
    - 使用步骤：
      - 导入Jackson的jar包
      - 创建Jackson核心对象ObjectMapper
      - 调用ObjectMapper的相关方法进行转换
        readValue(json字符串数据,Class)
  - Java对象转换json
    - 使用步骤：
      - 导入Jackson的jar包
      - 创建Jackson核心对象ObjectMapper
      - 调用ObjectMapper的相关方法进行转换
        
        转换方法：
        writeValue(参数一,obj):
        参数一：
        File：将obj对象转换为JSON字符串，并保存到指定的文件中
        Writer：将onj对象转换为JSON对象，并将JSON数据填充到字符输出流中
        OutputStream：将onj对象转换为JSON对象，并将JSON数据填充到字节输出流中
        
        writeValueAsString(obj):将对象转为json字符串
        
        注解：
        
        @JsonIgnore：排除属性
        
        @JsonFormat：属性值的格式化
        
        @JsonFormat(pattern = "yyyy-MM-dd")//属性格式转换
        
        复杂Java对象转换
        
        list：数组
        
        Map：对象格式一致

redis

概念：是一款高性能的NOSQL系列的非关系型数据库
- 数据之间没有关联关系
- 数据存储在内存中
- 一般会将数据存储在关系型数据库中，在nosql数据库中备份存储关系型数据库的数据
下载安装
- 解压直接可以使用
  - redis.windows.conf：配置文件
  - redis-cli.exe：redis的客户端
  - redis-server.exe：redis的服务器端
命令操作
- 数据结构：
  - redis存储的是key-value格式的数据，其中key都是字符串，value有五种不同的数据结构
    - 字符串类型 String
    - 哈希类型 hash：map格式
    - 列表类型 list：linkList格式
    - 集合类型 set
    - 有序集合类型 sortedset
  - 字符串类型 String
    - 存储：set key value
    - 获取：get key
    - 删除：del key
  - 哈希类型 hash
    - 存储：hset key field value
    - 获取：hget key field 获得指定的value
      
      hgetall key 获取所有的field和value
    - 删除：hdel key field
  - 列表类型 list：可以添加一个元素到列表的头部（左边）或者尾部（右边）
    - 添加：
      - lpush key value：将元素加入列表左边
      - rpush key value：将元素加入列表右边
    - 获取：
      - lrange key start end ：范围获取
    - 删除：
      - lpop key：删除列表最左边的元素，并将元素返回
      - rpop key：删除列表最右边的元素，并将元素返回
  - 集合类型 set：不允许重复元素
    - 存储：sadd key value
    - 获取：smembers key：获取set集合中所有的元素
    - 删除：srem key value：删除set集合中的某个元素
  - 有序集合类型 sortedset：不允许重复元素且元素有序
    - 存储：zadd key srcore value
    - 获取：zrange key start end
    - 删除：zrem key value
通用命令
- keys *：查询所有的键
- type key：获取键对应的value的类型
- del key：删除指定的key value
持久化操作
- redis是一个内存数据库，当redis服务器重启，或者电脑重启时数据会丢失。我们可以将redis内存中的数据持久化的保存在硬盘的文件中
- redis持久化机制
  - RDB：默认方式，不惜要进行配置，默认就使用这种机制
    - 在一定的间隔时间中，检测key的变化情况，然后持久化数据
    - 编辑redis.windwos.conf文件
      
      save 900 1
      save 300 10
      save 60 10000
    - 重新启动redis服务器并指定配置文件名称
      
      …>redis-server.exe redis.windows.conf
  - AOF：日志记录，可以记录每一条命令的操作。可以每一次命令操作后，持久化数据
    - 编辑redis.windwos.conf文件
      
      appendonly yes
    - appendfsync always：每一次操作都进行持久化
      
      appendfsync everysec：每隔一秒进行一次持久化
      
      appendfsync no：不进行持久化
使用Java客户端操作redis
- jedis：一款Java操作redis数据库的工具
- 使用步骤：
  - 下载jedis的jar包
  - 使用
jedis连接池：jedisPool
- 使用：
  - 创建JedisPool连接池对象
  - 调用 getResource()方法获取连接

MAVEN

功能：
- 依赖管理
- 一键构建：编译(compile)、测试(test)、打包(package)、安装(install)、发布(d)
仓库的种类：
- 本地仓库
- 远程仓库（私服）
- 中央仓库：几乎所有开源的jar包
maven标准目录结构
- src/main/java 核心代码部分
- src/main/resources 配置文件部分
- src/test/java 测试代码部分
- src/test/resources 测试配置文件
  示法
- json现在多用于存储和交换文本信息的语法
- 进行数据的传输
- json比xml更小、更快、更易解析
语法
- 基本规则
  - 数据在名称/值对中：json数据是由键值对构成的
    - 键用引号引起来，也可以不使用引号
    - 值的取值类型
      - 数字（整数或浮点数）
      - 字符串（双引号中）
      - 逻辑值（true或者false）
      - 数组（在方括号中）
      - 对象（在花括号中）
      - null
  - 数据由逗号分隔：多个键值对由逗号分隔
  - 花括号保存对象：使用{}来定义json格式
  - 方括号保存数组：[]
- 获取数据
  - json对象.键名
  - json对象[“键名”]
  - 数组对象[索引]
  - 获取person对象中所有的键和值：遍历：for in 循环
```
for(var key in person){
    altert(key + ":" + person[key]);
}
```
- json数据和Java对象的相互转换
  
  json解析器：
  
  Jsonlib，Gson，fastjson，Jackson
  - json转为Java对象
    - 使用步骤：
      - 导入Jackson的jar包
      - 创建Jackson核心对象ObjectMapper
      - 调用ObjectMapper的相关方法进行转换
        readValue(json字符串数据,Class)
  - Java对象转换json
    - 使用步骤：
      - 导入Jackson的jar包
      - 创建Jackson核心对象ObjectMapper
      - 调用ObjectMapper的相关方法进行转换
        
        转换方法：
        writeValue(参数一,obj):
        参数一：
        File：将obj对象转换为JSON字符串，并保存到指定的文件中
        Writer：将onj对象转换为JSON对象，并将JSON数据填充到字符输出流中
        OutputStream：将onj对象转换为JSON对象，并将JSON数据填充到字节输出流中
        
        writeValueAsString(obj):将对象转为json字符串
        
        注解：
        
        @JsonIgnore：排除属性
        
        @JsonFormat：属性值的格式化
        
        @JsonFormat(pattern = "yyyy-MM-dd")//属性格式转换
        
        复杂Java对象转换
        
        list：数组
        
        Map：对象格式一致

redis

概念：是一款高性能的NOSQL系列的非关系型数据库
- 数据之间没有关联关系
- 数据存储在内存中
- 一般会将数据存储在关系型数据库中，在nosql数据库中备份存储关系型数据库的数据
下载安装
- 解压直接可以使用
  - redis.windows.conf：配置文件
  - redis-cli.exe：redis的客户端
  - redis-server.exe：redis的服务器端
命令操作
- 数据结构：
  - redis存储的是key-value格式的数据，其中key都是字符串，value有五种不同的数据结构
    - 字符串类型 String
    - 哈希类型 hash：map格式
    - 列表类型 list：linkList格式
    - 集合类型 set
    - 有序集合类型 sortedset
  - 字符串类型 String
    - 存储：set key value
    - 获取：get key
    - 删除：del key
  - 哈希类型 hash
    - 存储：hset key field value
    - 获取：hget key field 获得指定的value
      
      hgetall key 获取所有的field和value
    - 删除：hdel key field
  - 列表类型 list：可以添加一个元素到列表的头部（左边）或者尾部（右边）
    - 添加：
      - lpush key value：将元素加入列表左边
      - rpush key value：将元素加入列表右边
    - 获取：
      - lrange key start end ：范围获取
    - 删除：
      - lpop key：删除列表最左边的元素，并将元素返回
      - rpop key：删除列表最右边的元素，并将元素返回
  - 集合类型 set：不允许重复元素
    - 存储：sadd key value
    - 获取：smembers key：获取set集合中所有的元素
    - 删除：srem key value：删除set集合中的某个元素
  - 有序集合类型 sortedset：不允许重复元素且元素有序
    - 存储：zadd key srcore value
    - 获取：zrange key start end
    - 删除：zrem key value
通用命令
- keys *：查询所有的键
- type key：获取键对应的value的类型
- del key：删除指定的key value
持久化操作
- redis是一个内存数据库，当redis服务器重启，或者电脑重启时数据会丢失。我们可以将redis内存中的数据持久化的保存在硬盘的文件中
- redis持久化机制
  - RDB：默认方式，不惜要进行配置，默认就使用这种机制
    - 在一定的间隔时间中，检测key的变化情况，然后持久化数据
    - 编辑redis.windwos.conf文件
      
      save 900 1
      save 300 10
      save 60 10000
    - 重新启动redis服务器并指定配置文件名称
      
      …>redis-server.exe redis.windows.conf
  - AOF：日志记录，可以记录每一条命令的操作。可以每一次命令操作后，持久化数据
    - 编辑redis.windwos.conf文件
      
      appendonly yes
    - appendfsync always：每一次操作都进行持久化
      
      appendfsync everysec：每隔一秒进行一次持久化
      
      appendfsync no：不进行持久化
使用Java客户端操作redis
- jedis：一款Java操作redis数据库的工具
- 使用步骤：
  - 下载jedis的jar包
  - 使用
jedis连接池：jedisPool
- 使用：
  - 创建JedisPool连接池对象
  - 调用 getResource()方法获取连接

MAVEN

功能：
- 依赖管理
- 一键构建：编译(compile)、测试(test)、打包(package)、安装(install)、发布(d)
仓库的种类：
- 本地仓库
- 远程仓库（私服）
- 中央仓库：几乎所有开源的jar包
maven标准目录结构
- src/main/java 核心代码部分
- src/main/resources 配置文件部分
- src/test/java 测试代码部分
- src/test/resources 测试配置文件
- src/main/webapp 页面资源,js,css图片等

薙切洛

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaWeb笔记

JavaWeb笔记Junit单元测试测试分类黑盒测试：不需要写代码白盒测试：需要写代码Junit（白盒测试的一种）使用：步骤：定义一个测试类（测试用例）建议：测试类名：被测试的类名 + Test包名：xxx.xxx.xx.test定义测试方法：可以独立运行建议：方法名：test + 测试的方法名返回值：void参数列表：空参给方法加@Test导入junit环境依赖判定结果红色：失败绿色：成功一般我们会使用断言操作来处理这个结果
复制链接

扫一扫