Javaweb学习笔记（二）

---

---

第二章 springboot

一、Maven

1、定义：Apache Maven 是一个项目管理和构建工具，它基于项目对象模型(POM)的概念，通过一小段描述信息来管理项目的构建。

2、作用
(1) 方便的依赖管理
(2) 统一的项目结构
(3) 标准的项目构建流程
3、创建Maven项目

4、Maven坐标
(1) 定义：Maven 中的坐标是资源的唯一标识，通过该坐标可以唯一定位资源位置。使用坐标来定义项目或引入项目中需要的依赖
(2) Maven 坐标主要组成
①groupld: 定义当前Maven项目隶属组织名称(通常是域名反写，例如:com.itheima)
②artifactld:定义当前Maven项目名称(通常是模块名称，例如 order-service、goods-service)
③version:定义当前项目版本号
5、Maven依赖管理
依赖坐标信息：https://mvnrepository.com/
(1) 配置依赖-当前项目运行所需要的iar包，一个项目中可以引入多个依赖
① 在 pom.xml 中编写 < dependencies > 标签
② 在< dependencies > 标签中使用 < dependency > 引入坐标
③ 定义坐标的 groupld，artifactld，version
④ 点击刷新按钮，引入最新加入的坐标
(2) 依赖传递 -依赖具有传递性

① 直接依赖:在当前项目中通过依赖配置建立的依赖关系
② 间接依赖: 被依赖的资源如果依赖其他资源，当前项目间接依赖其他资源
③ 排除依赖：排除依赖指主动断开依赖的资源，被排除的资源无需指定版本

<dependencies>
	<dependency>
		<groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
        <scope>test</ scope >
        <!-- 排除依赖 -->
     	<exclusions>
     		<exclusion>
				<groupId>junit</groupId>
            	<artifactId>junit</artifactId>
        	</exclusion>
      	</exclusions>
	</dependency>
</dependencies>

(3) 依赖范围 -依赖的jar包一般可以在任何地方使用，通过 scope>…</ scope >设置其作用范围
① 主程序范围有效。(main文件夹范围内)
② 测试程序范围有效。 (test文件夹范围内)
③ 是否参与打包运行。(package指令范围内)

(4) 生命周期-Maven的生命周期就是为了对所有的maven项目构建过程进行抽象和统一
Maven中有3套相互独立的生命周期，每套生命周期包含一些阶段 (phase)，阶段是有顺序的，后面的阶段依赖于前面的阶段。
① clean：清理工作
② default：核心工作，如: 编译、测试、打包、安装、部署等
③ site：生成报告、发布站点等


5、分模块设计：将项目按照功能拆分成若干个子模块，方便项目的管理维护、扩展，也方便模块间的相互调用，资源共享。通过maven连接起来。
6、继承
(1) 定义：继承描述的是两个工程间的关系，与java中的继承相似，子工程可以继承父工程中的配置信息，常见于依赖关系的继承。
(2) 作用：简化依赖配置、统一管理依赖
(3) 实现：
① 创建maven模块 tlias-parent，该工程为工程，设置打包方式pom(默认jar)

<!--每个springboot的父工程是spring-boot-starter-parent，让父工程继承
spring-boot-starter-parent再让子工程继承父工程-->
<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.7.17</version>
	
	<relativePath/> 
</parent>
<packaging>pom</packaging>

② 在子工程的pom.xml文件中，配置继承关系。

<!--relativePath指定父工程的pom文件的相对位置(如果不指定，将从本地仓库/远程仓库查找该工程)-->
<parent>
	<groupId>com.itheima</groupId>
	<artifactId>tlias-parent</artifactId>
	<version>1.0-SNAPSHOT</version>
	<relativePath>../tlias-parent/pom.xml</relativePath> 
</parent>

③ 在父工程中配置各个工程共有的依赖(子工程会自动继承父工程的依赖)。
(4) 工程打包方式
① jar: 普通模块打包，springboot项目基本都是jar包 (内嵌tomcat运行)
② war：普通web程序打包，需要部署在外部的tomcat服务器中运行
③ pom: 父工程或聚合工程，该模块不写代码，仅进行依赖管理
(5) 版本锁定：
① 定义：在maven中，可以在父工程的pom文件中通过< dependencyManagement > 来统一管理依赖版本。子工程引入该依赖时，无需指定< version >，但仍需导入该依赖，由父工程统一管理，变更依赖版本.
② 自定义属性：通过< properties >来自定义属性

