Maven
1.Maven入门
概述
Maven是Apache旗下的一个开源项目,是一款用于管理和构建java项目的工具。
Maven作用:
- 依赖管理
- 方便快捷的管理项目依赖的资源(jar包),避免引入大量的jar包,不同jar包之间的版本冲突问题
- 当使用maven进行项目依赖(jar包)管理,则很方便的可以解决这个问题。
我们只需要在maven项目的pom.xml文件中,添加一段
依赖实现
- 统一项目结构
- 提供标准、统一的项目结构,使用不同的开发工具Eclipse或者IDEA创建项目工程时发现项目结构不一致,若创建的是一个maven工程,是可以帮我们自动生成统一、标准的项目目录结构:
统一结构为:
1 | - src/main/java: java源代码目录 |
- 项目构建
maven提供了标准的、跨平台(Linux、Windows、MacOS)
的自动化项目构建方式
- Maven中的坐标是==资源的唯一标识== , 通过该坐标可以唯一定位资源位置
- 使用坐标来定义项目或引入项目中需要的依赖
坐标,就是资源(jar包)的唯一标识,通过坐标可以定位到所需资源(jar包)位置,坐标由:
- groupId:定义当前Maven项目隶属组织名称(通常是域名反写,例如:com.itheima)
- artifactId:定义当前Maven项目名称(通常是模块名称,例如 order-service、goods-service)
- version:定义当前项目版本号
依赖管理模型,是使用坐标来描述当前项目依赖哪些第三方jar包
pom.xml文件中的坐标能找到所要的jar包,利用Maven仓库
Maven仓库
Maven仓库分为:
- 本地仓库:自己计算机上的一个目录(用来存储jar包)
- 中央仓库:由Maven团队维护的全球唯一的。仓库地址:https://repo1.maven.org/maven2/
- 远程仓库(私服):一般由公司团队搭建的私有仓库
当项目中使用坐标引入对应依赖jar包后,首先会查找本地仓库中是否有对应的jar包
如果有,则在项目直接引用
如果没有,则去中央仓库中下载对应的jar包到本地仓库
如果还可以搭建远程仓库(私服),将来jar包的查找顺序则变为: 本地仓库 --> 远程仓库--> 中央仓库
由于中央仓库在国外,所以下载jar包速度可能比较慢,而阿里公司提供了一个远程仓库,里面基本也都有开源项目的jar包。
进入到conf目录下修改settings.xml配置文件即可(阿里云私服)==注:
只可配置一个
2.Maven项目
Maven项目的目录结构:
maven-project01 |--- src (源代码目录和测试代码目录) |--- main (源代码目录) |--- java (源代码java文件目录) |--- resources (源代码配置文件目录) |--- test (测试代码目录) |--- java (测试代码java目录) |--- resources (测试代码配置文件目录) |--- target (编译、打包生成文件存放目录)
POM (Project Object Model) :指的是项目对象模型,用来描述当前的maven项目。
- 使用pom.xml文件来实现
pom.xml文件:
1 |
|
pom文件详解:
:pom文件的根标签,表示当前maven项目 :声明项目描述遵循哪一个POM模型版本 - 虽然模型本身的版本很少改变,但它仍然是必不可少的。目前POM模型版本是4.0.0
- 坐标 :
、 、 - 定位项目在本地仓库中的位置,由以上三个标签组成一个坐标
:maven项目的打包方式,通常设置为jar或war(默认值:jar)
使用Maven面板,通过导入pox文件可以快速导入Maven文件
3.Maven依赖管理
依赖:指当前项目运行所需要的jar包。一个项目中可以引入多个依赖:
例如:在当前工程中,我们需要用到logback来记录日志,此时就可以在maven工程的pom.xml文件中,引入logback的依赖。具体步骤如下:
- 在pom.xml中编写
标签 - 在
标签中使用 引入坐标 - 定义坐标的 groupId、artifactId、version
- 点击刷新按钮,引入最新加入的坐标
- 刷新依赖:保证每一次引入新的依赖,或者修改现有的依赖配置,都可以加入最新的坐标
添加依赖的几种方式:
- 利用中央仓库搜索的依赖坐标
- 利用IDEA工具搜索依赖 Alt+Insert快捷键 -> Dependencies
依赖具有传递性
早期我们没有使用maven时,向项目中添加依赖的jar包,需要把所有的jar包都复制到项目工程下。若需要logback-classic时,由于logback-classic又依赖了logback-core和slf4j,所以必须把这3个jar包全部复制到项目工程下。
However,我们现在使用了maven,当项目中需要使用logback-classic时,只需要在pom.xml配置文件中,添加logback-classic的依赖坐标即可,在pom.xml文件中只添加了logback-classic依赖,但由于maven的依赖具有传递性,所以会自动把所依赖的其他jar包也一起导入。
依赖传递可以分为:
- 直接依赖:在当前项目中通过依赖配置建立的依赖关系
- 间接依赖:被依赖的资源如果依赖其他资源,当前项目间接依赖其他资源
排除依赖:
在maven项目中,我们可以通过排除依赖来实现:A依赖B,B依赖C,如果A不想将C依赖进来
什么是排除依赖?
- 排除依赖:指主动断开依赖的资源。(被排除的资源无需指定版本)
依赖排除示例:
- maven-projectA依赖了maven-projectB,maven-projectB依赖了Junit。基于依赖的传递性,所以maven-projectA也依赖了Junit
使用排除依赖后,maven-projectA不再依赖了Junit
依赖范围:
在项目中导入依赖的jar包后,默认情况下,可以在任何地方使用。
如果希望限制依赖的使用范围,可以通过
作用范围:
- 主程序范围有效(main文件夹范围内)
- 测试程序范围有效(test文件夹范围内)
- 是否参与打包运行(package指令范围内)
4.Maven生命周期
Maven的生命周期就是为了对所有的构建过程进行抽象和统一。 描述了一次项目构建,经历哪些阶段。在Maven出现之前,项目构建的生命周期就已经存在,软件开发人员每天都在对项目进行清理,编译,测试及部署。虽然大家都在不停地做构建工作,但公司和公司间、项目和项目间,往往使用不同的方式做类似的工作。
Maven从大量项目和构建工具中学习和反思,然后总结了一套高度完美的,易扩展的项目构建生命周期。这个生命周期包含了项目的清理,初始化,编译,测试,打包,集成测试,验证,部署和站点生成等几乎所有构建步骤。
Maven对项目构建的生命周期划分为3套(相互独立):
- clean:清理工作。
- default:核心工作。如:编译、测试、打包、安装、部署等。
- site:生成报告、发布站点等。
主要关注以下几个:
• clean:移除上一次构建生成的文件
• compile:编译项目源代码
• test:使用合适的单元测试框架运行测试(junit)
• package:将编译后的文件打包,如:jar、war等
• install:安装项目到本地仓库
Maven的生命周期是抽象的,这意味着生命周期本身不做任何实际工作。在Maven的设计中,实际任务(如源代码编译)都交由插件来完成。
生命周期的顺序是:clean --> validate --> compile --> test --> package --> verify --> install --> site --> deploy
我们需要关注的就是:clean --> compile --> test --> package --> install
在同一套生命周期中,我们在执行后面的生命周期时,前面的生命周期都会执行。(执行package时,compile会执行,但clean不会,因为不是一套)
在日常开发中,当我们要执行指定的生命周期时,有两种执行方式:
- 在idea工具右侧的maven工具栏中,选择对应的生命周期,双击执行
- 在DOS命令行中,通过maven命令执行
compile后:只对main文件夹(主函数)源代码编译,生成target目录
test:对test文件夹(测试程序)进行编译
package:对项目打包,生成jar包,打包后生成的jar包放在target目录下
install:把jar文件安装在当前项目文件夹指定坐标路径下(target)
clean:删除target目录
DOS操作:需要在Poweshell窗口操作 mvn clean....
5.其他Maven知识点(持续补充)
有时候给idea配置完maven仓库信息后,在idea中依然搜索不到仓库中的jar包。这是因为仓库中的jar包索引尚未更新到idea中。这个时候我们就需要更新idea中maven的索引了,具体做法如下:
打开设置----搜索maven----Repositories----选中本地仓库-----点击Update
清理Maven仓库:初始情况下,我们的本地仓库是没有任何jar包的,此时会从私服去下载(如果没有配置,就直接从中央仓库去下载),可能由于网络的原因,jar包下载不完全,这些不完整的jar包都是以lastUpdated结尾。此时,maven不会再重新帮你下载,需要你删除这些以lastUpdated结尾的文件,然后maven才会再次自动下载这些jar包。
如果本地仓库中有很多这样的以lastUpadted结尾的文件,可以定义一个批处理文件,在其中编写如下脚本来删除:
1 | set REPOSITORY_PATH=E:\develop\apache-maven-3.6.1\mvn_repo |
操作步骤如下:
1). 定义批处理文件del_lastUpdated.bat (直接创建一个文本文件,命名为del_lastUpdated,后缀名直接改为bat即可 )
2). 在上面的bat文件上右键---》编辑 。修改文件:REPOSITORY为自己的仓库 mvn-3.6.1/mvn_repo
修改完毕后,双击运行即可删除maven仓库中的残留文件。
SpringBoot
Spring的官网(https://spring.io),去看一下Spring的简介:Spring makes Java simple。
Spring的官方提供很多开源的项目,可以点击上面的projects,看到spring家族旗下的项目,按照流行程度排序为:
SpringBoot SpringFrameWork SpringData SpringCloud SpringCloudDataFlow SpringSecurity
Spring若干个子项目完成特点的功能,统称为:spring全家桶
最基础、最核心的是 SpringFramework。其他的spring家族的技术,都是基于SpringFramework的,SpringFramework中提供很多实用功能,如:依赖注入、事务管理、web开发支持、数据访问、消息服务等等。
However:直接基于SpringFramework进行开发,存在个问题:配置繁琐、入门难度大;基于此,spring官方推荐从另外一个项目开始学习,那就是目前最火爆的SpringBoot。
SB最大特点:简单配置 + 快速开发 Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率
1.基础入门
创建工程
需求:基于SpringBoot的方式开发一个web应用,浏览器发起请求/hello后,给浏览器返回字符串 “Hello World”。
第1步:创建SpringBoot工程项目
第2步:定义HelloController类,添加方法hello,并添加注解
第3步:测试运行
基于Spring官方骨架,创建SpringBoot工程。

基本信息描述完毕之后,勾选web开发相关依赖。
点击Finish之后,就会联网创建这个SpringBoot工程,创建好之后,结构如下:
src - main - java - com.ning - SpringBootQuickStarte1Appication.java
在com.ning这个包下创建一个子包controller,再在controller包下新建一个类:HelloController
编写:
1 | package com.itheima.controller; |
运行SpringBoot自动生成的引导类:SpringBootQuickStarte1Appication.java(有main函数)
打开浏览器,输入 http://localhost:8080/hello

以上内容是基于Spring官方提供的骨架实现,Spring官方骨架,可以理解为Spring官方为程序员提供一个搭建项目的模板。
同时,案例中也引用了:web依赖和test依赖(dependencies,Maven学到的)
spring-boot-starter-web和spring-boot-starter-test,在SpringBoot中又称为:起步依赖
而在SpringBoot的项目中,有很多的起步依赖,他们有一个共同的特征:就是以spring-boot-starter-作为开头。在以后大家遇到spring-boot-starter-xxx这类的依赖,都为起步依赖。
- spring-boot-starter-web:包含了web应用开发所需要的常见依赖
- spring-boot-starter-test:包含了单元测试所需要的常见依赖
spring-boot-starter-web内部把关于Web开发所有的依赖都已经导入并且指定了版本,只需引入
spring-boot-starter-web
依赖就可以实现Web开发的需要的功能(通过依赖传递,自动导入web开发所需依赖)
Spring的官方提供了很多现成的starter(起步依赖),我们在开发相关应用时,只需要引入对应的starter即可。
地址:https://docs.spring.io/spring-boot/docs/2.7.2/reference/htmlsingle/#using.build-systems.starters
每一个起步依赖,都用于开发一个特定的功能。
例:当我们开发中需要使用redis数据库时,只需要在SpringBoot项目中,引入:spring-boot-starter-redis ,即可导入redis开发所需要的依赖。
在之前开发的SpringBoot入门案例中,我们通过maven引入的依赖,是没有指定具体的依赖版本号的。每一个SpringBoot工程,都有一个父工程。依赖的版本号,在父工程中统一管理。
同时,在刚刚启动的SpringBoot项目中,引入了web运行环境(也就是引入spring-boot-starter-web起步依赖),其内部已经集成了内置的Tomcat服务器(下文要提到的Web服务器),我们可以通过IDEA开发工具右侧的maven面板中,就可以看到当前工程引入的依赖。其中已经将Tomcat的相关依赖传递下来了,也就是说在SpringBoot中可以直接使用Tomcat服务器。
当我们运行SpringBoot的引导类时(运行main方法),就会看到命令行输出的日志,其中占用8080端口的就是Tomcat。
解析过程
浏览器Browser:
输入网址:
http://192.168.100.11:8080/hello通过IP地址192.168.100.11定位到网络上的一台计算机
我们之前在浏览器中输入的localhost,就是127.0.0.1(本机)
通过端口号8080找到计算机上运行的程序
localhost:8080, 意思是在本地计算机中找到正在运行的8080端口的程序/hello是请求资源位置
- 资源:对计算机而言资源就是数据
- web资源:通过网络可以访问到的资源(通常是指存放在服务器上的数据)
localhost:8080/hello,意思是向本地计算机中的8080端口程序,获取资源位置是/hello的数据- 8080端口程序,在服务器找/hello位置的资源数据,发给浏览器
- 资源:对计算机而言资源就是数据
服务器:(可以理解为ServerSocket)
- 接收到浏览器发送的信息(如:/hello)
- 在服务器上找到/hello的资源
- 把资源发送给浏览器
网络三要素:
- IP :网络中计算机的唯一标识
- 端口 :计算机中运行程序的唯一标识
- 协议 :网络中计算机之间交互的规则
浏览器和服务器两端进行数据交互,使用http协议**
2.HTTP协议
概述
HTTP:Hyper Text Transfer Protocol(超文本传输协议),规定了浏览器与服务器之间数据传输的规则。
- http是互联网上应用最为广泛的一种网络协议
- http协议要求:浏览器在向服务器发送请求数据时,或是服务器在向浏览器发送响应数据时,都必须按照固定的格式进行数据传输
格式:
浏览器向服务器进行请求时:
- 服务器按照固定的格式进行解析
服务器向浏览器进行响应时:
- 浏览器按照固定的格式进行解析
HTTP协议有哪些特点?
基于TCP协议: 面向连接,安全
TCP是一种面向连接的(建立连接之前是需要经过三次握手)、可靠的、基于字节流的传输层通信协议,在数据传输方面更安全
基于请求-响应模型: 一次请求对应一次响应(先请求后响应)
请求和响应是一一对应关系,没有请求,就没有响应
HTTP协议是无状态协议: 对于数据没有记忆能力。每次请求-响应都是独立的
无状态指的是客户端发送HTTP请求给服务端之后,服务端根据请求响应数据,响应完后,不会记录任何信息。
- 缺点: 多次请求间不能共享数据
- 优点: 速度快(只要速度快就够了,因为用户需要及时反馈)
解决数据共享:Java中使用会话技术(Cookie、Session)来解决这个问题。
浏览器和服务器是按照HTTP协议进行数据通信的。
HTTP协议又分为:请求协议和响应协议
- 请求协议:浏览器将数据以请求格式发送到服务器
- 包括:请求行、请求头 、请求体
- 响应协议:服务器将数据以响应格式返回给浏览器
- 包括:响应行 、响应头 、响应体
请求协议
最常见:
| 请求方式 | 请求说明 |
|---|---|
| GET | 获取资源。 向特定的资源发出请求。例:http://www.baidu.com/s?wd=hehe2ning |
| POST | 传输实体主体。 向指定资源提交数据进行处理请求(例:上传文件),数据被包含在请求体中。 |
GET方式的请求协议:

请求行 :HTTP请求中的第一行数据。由:
请求方式、资源路径、协议/版本组成(之间使用空格分隔)- 请求方式:GET
- 资源路径:/brand/findAll?name=OPPO&status=1
- 请求路径:/brand/findAll
- 请求参数:name=OPPO&status=1
- 请求参数是以key=value形式出现
- 多个请求参数之间使用
&连接
- 请求路径和请求参数之间使用
?连接
- 协议/版本:HTTP/1.1
- 请求方式:GET
请求头 :第二行开始,上图黄色部分内容就是请求头。格式为key: value形式
- http是个无状态的协议,所以在请求头设置浏览器的一些自身信息和想要响应的形式。这样服务器在收到信息后,就可以知道是谁,想干什么了
常见请求头:
Host: 表示请求的主机名
User-Agent: 浏览器版本。 例如:Chrome浏览器的标识类似Mozilla/5.0 ...Chrome/79 ,IE浏览器的标识类似Mozilla/5.0 (Windows NT ...)like Gecko
Accept:表示浏览器能接收的资源类型,如text/,image/或者/表示所有;
Accept-Language:表示浏览器偏好的语言,服务器可以据此返回不同语言的网页;
Accept-Encoding:表示浏览器可以支持的压缩类型,例如gzip, deflate等。
Content-Type:请求主体的数据类型
Content-Length:数据主体的大小(单位:字节)
服务端可以根据请求头中的内容来获取客户端的相关信息,有了这些信息服务端就可以处理不同的业务需求。
POST方式的请求协议:

- 请求行(以上图中红色部分):包含请求方式、资源路径、协议/版本
- 请求方式:POST
- 资源路径:/brand
- 协议/版本:HTTP/1.1
- 请求头(以上图中黄色部分)
- 请求体(以上图中绿色部分) :存储请求参数
- 请求体和请求头之间是有一个空行隔开(作用:用于标记请求头结束)
GET请求和POST请求的区别:
| 区别方式 | GET请求 | POST请求 |
|---|---|---|
| 请求参数 | 请求参数在请求行中。 例:/brand/findAll?name=OPPO&status=1 |
请求参数在请求体中 |
| 请求参数长度 | 请求参数长度有限制(浏览器不同限制也不同) | 请求参数长度没有限制 |
| 安全性 | 安全性低。原因:请求参数暴露在浏览器地址栏中。 | 安全性相对高 |
响应协议
与HTTP的请求一样,HTTP响应的数据也分为3部分:响应行、响应头 、响应体

响应行(以上图中红色部分):响应数据的第一行。响应行由
协议及版本、响应状态码、状态码描述组成- 协议/版本:HTTP/1.1
- 响应状态码:200
- 状态码描述:OK
响应头(以上图中黄色部分):响应数据的第二行开始。格式为key:value形式
- http是个无状态的协议,所以可以在请求头和响应头中设置一些信息和想要执行的动作,这样,对方在收到信息后,就可以知道你是谁,你想干什么
常见的HTTP响应头有:
1
2
3
4
5
6
7
8
9Content-Type:表示该响应内容的类型,例如text/html,image/jpeg ;
Content-Length:表示该响应内容的长度(字节数);
Content-Encoding:表示该响应压缩算法,例如gzip ;
Cache-Control:指示客户端应如何缓存,例如max-age=300表示可以最多缓存300秒 ;
Set-Cookie: 告诉浏览器为当前页面所在的域设置cookie ;响应体(以上图中绿色部分): 响应数据的最后一部分。存储响应的数据
- 响应体和响应头之间有一个空行隔开(作用:用于标记响应头结束)
响应状态码:
| 状态码分类 | 说明 |
|---|---|
| 1xx | 响应中 --- 临时状态码。表示请求已经接受,告诉客户端应该继续请求或者如果已经完成则忽略 |
| 2xx | 成功 --- 表示请求已经被成功接收,处理已完成 |
| 3xx | 重定向 --- 重定向到其它地方,让客户端再发起一个请求以完成整个处理 |
| 4xx | 客户端错误 --- 处理发生错误,责任在客户端,如:客户端的请求一个不存在的资源,客户端未被授权,禁止访问等 |
| 5xx | 服务器端错误 --- 处理发生错误,责任在服务端,如:服务端抛出异常,路由出错,HTTP版本不支持等 |
关于响应状态码,主要认识如下三个状态码:
- 200 ok 客户端请求成功
- 404 Not Found 请求资源不存在
- 500 Internal Server Error 服务端发生不可预期的错误
简单解析HTTP协议:首先服务器端启动ServerSocket程序 ->
浏览器输入:http://localhost:8080
就会访问到ServerSocket程序
- ServerSocket程序,会读取服务器上
html/a.html文件,并把文件数据发送给浏览器 - 浏览器接收到a.html文件中的数据后进行解析,显示以下内容
在开发中真正用到的Web服务器都是使用目前比较流行的web服务器。如:Tomcat
3.Web服务器
概述
服务器,也称伺服器。是提供计算服务的设备。由于服务器需要响应服务请求,并进行处理,因此一般来说服务器应具备承担服务并且保障服务的能力。服务器的构成包括处理器、硬盘、内存、系统总线等,和通用的计算机架构类似,但是由于需要提供高可靠的服务,因此在处理能力、稳定性、可靠性、安全性、可扩展性、可管理性等方面要求较高。
在网络环境下,根据服务器提供的服务类型不同,可分为:文件服务器,数据库服务器,应用程序服务器,WEB服务器等。
服务器软件:基于ServerSocket编写的程序
- 服务器软件本质是一个运行在服务器设备上的应用程序
- 能够接收客户端请求,并根据请求给客户端响应数据
如:MySQL服务器上会存在MySQL软件,作用提供数据库操作服务;Nginx服务器上存在Nginx软件,作用发布静态Web资源(html,css,js);Tomcat服务器上存在Tomcat软件,作用发布Web资源(静态+动态);
Web服务器是一个应用程序(软件),对HTTP协议的操作进行封装,使得程序员不必直接对协议进行操作(不用程序员自己写代码去解析http协议规则),让Web开发更加便捷。主要功能是"提供网上信息浏览服务"。
Web服务器是安装在服务器端的一款软件,将来我们把自己写的Web项目部署到Tomcat服务器软件中,当Web服务器软件启动后,部署在Web服务器软件中的页面就可以直接通过浏览器来访问了。
Web服务器软件使用步骤
- 准备静态资源
- 下载安装Web服务器软件
- 将静态资源部署到Web服务器上(将静态资源resources文件夹复制到tomcat文件夹下的webapps中)
- 启动Web服务器使用浏览器访问对应的资源(tomcat的bin目录下双击startup.bat脚本即可启动)
此时:浏览器输入:http://localhost:8080/demo/index.html便会出现资源内容
Tomcat运行前需要配置好环境变量中的JAVA_HOME路径,要想修改Tomcat启动的端口号,需要修改 conf/server.xml文件
4.SpringBoot请求响应
在实际开发web程序时,不会像刚才一样,直接请求我们的后端web服务器(也就是内置的Tomcat),而是:
请求会被部署在Tomcat中的Controller接收,然后Controller再给浏览器一个响应,响应一个字符串 “Hello World”。 而在请求响应的过程中是遵循HTTP协议的。在Tomcat这类Web服务器中,是不识别我们自己定义的Controller的。但是我们前面讲到过Tomcat是一个Servlet容器,是支持Serlvet规范的,所以呢,在tomcat中是可以识别 Servlet程序的。 那我们所编写的XxxController 是如何处理请求的,又与Servlet之间有什么联系呢?
在SpringBoot进行web程序开发时,它内置了一个核心的Servlet程序 DispatcherServlet,称之为 核心控制器。 DispatcherServlet 负责接收页面发送的请求,然后根据执行的规则,将请求再转发给后面的请求处理器Controller,请求处理器处理完请求之后,最终再由DispatcherServlet给浏览器响应数据。
那将来浏览器发送请求,会携带请求数据,包括:请求行、请求头;请求到达tomcat之后,tomcat会负责解析这些请求数据,然后将解析后的请求数据会传递给Servlet程序的HttpServletRequest对象,那也就意味着 HttpServletRequest 对象就可以获取到请求数据。 而Tomcat,还给Servlet程序传递了一个参数 HttpServletResponse,通过这个对象,我们就可以给浏览器设置响应数据 。
那上述所描述的这种浏览器/服务器的架构模式呢,我们称之为:BS架构。
BS架构:Browser/Server,浏览器/服务器架构模式。客户端只需要浏览器,应用程序的逻辑和数据都存储在服务端。浏览器和服务器之间请求与响应,在服务器对请求进行分层解耦。
请求
当前最为主流的开发模式:前后端分离
在这种模式下,前端技术人员基于"接口文档",开发前端程序;后端技术人员也基于"接口文档",开发后端程序。
由于前后端分离,对我们后端技术人员来讲,在开发过程中,是没有前端页面的,那我们怎么测试自己所开发的程序呢?
方式:使用专业的接口测试工具(如Postman工具),其他方式参考外卖项目开发中的两种方式
Postman是一款功能强大的网页调试与发送网页HTTP请求的Chrome插件,可以模拟浏览器向后端服务器发起任何形式(如:get、post)的HTTP请求,还可以在发起请求时,携带一些请求参数、请求头等信息,常用于进行接口测试
简单参数
简单参数:在向服务器发起请求时,向服务器传递的是一些普通的请求数据。
后端程序接收简单参数的方式:
原始接收(仅了解):
在原始的Web程序当中,需要通过Servlet中提供的API:HttpServletRequest(请求对象),获取请求的相关信息。比如获取请求参数:
Tomcat接收到http请求时:把请求的相关信息封装到HttpServletRequest对象中
在Controller中,我们要想获取Request对象,可以直接在方法的形参中声明 HttpServletRequest 对象。然后就可以通过该对象来获取请求信息:
1 | //根据指定的参数名获取请求参数的数据值 |
SpringBoot接收:
在SpringBoot的环境中,对原始的API进行了封装,接收参数的形式更加简单。 如果是简单参数,参数名与形参变量名相同,定义同名的形参即可接收参数。
1 |
|
postman测试( GET 请求):

postman测试( POST请求 ):

结论:不论是GET请求还是POST请求,对于简单参数来讲,只要保证==请求参数名和Controller方法中的形参名保持一致==,就可以获取到请求参数中的数据值。
如果方法形参名称与请求参数名称不一致,controller方法中的形参还能接收到请求参数值吗?
1 |
|
答案:运行没有报错。 controller方法中的username值为:null,age值为20
- 结论:对于简单参数来讲,请求参数名和controller方法中的形参名不一致时,无法接收到请求数据
那么如果我们开发中,遇到了这种请求参数名和controller方法中的形参名不相同,怎么办?
解决方案:可以使用Spring提供的==@RequestParam注解==完成映射
在方法形参前面加上 @RequestParam 然后通过value属性执行请求参数名,从而完成映射。代码如下:
1 |
|
注意事项:
@RequestParam中的required属性默认为true(默认值也是true),代表该请求参数必须传递,如果不传递将报错

如果该参数是可选的,可以将required属性设置为false
1
2
3
4
5
public String simpleParam( String username, Integer age){
System.out.println(username+ ":" + age);
return "OK";
}
在使用简单参数做为数据传递方式时,前端传递了多少个请求参数,后端controller方法中的形参就要书写多少个。如果请求参数比较多,通过上述的方式一个参数一个参数的接收,会比较繁琐。
此时,我们可以考虑将请求参数封装到一个实体类对象中。 要想完成数据封装,需要遵守如下规则:请求参数名与实体类的属性名相同
实体参数
在使用简单参数做为数据传递方式时,前端传递了多少个请求参数,后端controller方法中的形参就要书写多少个。如果请求参数比较多,通过上述的方式一个参数一个参数的接收,会比较繁琐。
此时,我们可以考虑将请求参数封装到一个实体类对象中。 要想完成数据封装,需要遵守如下规则:请求参数名与实体类的属性名相同
定义POJO实体类:POJO :(Plain Old Java Objects),简单的Java对象,其中有一些属性及其getter、setter方法的类,有时可以作为value object或dto(Data Transform Object)来使用.当然,如果你有一个简单的运算属性也是可以的,但不允许有业务方法,也不能携带有connection之类的方法。
1 | public class User { |
Controller方法:
1 |
|
Postman测试:
- 参数名和实体类属性名一致时,均为name:一切正常
- 不一致时,请求变成了username:则 User{name='null', age = 10}
上面我们讲的呢是简单的实体对象,下面我们在来学习下复杂的实体对象。
复杂实体对象指的是,在实体类中有一个或多个属性,也是实体对象类型的。如下:
User类中有一个Address类型的属性(Address是一个实体类),即实体类中包含实体类
复杂实体对象的封装,需要遵守如下规则:
- 请求参数名与形参对象属性名相同,按照对象层次结构关系即可接收嵌套实体类属性参数
定义POJO实体类:
- Address实体类
1 | public class Address { |
- User实体类
1 | public class User { |
Controller方法:
1 |
|
Postman测试:新加的内容为address.province和address.city
数组集合参数
数组集合参数的使用场景:在HTML的表单中,有一个表单项是支持多选的(复选框),可以提交选择的多个值。其实多个值也是一个一个的提交。后端程序接收上述多个值的方式有两种:数组和集合
数组参数:请求参数名与形参数组名称相同且请求参数为多个,定义数组类型形参即可接收参数

Controller方法:
1 |
|
Postman测试
在前端请求时,有两种传递形式:
方式一: xxxxxxxxxx?hobby=game&hobby=java 方式二:xxxxxxxxxxxxx?hobby=game,java
集合参数:请求参数名与形参集合对象名相同且请求参数为多个,@RequestParam 绑定参数关系
默认情况下,请求中参数名相同的多个值,是封装到数组。如果要封装到集合,要使用@RequestParam绑定参数关系
![]()
Controller方法:
1
2
3
4
5
6
7
8
9
public class RequestController {
//数组集合参数
public String listParam( List<String> hobby){
System.out.println(hobby);
return "OK";
}
}
Postman测试:
方式一: xxxxxxxxxx?hobby=game&hobby=java 方式二:xxxxxxxxxxxxx?hobby=game,java
日期参数
上述演示的都是一些普通的参数,在一些特殊的需求中,可能会涉及到日期类型数据的封装。比如,如下需求:
要选择一个活动/项目的起始时间和结束时间时
因为日期的格式多种多样(如:2022-12-12 10:05:45 、2022/12/12 10:05:45),那么对于日期类型的参数在进行封装的时候,需要通过==@DateTimeFormat==注解,以及其pattern属性来设置日期的格式。
- @DateTimeFormat注解的pattern属性中指定了哪种日期格式,前端的日期参数就必须按照指定的格式传递。
- 后端controller方法中,需要使用Date类型或LocalDateTime类型,来封装传递的参数。
Controller方法:
1 |
|
Postman测试:
xxxxxxxxxx?updatetime=2024-4-25 10:05:45
JSON参数
JSON: JavaScript Object Notation(JavaScript 对象表示法)
JSON 是存储和交换文本信息的语法,类似XML;JSON 比XML 更小、更快,更易解析;JSON 易于人阅读和编写
如果是比较复杂的参数,前后端通过会使用JSON格式的数据进行传输。 (JSON是开发中最常用的前后端数据交互方式)
我们学习JSON格式参数,主要从以下两个方面着手:
- Postman在发送请求时,如何传递json格式的请求参数
- 在服务端的controller方法中,如何接收json格式的请求参数
Postman发送JSON格式数据:

服务端Controller方法接收JSON格式数据:
- 传递json格式的参数,在Controller中会使用实体类进行封装。
- 封装规则:JSON数据键名与形参对象属性名相同,定义POJO类型形参即可接收参数。需要使用 ==@RequestBody==标识。

- @RequestBody注解:将JSON数据映射到形参的实体类对象中(JSON中的key和实体类中的属性名保持一致)
实体类:Address
1 | public class Address { |
实体类:User
1 | public class User { |
Controller方法:
1 |
|
Postman测试:
xxxx/jsonParam:发送JSON数据,在后端成功接收
路径参数
传统的开发中请求参数是放在请求体(POST请求)传递或跟在URL后面通过?key=value的形式传递(GET请求)。
在现在的开发中,经常还会直接在请求的URL中传递参数。例如:
1 | http://localhost:8080/user/1 |
上述的这种传递请求参数的形式呢,我们称之为:路径参数。
学习主要掌握在后端的controller方法中,如何接收路径参数。
路径参数:
- 前端:通过请求URL直接传递参数
- 后端:使用{…}来标识该路径参数,需要使用@PathVariable获取路径参数

Controller方法:
1 |
|
Postman测试:xxxx/path/1
传递多个路径参数:
Postman:xxxx/path/1/SJN
Controller方法:
1 |
|
响应
Controller 是 Spring 中最基本的组件,主要处理用户交互,一般每个业务逻辑都会有一个 Controller,供用户请求接口进行数据访问。
在Spring MVC 中,控制器Controller 负责处理由DispatcherServlet 分发的请求,它把用户请求的数据经过业务层处理之后封装成一个Model ,然后再把该Model 返回给对应的View 进行展示。
Spring MVC 只需使用@Controller 标记一个类即可,然后使用@RequestMapping 和@RequestParam 等一些注解以定义URL 请求和Controller 方法之间的映射,这样Controller 就能被外界访问到。此外Controller 不会直接依赖于HttpServletRequest 和HttpServletResponse 等HttpServlet 对象。
(SpringMVC:Spring MVC是一个基于Java的Web应用程序开发框架,它是Spring Framework的一部分。MVC代表模型-视图-控制器(Model-View-Controller))
@RequestMapping 注解,为我们的应用提供了 “routing”
信息。在这里的 routing 可以理解为路径,在我们访问 Web
资源的时候都会要求提供一个路径的信息。 具体有关这个注解的解释为任何 HTTP
的请求,如果使用了 / 路径的话,所有的请求将会映像到
home 方法,或者可以理解为 home 方法
将会被执行。
@RestController 注解将会告诉 Spring 将返回的结果使用
String 字符串来进行渲染,然后将渲染的结果返回给调用者。
Controller程序呢,除了接收请求外,还可以进行响应,前面代码中的return的结果内容即是响应的结果,如何响应给浏览器呢?
答案:使用==@ResponseBody==注解
@ResponseBody注解:
- 类型:方法注解、类注解
- 位置:书写在Controller方法上或类上
- 作用:将方法返回值直接响应给浏览器
- 如果返回值类型是实体对象/集合,将会转换为JSON格式后在响应给浏览器
但是在我们所书写的Controller中,只在类上添加了@RestController注解、方法添加了@RequestMapping注解,并没有使用@ResponseBody注解,怎么给浏览器响应呢?
原因:在类上添加的@RestController注解,是一个组合注解。
- @RestController = @Controller + @ResponseBody
@RestController源码中含有注解@ResponseBody
类上有@RestController注解或@ResponseBody注解时:表示当前类下所有的方法返回值做为响应数据,返回值如果是一个POJO对象或集合时,会先转换为JSON格式,再响应给浏览器
统一响应结果
我们在前面所编写的这些Controller方法中,返回值各种各样,没有任何的规范。在真实的项目开发中,无论是哪种方法,我们都会定义一个统一的返回结果。方案如下:

前端:只需要按照统一格式的返回结果进行解析(仅一种解析方案),就可以拿到数据。
统一的返回结果使用类来描述,在这个结果中包含:
- 响应状态码:当前请求是1成功,还是0失败
- 状态码信息:给页面的提示信息
- 返回的数据:给前端响应的数据(字符串、对象、集合)
定义在一个实体类Result来包含以上信息。代码如下:
1 | public class Result { |
改造Controller:
1 |
|
原本是return的字符串,现在return 统一响应数据 Result.success了
Springboot项目的静态资源(html,css,js等前端资源)默认存放目录为:classpath:/static 、 classpath:/public、 classpath:/resources
在SpringBoot项目中,静态资源默认可以存放的目录:
- classpath:/static/
- classpath:/public/
- classpath:/resources/
- classpath:/META-INF/resources/
classpath:
- 代表的是类路径,在maven的项目中,其实指的就是 src/main/resources 或者 src/main/java,但是java目录是存放java代码的,所以相关的配置文件及静态资源文档,就放在 src/main/resources下。

当前程序的这个业务逻辑还是比较简单的,如果业务逻辑再稍微复杂一点,我们会看到Controller方法的代码量就很大了。
- 当我们要修改操作数据部分的代码,需要改动Controller
- 当我们要完善逻辑处理部分的代码,需要改动Controller
- 当我们需要修改数据响应的代码,还是需要改动Controller
===> 整个工程代码的复用性比较差,而且代码难以维护
解决办法:分层开发
5.分层解耦
概述
在我们进行程序设计以及程序开发时,尽可能让每一个接口、类、方法的职责更单一些(单一职责原则)。
单一职责原则:一个类或一个方法,就只做一件事情,只管一块功能。
这样就可以让类、接口、方法的复杂度更低,可读性更强,扩展性更好,也更利用后期的维护。
代码基本处理逻辑,从组成上看可以分为三个部分:
- 数据访问:负责业务数据的维护操作,包括增、删、改、查等操作。
- 逻辑处理:负责业务逻辑处理的代码。
- 请求处理、响应数据:负责,接收页面的请求,给页面响应数据。
按照上述的三个组成部分,在我们项目开发中呢,可以将代码分为三层:
- Controller:控制层。接收前端发送的请求,对请求进行处理,并响应数据。=》解决请求响应
- Service:业务逻辑层。处理具体的业务逻辑。=》解决核心业务逻辑
- Dao:数据访问层(Data Access Object),也称为持久层。负责数据访问操作,包括数据的增、删、改、查。=》解决数据访问问题
基于三层架构的程序执行流程:
前端发起的请求,由Controller层接收(Controller响应数据给前端)
Controller层调用Service层来进行逻辑处理(Service层处理完后,把处理结果返回给Controller层)
Serivce层调用Dao层(逻辑处理过程中需要用到的一些数据要从Dao层获取)
Dao层操作文件中的数据(Dao拿到的数据会返回给Service层)
对任一层进行变更维护,都不会影响到其他层的处理
为了实现三层架构的思想,可以在工程代码中建立以下三个包:
- 控制层包名:com.ning.controller
- 业务逻辑层包名:xxxx.service
- 数据访问层包名:xxxx.dao
分别实现:
控制层:接收前端发送的请求,对请求进行处理,并响应数据
1 |
|
业务逻辑层:处理具体的业务逻辑
- 业务接口
1 | //业务逻辑接口(制定业务标准) |
- 业务实现类
1 | //业务逻辑实现类(按照业务标准实现) |
- 数据访问实现类
1 | //数据访问实现类 |

三层架构的好处:
- 复用性强
- 便于维护
- 利用扩展
解耦
解耦:解除耦合,什么是耦合呢?
首先需要了解软件开发涉及到的两个概念:内聚和耦合。
内聚:软件中各个功能模块内部的功能联系。
耦合:衡量软件中各个层/模块之间的依赖、关联的程度。
软件设计原则:高内聚低耦合。
高内聚指的是:一个模块中各个元素之间的联系的紧密程度,如果各个元素(语句、程序段)之间的联系程度越高,则内聚性越高,即 "高内聚"。
低耦合指的是:软件中各个层、模块之间的依赖关联程序越低越好。
程序中高内聚的体现:
- EmpServiceA类中只编写了和员工相关的逻辑处理代码
程序中耦合代码的体现:
- 把业务类变为EmpServiceB时,需要修改controller层中的代码,即变成new EmpServiceB
高内聚、低耦合的目的是使程序模块的可重用性、移植性大大增强。
之前我们在编写代码时,需要什么对象,就直接new一个就可以了。 这种做法呢,层与层之间代码就耦合了,当service层的实现变了之后, 我们还需要修改controller层的代码。
解耦思路:不 new 对象
不能new,就意味着没有业务层对象,解决:
- 提供一个容器,容器中存储一些对象(例:EmpService对象)
- controller程序从容器中获取EmpService类型的对象
我们想要实现上述解耦操作,就涉及到Spring中的两个核心概念:
控制反转: Inversion Of Control,简称IOC。对象的创建控制权由程序自身转移到外部(容器),这种思想称为控制反转。
对象的创建权由程序员主动创建转移到容器(由容器创建、管理对象)。这个容器称为:IOC容器或Spring容器
依赖注入: Dependency Injection,简称DI。容器为应用程序提供运行时,所依赖的资源,称之为依赖注入。
程序运行时需要某个资源,此时容器就为其提供这个资源。
例:EmpController程序运行时需要EmpService对象,Spring容器就为其提供并注入EmpService对象
IOC容器中创建、管理的对象,称之为:bean对象
IOC & DI
任务:完成Controller层、Service层、Dao层的代码解耦
- 思路:
- 删除Controller层、Service层中new对象的代码(不new了)
- Service层及Dao层的实现类,交给IOC容器管理 (使用Spring提供的注解:==@Component==,就可以实现类交给IOC容器管理)
- 为Controller及Service注入运行时依赖的对象(使用Spring提供的注解:==@Autowired==
,就可以实现程序运行时IOC容器自动注入需要的依赖对象)
- Controller程序中注入依赖的Service层对象
- Service程序中注入依赖的Dao层对象
完整的三层代码:
- Controller层:
1 |
|
- Service层:
1 | //实现2. 将当前对象交给IOC容器管理,成为IOC容器的bean |
Dao层:
1 | //将当前对象交给IOC容器管理,成为IOC容器的bean 实现2. |
接下来呢,我们学习下IOC控制反转和DI依赖注入的细节。
前面我们提到IOC控制反转,就是将对象的控制权交给Spring的IOC容器,由IOC容器创建及管理对象。IOC容器创建的对象称为bean对象。
在之前的入门案例中,要把某个对象交给IOC容器管理,需要在类上添加一个注解:@Component
而Spring框架为了更好的标识web应用程序开发当中,bean对象到底归属于哪一层,又提供了@Component的衍生注解:
- @Controller (标注在控制层类上)(由于代码中有标注@RestController = @Controller + @ResponseBody),故不用标注它
- @Service (标注在业务层类上)
- @Repository (标注在数据访问层类上)
要把某个对象交给IOC容器管理,需要在对应的类上加上如下注解之一:
| 注解 | 说明 | 位置 |
|---|---|---|
| @Controller | @Component的衍生注解 | 标注在控制器类上 |
| @Service | @Component的衍生注解 | 标注在业务类上 |
| @Repository | @Component的衍生注解 | 标注在数据访问类上(由于与mybatis整合,用的少) |
| @Component | 声明bean的基础注解 | 不属于以上三类时,用此注解 |
在IOC容器中,每一个Bean都有一个属于自己的名字,可以通过注解的value属性指定bean的名字。如果没有指定,默认为类名首字母小写。
注意事项:
- 声明bean的时候,可以通过value属性指定bean的名字,如果没有指定,默认为首字母小写后的类名(类名EmpServiceA ->bean名empServiceA)。
- 使用以上四个注解都可以声明bean,但是在springboot集成web开发中,声明控制器bean只能用@Controller。
使用四大注解声明的bean,要想生效,还需要被组件扫描注解==@ComponentScan==扫描
@ComponentScan注解虽然没有显式配置,但是实际上已经包含在了引导类声明注解 @SpringBootApplication 中,==默认扫描的范围是SpringBoot启动类所在包及其子包==。
在本项目中在:SpringbootWebReqRespApplication(启动类)
推荐做法(如下图):
- 将我们定义的controller,service,dao这些包呢,都放在引导类所在包com.ning的子包下,这样我们定义的bean就会被自动的扫描到,即让启动类.java代码和dao包等平级
依赖注入DI,是指IOC容器要为应用程序去提供运行时所依赖的资源,而资源指的就是对象。
在入门程序案例中,我们使用了@Autowired这个注解,完成了依赖注入的操作,而这个Autowired翻译过来叫:自动装配。
@Autowired注解,默认是按照类型进行自动装配的(去IOC容器中找某个类型的对象,然后完成注入操作)
入门程序举例:在EmpController运行的时候,就要到IOC容器当中去查找EmpService这个类型的对象,而我们的IOC容器中刚好有一个EmpService这个类型的对象,所以就找到了这个类型的对象完成注入操作。
那如果在IOC容器中,存在多个相同类型的bean对象,会出现什么情况呢?

程序运行会报错
如何解决上述问题呢?Spring提供了以下几种解决方案:
- @Primary 默认的实现
- @Qualifier value指定名称
- @Resource name属性指定要注入的bean的名称
使用@Primary注解:当存在多个相同类型的Bean注入时,加上@Primary注解,来确定默认的实现。

使用@Qualifier注解:指定当前要注入的bean对象。 在@Qualifier的value属性中,指定注入的bean的名称。
- @Qualifier注解不能单独使用,必须配合@Autowired使用

使用@Resource注解:是按照bean的名称进行注入。通过name属性指定要注入的bean的名称。

面试题 : @Autowird 与 @Resource的区别
- @Autowired 是spring框架提供的注解,而@Resource是JDK提供的注解
- @Autowired 默认是按照类型注入,而@Resource是按照名称注入