<!--父工程pom.xml-->
<properties>
	<jjwt.version>0.9.0</jjwt.version>
</properties>
<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>io.jsonwebtoken</groupId>
         	<artifactId>jjwt</artifactId>
        	<version>${jjwt.version}</version>
    	</dependency>
	</dependencies>
</dependencyManagement>

<!--子工程pom.xml-->
<dependencies>
	<dependency>
		<groupId>io.jsonwebtoken</groupId>
		<artifactId>jjwt</artifactId>
	</dependency>
</dependencies>

7、聚合
(1) 定义：将多个模块组织成一个整体，同时进行项目的构建。聚合工程是一个不具有业务功能的“空”工程(有且仅有一个pom文件)
(2) 实现：父工程可以同时是聚合工程，maven中可以通过< modules >设置当前聚合工程所包含的子模块名称。

<!-- 聚合其他模块 -->
<modules>
	<module>../tlias-pojo</module>
	<module>../tlias-utils</module>
	<module>../tlias-management</module>
</modules>

8、私服
(1) 定义：私服是一种特殊的远程仓库，它是架设在局域网内的仓库服务，用来代理位于外部的中央仓库，用于解决团队内部的资源共享与资源同步问题。
(2) 依赖查找顺序：本地仓库——私服——中央仓库
(3) 项目版本
① RELEASE(发行版本)：功能趋于稳定、当前更新停止，可以用于发行的版本，存储在私服中的RELEASE仓库中。
② SNAPSHOT(快照版本)：功能不稳定、尚处于开发中的版本，即快照版本，存储在私服的SNAPSHOT仓库中。
③ CENTRAL(中央仓库)：从中央仓库下载的jar包。
(4) 资源上传与下载

① 设置私服的访问用户名和密码以及依赖下载的仓库组地址

<!-- maven的setting.xml -->
<!-- 配置私服的用户名和密码 -->
 <server>
	<id>maven-releases</id>
	<username>admin</username>
    <password>admin</password>
</server>
<server>
	<id>maven-snapshots</id>
    <username>admin</username>
    <password>admin</password>
</server>
<!-- 配置私服的连接地址 -->
<mirror>
       <id>maven-public</id>
       <mirrorOf>*</mirrorOf> <!--mirrorOf用于匹配仓库id，*用于匹配所有的仓库id-->
       <url>http://192.168.150.101:8081/repository/maven-public/</url>
</mirror>
<profile>
	<id>allow-snapshots</id>
    	<activation>
        <activeByDefault>true</activeByDefault>
        </activation>
	<repositories>
		<repository>
        	<id>maven-public</id>
            <url>http://192.168.150.101:8081/repository/maven-public/</url>
            <releases> <!--指定release版本可以在仓库地址中使用-->
           		<enabled>true</enabled>
           	</releases>
           	<snapshots> <!--指定snapshots版本可以在仓库地址中使用-->
               	<enabled>true</enabled>
            </snapshots>
		</repository>
	</repositories>
</profile>

② 上传自己的项目到私服上

<!--项目的pom.xml-->
<distributionManagement>
	<!-- release版本的发布地址 -->
    <repository>
    	<id>maven-releases</id>
        <url>http://192.168.150.101:8081/repository/maven-releases/</url>
    </repository>   
    <!-- snapshot版本的发布地址 -->
    <snapshotRepository>
    	<id>maven-snapshots</id>
        <url>http://192.168.150.101:8081/repository/maven-snapshots/</url>
    </snapshotRepository>
</distributionManagement>

③ 发布项目，直接运行 deploy 生命周期即可 (发布时，建议跳过单元测试)

二、HTTP协议

1、概念：Hyper Text Transfer Protocol，超文本传输协议，规定了浏览器和服务器之间数据传输的规则。

2、特点
① 基于TCP协议:面向连接，安全
② 基于请求-响应模型的:一次请求对应一次响应
③ HTTP协议是无状态的协议:对于事务处理没有记忆能力。每次请求-响应都是独立的。
缺点:多次请求间不能共享数据
优点: 速度快
3、HTTP请求协议
(1) 请求数据格式

4、HTTP响应协议
(1) HTTP响应格式

(2) 常见的响应状态码

(3) 响应头

三、Web服务器-Tomcat

1、定义：Tomcat是Apache 软件基金会一个核心项目，是一个开源免费的轻量级Web服务器，支持ervlet/JSP少量/avaEE规范。Tomcat也称为Web容器、Servlet容器。
2、官网：https://tomcat.apache.org/
3、基本使用
(1) 启动: bin/startup.bat
(2) 停止: bin/shutdown.bat
(3) 部署: 应用复制到webapps目录

四、请求响应

4.1 定义
1、请求(HttpServletRequest)：获取请求数据
2、响应(HttpServletResponse)：设置响应数据
3、BS架构(Browser/Server)：浏览器/服务器架构模式。客户端只需要浏览器，应用程序的逻辑和数据都存储在服务端。
4、CS架构(Client/Server)：客户端/服务器架构模式。

4.2 请求

1、简单参数
(1) 原始方式：在原始的web程序中，获取请求参数，需要通过HttpServletRequest对象手动获取

@RestController
public class RequestController {
    @RequestMapping("/simpleParam")
    public String simpleParam(HttpServletRequest request){
        //获取请求参数
        String name = request.getParameter("name");
        String ages = request.getParameter("age");
        int age = Integer.parseInt(ages);
        System.out.println(name + ":" + age);
        return "OK";
    }
}

(2) SpringBoot方式：参数名与形参变量名相同，定义形参即可接收参数

@RequestMapping("/simpleParam")
public String simpleParam(String name,Integer age){
System.out.println(name + ":" + age);
return "OK";
}

(3) @RequestParam注解：方法形参名称与请求参数名称不匹配，通过该注解完成映射该注解的required属性默认是true，代表请求参数必须传递

@RequestMapping("/simpleParam")
public String simpleParam(@RequestParam(name="name",required=false) String name,Integer age){
	System.out.println(name + ":" + age);
	return "OK";
}

2、实体参数：请求参数名与形参对象属性名相同，定义POJO(实体类文件夹)接收即可

//定义一个实体类
public class User {
    private String name;
    private Integer age;
}

//将实体参数name、age传递给方法
@RequestMapping("/simplePojo")
public String simplePojo(User user){
	System.out.println(user);
	return "OK";
}

3、数组集合参数：请求参数名与形参数组名称相同且请求参数为多个

(1) 使用数组封装

 @RequestMapping("/arrayParam")
 public String arrayParam(String[] hobby){
	System.out.println(Arrays.toString(hobby));
	return "OK";
}

(2) 使用集合封装：使用@RequestParam绑定参数关系

 @RequestMapping("/listParam")
 public String listParam(@RequestParam List<String> hobby){
	System.out.println(hobby);
	return "OK";
}

4、日期参数：使用 @DateTimeFormat 注解完成日期参数格式转换

@RequestMapping("/listParam")
public String dateParam(@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime updataTime){
	System.out.println(updataTime);
	return "OK";
}

5、JSON参数：JSON数据键名与形参对象属性名相同，定义POJO类型形参接收参数，需要使用 @RequestBody标识

@RequestMapping("/jsonParam")
public String jsonParam(@RequestBody User user){updataTime){
	System.out.println(user);
	return "OK";
}

6、路径参数：通过请求URL直接传递参数，使用{…}来标识该路径参数，需要使用@PathVariable 获取路径参数并绑定在{…}上

@RequestMapping("/path/{id}/{name}")
public String pathParam(@PathVariable Integer id,@PathVariable String name){
	System.out.println(id);
	System.out.println(name);
	return "OK";
}

4.3 响应

1、@ResponseBody——响应数据的注解
(1) 类型：方法注解、类注解
(2) 位置：Controller方法上/类上
(3) 作用：将方法返回值直接响应，如果返回值类型是 实体对象/集合，将会转换为]SON格式响应
(4) 说明：@RestController = @Controller + @ResponseBody
2、统一响应结果

五、分层解耦

5.1 三层架构

1、三层架构
(1) controller: 控制层，接收前端发送的请求，对请求进行处理，并响应数据。
(2) service：业务逻辑层，处理具体的业务逻辑
(3) dao: 数据访问层(Data Access Obiect)(持久层)，负责数据访问操作，包括数据的增、删、改、查。

2、代码实现

5.2 分层解耦

1、软件设计原则：高内聚低耦合
(1) 内聚：软件中各个功能模块内部的功能联系.
(2) 耦合：衡量软件中各个层/模块之间的依赖、关联的程度。
2、代码
(1) Dao数据访问层

//EmpDao接口
public interface EmpDao {
    public List<Emp> listEmp();
}
//EmpDaoA实现类继承EmpDao接口
@Repository  //将当前类交给IOC容器管理，成为IOC容器中的bean
public class EmpDaoA implements EmpDao {
    @Override
    public List<Emp> listEmp(){
    	//加载并解析emp.xml文件
        String file = this.getClass().getClassLoader().getResource("emp.xml").getFile();
        List<Emp> empList = XmlParserUtils.parse(file, Emp.class);
        return empList;
    }
}

(2) Service逻辑处理层

//EmpService接口
public interface EmpService {
    //获取员工列表
    public List<Emp> listEmp();
}
//EmpDaoA实现类继承EmpService接口
@Service //将当前类交给IOC容器管理，成为IOC容器中的bean
public class EmpServiceA implements EmpService {
    @Autowired //依赖注入，运行时IOC容器会提供该类型的bean对象，并赋值给该变量
    private EmpDao empDao;
    @Override
    public List<Emp> listEmp() {
        //1、调用Dao获取数据
        List<Emp> empList = empDao.listEmp();
        //2、对数据进行转换处理
        empList.stream().forEach(emp -> {
            //处理gender
            String gender = emp.getGender();
            if ("1".equals(gender)){
                emp.setGender("男");
            }else if("2".equals(gender)){
                emp.setGender("女");
            }
            String job = emp.getJob();
            if ("1".equals(job)){
                emp.setJob("讲师");
            }else if("2".equals(job)){
                emp.setJob("班主任");
            }else if("3".equals(job)){
                emp.setJob("就业指导");
            }
        });
        return empList;
    }
}

(3) Controller控制层

@RestController
public class EmpController {
    @Autowired  //依赖注入，运行时IOC容器会提供该类型的bean对象，并赋值给该变量
    private EmpService empService;
    @RequestMapping("/listEmp")
    public Result list(){
        List<Emp> empList = empService.listEmp();
        return Result.success(empList);
}

六、原理

6.1 起步依赖：通过Maven中的依赖传递来减少依赖

6.2 自动配置

1、定义：SpringBoot的自动配置就是当spring容器启动后，一些配置类、bean对象就自动存入到了IOC容器中，不需要我们手动去声明，从而简化了开发，省去了繁琐的配置操作。
2、

第三章 MySQL

一、定义
(1) 数据库：DataBase(DB)，存储和管理数据的仓库
(2) 数据库管理系统:DataBase Management System (DBMS)，操纵和管理数据库的大型软件。
(3) 关系型数据库(RDBMS):建立在关系模型基础上，由多张相互连接的二维表组成的数据库。
二、配置
1、初始化MySQL

mysqld --initialize-insecure

2、注册MySQL服务

mysqld -install //安装mysql
mysqld -remove mysql //卸载mysql

3、启动MySQL服务

net start mysql //启动mysql服务
net stop mysql //停止mysql服务

4、修改默认账户密码

mysqladmin -u root password 1234

5、登录MySQL

mysql -uroot -p1234

三、SQL

1、SQL分类

2.2 数据库设计DDL

(1) 数据类型
数据类型主要分为数值类型、字符串类型、日期类型

(2) 数据库

create database [if not exists] 数据库名; //创建
drop database [if exists] 数据库名; //删除
//查询
show databases; //查询所有数据库
select database(); //查询当前数据库
use 数据库名; //使用数据库

(3) 设计表结构的流程

① 语法

//创建
-- create table 表名(
--     字段1 字段类型 [约束] [comment 字段1注释],
-- )[comment 表注释];
create table tb_user(
    id int comment 'ID',
    username varchar(20) comment 'username',
    name varchar(10) comment '姓名',
    age int comment '年龄',
    gender char comment '性别'
)comment '用户表';
//查询
show tables; //查询当前数据库所有表
desc 表名; //查询表结构
show create table 表名; //查询建表语句
//修改
alter table tb_emp add qq varchar(11) comment 'QQ'; //添加字段
alter table tb_emp modify qq varchar(13) comment 'QQ'; //修改字段类型
alter table tb_emp change qq qq_ num varchar(13) comment 'QQ'; //将字段qq改为qq_num
alter table tb_emp drop column qq_num; //删除qq_num字段
rename table tb_emp to emp; //修改表名
//删除
drop table if exists tp_emp;

② 约束

2.3 数据库操作DML

1、定义：DML有助于检索和管理关系数据库中数据
2、语法

//1、添加
-- 添加单个数据
insert into 表名(字段名1,字段名2) values(值1,值2); //指定字段添加数据
insert into 表名 values(值1,值2); //全部字段添加数据
-- 添加批量数据
insert into 表名(字段名1,字段名2) values(值1,值2),(值1,值2); //指定字段添加数据
insert into 表名 values(值1,值2),(值1,值2); //全部字段添加数据
//2、修改
update 表名 set 字段名1 = 值1,字段名2 = 值2 [where 条件];//如果没有where语句，修改整张表的数据
//3、删除
delete from 表名 [where 条件]; //如果没有where语句，删除整张表的数据

2.4 数据库查询DQL

1、基础查询

//查询多个字段
select 字段1,字段2, 字段3 from 表名;
//查询所有字段
select * from 表名;
//查询时设置别名
select 字段1 [as 别名1],字段2 [as 别名2] from 表名;
//查询时去除重复记录
select distinct 字段1,字段2, 字段3 from 表名;

2、条件查询

select 字段1,字段2, 字段3 from 表名 where 条件列表;

3、聚合函数
(1) 聚合函数类别
① count：统计数量
② max：最大值
③ min：最小值
④ avg：平均值
⑤ sum：求和
(2) 语法

select 聚合函数(字段列表) from 表名;

4、分组查询
(1) 语法

select 字段列表 from 表名 [where 条件列表] group by 分组字段名 [having 分组后过滤条件];
//根据性别分组，统计男性和女性员工的数量
select gender,count(*) from tb_emp group by gender;
//查询入职时间在2015-01-01’ (包含) 以前的员工 ，并对结果根据职位分组 ，获取员工数量大于等于2的职位
select job,count(*) from tb_emp where entrydate<='2015-01-01' group by job having count(*)>=2;

(2) where和having区别
① 执行时机不同：where是分组之前进行过滤，不满足where条件，不参与分组，而having是分组之后对结果进行过滤。
② 判断条件不同：where不能对聚合函数进行判断，而having可以。
5、排序查询
(1) 排序方式
① ASC：升序(默认）
② DESC：降序
(2) 语法
如果是多字段排序，当第一个字段值相同时，才会根据第二个字段进行排序。

select 字段列表 from 表名 [where 条件列表][group by 分组字段] order by 字段1,字段2 排序方式;
//根据入职时间对公司的员工进行升序排序，入职时间相同，再按照更新时间进行降序排序
select * from tb_emp order by entrydate,update_time desc;

6、分页查询
(1) 起始索引从0开始，起始索引= (查询页码-1)*每页显示记录数。若查询第一页数据，起始索引可以省略，直接简写为 limit 10。
(2) 语法

select 字段列表 from 表名 limit 起始索引,查询记录数;
//查询第1页员工数据，每页展示5条记录
select * from tb_emp limit 0,5;
//查询第2页员工数据，每页展示5条记录
select * from tb_emp limit 5,5;

7、流程控制函数
(1) if(条件表达式，true取值，false取值)
(2) case 表达式 when 取值1 then 结果1 when 取值2 then 结果2 … else … end

//完成员工性别的统计，并按男性、女性显示出来
select if(gender = 1,'男性','女性') 性别,count(*) from tb_emp group by gender;
//完成员工职位的统计，并按班主任、讲师、教研主管和学工主管显示出来
select (case job when 1 then '班主任' when 2 then '讲师' when 3 then '教研主管' when 4 then '学工主管' else '未分配职位' end) 职位,count(*) 
from tb_emp group by job;

2.5 多表设计

1、一对多
(1) 实现：在多的一方添加外键，关联另外一方的主键。
(2) 物理外键
① 定义：使用foreign key定义外键来关联另一张表
② 缺点：影响增、删、改的效率(需要检查外键关系)；仅用于单节点数据库，不适用与分布式、集群场景；容易引发数据库的死锁问题，消耗性能。
③ 语法

-- 创建表时添加
create table 表名(
	字段 数据类型,
	...
	[constraint] [外键名称] foreign key(外键字段名) references 主表(字段名)
);
-- 建完表后添加
alter table 表名 add constraint 外键名称 foreign key(外键字段名) references 主表(字段名);

2、一对一
(1) 定义：一对一关系，多用于单表拆分，将一张表的基础字段放在一张表中，其他字段放在另一张表中，以提升操作效率。
(2) 实现：任意一方，添加外键，关联另外一方的主键。
3、一对多
(1) 实现：通过中间表来维护，中间表的两个外键，分别关联另外两张表的主键。

2.6 多表查询

1、定义：多表查询是指从多张表中查询数据，会出现笛卡尔积。笛卡尔乘积是指在数学中，两个集合(A集合和B集合)的所有组合情况。
2、连接查询
(1) 内连接

//查询员工的姓名 ， 及所属的部门名称
-- 显式内连接:select 字段列表 from 表1 [inner] join 表2 on 条件;
select tb_emp.name,tb_dept.name from tb_emp inner join tb_dept on tb_emp.dept_id = tb_dept.id;
-- 隐式内连接:select 字段列表 from 表1,表2 where 条件;
select tb_emp.name,tb_dept.name from tb_emp,tb_dept where tb_emp.dept_id = tb_dept.id;

(2) 外连接

-- 左外连接:select 字段列表 from left [outer] join 表2 on 条件;
//查询员工表所有员工的姓名，和对应的部门名称 (左外连接)
select e.name,d.name from tb_emp e left join tb_dept d on e.dept_id = d.id;
-- 右外连接:select 字段列表 from right [outer] join 表2 on 条件;
//查询部门表所有部门的名称和对应的员工名称 (右外连接)
select e.name,d.name from tb_emp e right join tb_dept d on e.dept_id = d.id;

3、子查询
(1) 定义：SQL语句中嵌套select语句，称为嵌套查询，又称子查询。子查询外部的语句可以是insert / update / delete / select 的任何一个，最常见的是 select。
(2) 形式

select * from tb1 where column = (select column from tb2 ...);

(3) 分类
① 标量子查询:子查询返回的结果为单个值
常用的操作符:= <> < <= > >=
② 列子查询:子查询返回的结果为一列
常用的操作符:in、not in等
③ 行子查询:子查询返回的结果为一行
常用的操作符:=、<>、in、not in
④ 表子查询:子查询返回的结果为多行多列,常作为临时表
常用的操作符:in

-- 1、标量子查询-查询“教研部”的所有员工信息
select * from tb_emp where dept_id = (select id from tb_dept where name ='教研部');
-- 2、列子查询-查询“教研部”和“咨询部” 的所有员工信息
select * from tb_emp where dept_id = (select id from tb_dept where name ='教研部' or name ='咨询部');
-- 3、行子查询-查询与“韦一笑”的入职日期及职位都相同的员工信息
select * from tb_emp where entrydate = (select entrydate from tb_dept where name ='韦一笑') and job = (select job from tb_dept where name ='韦一笑');
select * from tb_emp where (entrydate,job) = (select entrydate,job from tb_dept where name ='韦一笑');
-- 4、表子查询-查询入职日期是 “2006-01-01”之后的员工信息，及其部门名称
//select * from tb_emp where entrydate > '2006-01-01'作为临时表
select e.*,d.name from (select * from tb_emp where entrydate > '2006-01-01') e,tb_emp where e.dept_id = d.id; 

2.7 索引

1、定义：索引 (index)是帮助数据库高效获取数据的数据结构。
2、结构：MySOL数据库支持的索引结构有很多，如: Hash索引、B+Tree索引、Full-Text索引等。我们平常所说的索引，如果没有特别指明，都是指默认的B+Tree 结构组织的索引。

3、操作语法
主键字段，在建表时，会自动创建主键索引。添加唯一约束时，数据库实际上会添加唯一索引。

-- 创建索引
create [unique] index 索引名 on 表名(字段名);
-- 查看索引
show index from 表名;
-- 删除索引
drop index 索引名 from on 表名;

四、mybatis

1、定义：mybatis是一款优秀的持久层框架，用于简化JDBC的开发。mybatis可以使用注解和XML映射文件来配置和映射原始类型、接口和Java POJO为数据库中的记录。
2、数据库连接池
(1) 定义：数据库连接池是个容器，负责分配、管理数据库连接(Connection)。它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个。释放空闲时间超过最大空闲时间的连接，来避免因为没有释放连接而引起的数据库连接遗漏。
(2) 优势：资源重用；提升系统响应速度；避免数据库连接遗漏
(3) 常见产品

(4) 配置数据库连接池——Druid数据库连接池

<!-- pom.xml -->
<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>druid-spring-boot-starter</artifactId>
	<version>1.2.8</version>
</dependency>
<!-- application.properties -->
#驱动类名称
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#数据库连接的url
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis
#连接数据库的用户名
spring.datasource.username=root
#连接数据库的密码
spring.datasource.password=1234

3、注解配置SQL
在接口方法上添加注解来执行SQL

<!-- EmpMapper -->
@Mapper 在运行时，会自动生成该接口的实现类对象(代理对象)，并日路该对象交给IOC容器管理
public interface EmpMapper {
    //删除数据——根据id
    @Delete("delete from emp where id = #{id}")
    public void delete(Integer id);
    //新增数据
   	//Options主键返回，useGeneratedKeys = true表明需要拿到生成的主键值，最终封装到id
    @Options(keyProperty = "id",useGeneratedKeys = true)
    @Insert("insert into emp(username, name, gender, image, job, entrydate, dept_id,
    create_time, update_time) values (#{username},#{name},#{gender},#{image},#{job},
    #{entrydate},#{deptId},#{createTime},#{updateTime})")
    public void insert(Emp emp); //如果有多个参数，可以使用实体类封装起来
    //更新数据
    @Update("update emp set username=#{username},name=#{name},gender=#{gender},image=
    #{image},job=#{job},entrydate=#{entrydate},dept_id=#{deptId},update_time=#{updateTime} 
    where id = #{id}")
    public void update(Emp emp);
    //查询数据——根据id
    @Select("select * from emp where id = #{id}")
    public Emp getById(Integer id);

<!-- MybatisApplicationTests -->
@SpringBootTest //整合单元测试的注解
class MybatisApplicationTests {
	@Autowired //依赖注入
	private EmpMapper empMapper;
	//删除数据——根据id
	@Test
	public void testDelete(){
		empMapper.delete(16);
		/*int delete = empMapper.delete(16);
		System.out.println(delete);*/
	}
	//新增数据
	@Test
	public void testInsert(){
		//构造员工对象
		Emp emp = new Emp();
		emp.setUsername("joey");
		emp.setName("乔伊");
		emp.setImage("1.jpg");
		emp.setGender((short)1);
		emp.setJob((short)1);
		emp.setEntrydate(LocalDate.of(2000,1,1));
		emp.setCreateTime(LocalDateTime.now());
		emp.setUpdateTime(LocalDateTime.now());
		emp.setDeptId(1);
		empMapper.insert(emp);
		System.out.println(emp.getId());
	}
	//更新数据
	@Test
	public void testUpdate() {
		//构造员工对象
		Emp emp = new Emp();
		emp.setId(18);
		emp.setUsername("ross");
		emp.setName("罗斯");
		emp.setImage("1.jpg");
		emp.setGender((short) 2);
		emp.setJob((short) 1);
		emp.setEntrydate(LocalDate.of(2000, 1, 1));
		emp.setUpdateTime(LocalDateTime.now());
		emp.setDeptId(1);
		empMapper.update(emp);
		System.out.println(emp.getId());
	}
	//查询数据——根据id
	@Test
	public void testGetById(){
		Emp emp = empMapper.getById(18);
		System.out.println(emp);
	}

4、XML映射文件配置SQL
(1) 规范
① XML映射文件的名称与Mapper接口名称一致，并且将XML映射文件和Mapper接口放置在相同包下(同包同名)。
② XML映射文件的namespace属性为Mapper接口全限定名一致。
③ XML映射文件中sql语句的id与Mapper接口中的方法名一致，并保持返回类型一致。
(2) 代码

<!-- xml文件 -->
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.mapper.EmpMapper">
    <!-- 批量删除 -->
    //collection:遍历的集合；item：遍历出来的元素；separator：分隔符；open：遍历开始前拼接的SQL片段；close：遍历结束后拼接的SQL片段
    <delete id="deleteByIds">
        delete from emp where id in
        <foreach collection="ids" item="id" separator="," open="(" close=")">
            #{id}
        </foreach>
    </delete>
    <!-- 条件查询 -->
    //resultType:单条记录所封装的类型
    <select id="list" resultType="com.itheima.pojo.Emp">
        select *
        from emp
        <where>
            <if test="name != null">name like '%${name}%'</if>
            <if test="name != null">and gender = #{gender}</if>
            <if test="name != null">and entrydate between #{begin} and #{end}</if>
        </where>
        order by update_time desc
    </select>
</mapper>

<!-- EmpMapper -->
<!-- 批量删除 -->
public void deleteByIds(List<Integer> ids) ;
<!-- 条件查询 -->
public List<Emp> list(String name, Short gender, LocalDate begin,LocalDate end);

<!-- MybatisApplicationTests -->
<!-- 条件查询 -->
@Test
public void testList(){
	List<Emp> empList = empMapper.list("张",(short)1,LocalDate.of(2010,1,1),LocalDate.of(2020,1,1));
	System.out.println(empList);
}
<!-- 批量删除 -->
@Test
public void testdeleteByIds(){
	List<Integer> ids = Arrays.asList(13,14,15);
	empMapper.deleteByIds(ids);
}

5、动态SQL
(1) 定义：随着用户的输入或外部条件的变化而变化的SQL语句，我们称为动态SQL。
(2) < if >
① < if >：用于判断条件是否成立。使用test属性进行条件判断，如果条件为true，则拼接SQL。
② < where >: where 元素只会在子元素有内容的情况下才插入where子句。而且会自动去除子句的开头的AND或OR。

<!-- 根据姓名、性别、入职时间查询语句 -->
<!-- resultType:单条记录所封装的类型 -->
<select id="list" resultType="com.itheima.pojo.Emp">
	select *
    from emp
    <where>
    	<if test="name != null">name like '%${name}%'</if>
    	<if test="name != null">and gender = #{gender}</if>
        <if test="name != null">and entrydate between #{begin} and #{end}</if>
    </where>
    order by update_time desc
</select>

(3) < foreach >
< foreach >用于遍历循环，属性为：collection:遍历的集合；item：遍历出来的元素；separator：分隔符；open：遍历开始前拼接的SQL片段；close：遍历结束后拼接的SQL片段

<!-- 批量删除 -->
<delete id="deleteByIds">
	delete from emp where id in
    <foreach collection="ids" item="id" separator="," open="(" close=")">
    	#{id}
   	</foreach>
</delete>

(4) < sql >< include >
① < sql >：定义可重用的SQL片段。
② < include >：通过属性refid，指定包含的sql片段。

<!-- 定义可重用的SQL片段 -->
<sql id="commonSelect">
	select id, username, password, name, gender, image, job, entrydate, dept_id, create_time, 	  
	update_time from emp
</sql>
<!-- 使用SQL片段 -->
<include refid="commonSelect"/>

6、lombok
(1) 定义：Lombok是一个实用的Java类库，能通过注解的形式自动生成构造器、getter/setter、equals、hashcode、toString等方法，并可以自动化生成日志变量，简化java开发、提高效率。
(2) 注解

7、配置格式
(1) XML

<server>
	<port>8080</port>
	<address>127.0.0.1</address>
</server>

(2) properties

server.port=8080
server.address=127.0.0.1

(3) yml/yaml

server:
  port:8080
  address:127.0.0.1