0%

JavaWeb开发

Maven

1.Maven入门

概述

Maven是Apache旗下的一个开源项目,是一款用于管理和构建java项目的工具。

Maven作用:

  1. 依赖管理
  • 方便快捷的管理项目依赖的资源(jar包),避免引入大量的jar包,不同jar包之间的版本冲突问题
  • 当使用maven进行项目依赖(jar包)管理,则很方便的可以解决这个问题。 我们只需要在maven项目的pom.xml文件中,添加一段依赖实现
  1. 统一项目结构
  • 提供标准、统一的项目结构,使用不同的开发工具Eclipse或者IDEA创建项目工程时发现项目结构不一致,若创建的是一个maven工程,是可以帮我们自动生成统一、标准的项目目录结构:
image-20221130220539444

统一结构为:

1
2
3
4
- src/main/java: java源代码目录
- src/main/resources: 配置文件信息
- src/test/java: 测试代码
- src/test/resources: 测试配置文件信息
  1. 项目构建

maven提供了标准的、跨平台(Linux、Windows、MacOS) 的自动化项目构建方式image-20221130222907628

  • 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配置文件即可(阿里云私服)==注: 只可配置一个(另一个要注释!) ,不然两个可能发生冲突,导致jar包无法下载!!!!!!!==

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<!-- POM模型版本 -->
<modelVersion>4.0.0</modelVersion>

<!-- 当前项目坐标 -->
<groupId>com.itheima</groupId>
<artifactId>maven_project1</artifactId>
<version>1.0-SNAPSHOT</version>

<!-- 打包方式 -->
<packaging>jar</packaging>

</project>

pom文件详解:

  • :pom文件的根标签,表示当前maven项目
  • :声明项目描述遵循哪一个POM模型版本
    • 虽然模型本身的版本很少改变,但它仍然是必不可少的。目前POM模型版本是4.0.0
  • 坐标 :、、
    • 定位项目在本地仓库中的位置,由以上三个标签组成一个坐标
  • :maven项目的打包方式,通常设置为jar或war(默认值:jar)

使用Maven面板,通过导入pox文件可以快速导入Maven文件

3.Maven依赖管理

依赖:指当前项目运行所需要的jar包。一个项目中可以引入多个依赖:

例如:在当前工程中,我们需要用到logback来记录日志,此时就可以在maven工程的pom.xml文件中,引入logback的依赖。具体步骤如下:

  1. 在pom.xml中编写标签
  2. 在标签中使用引入坐标
  3. 定义坐标的 groupId、artifactId、version
  4. 点击刷新按钮,引入最新加入的坐标
    • 刷新依赖:保证每一次引入新的依赖,或者修改现有的依赖配置,都可以加入最新的坐标

添加依赖的几种方式:

  1. 利用中央仓库搜索的依赖坐标
  2. 利用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包也一起导入。

依赖传递可以分为:

  1. 直接依赖:在当前项目中通过依赖配置建立的依赖关系
  2. 间接依赖:被依赖的资源如果依赖其他资源,当前项目间接依赖其他资源

排除依赖:

在maven项目中,我们可以通过排除依赖来实现:A依赖B,B依赖C,如果A不想将C依赖进来

什么是排除依赖?

  • 排除依赖:指主动断开依赖的资源。(被排除的资源无需指定版本)

依赖排除示例:

  • maven-projectA依赖了maven-projectB,maven-projectB依赖了Junit。基于依赖的传递性,所以maven-projectA也依赖了Junit

使用排除依赖后,maven-projectA不再依赖了Junit

依赖范围:

在项目中导入依赖的jar包后,默认情况下,可以在任何地方使用。

如果希望限制依赖的使用范围,可以通过标签设置其作用范围。

作用范围:

  1. 主程序范围有效(main文件夹范围内)
  2. 测试程序范围有效(test文件夹范围内)
  3. 是否参与打包运行(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不会,因为不是一套)

在日常开发中,当我们要执行指定的生命周期时,有两种执行方式:

  1. 在idea工具右侧的maven工具栏中,选择对应的生命周期,双击执行
  2. 在DOS命令行中,通过maven命令执行

compile后:只对main文件夹(主函数)源代码编译,生成target目录

test:对test文件夹(测试程序)进行编译

package:对项目打包,生成jar包,打包后生成的jar包放在target目录下

install:把jar文件安装在当前项目文件夹指定坐标路径下(target)

image-20221201170830837

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
2
3
4
5
6
7
set REPOSITORY_PATH=E:\develop\apache-maven-3.6.1\mvn_repo
rem 正在搜索...

del /s /q %REPOSITORY_PATH%\*.lastUpdated

rem 搜索完毕
pause

操作步骤如下:

1). 定义批处理文件del_lastUpdated.bat (直接创建一个文本文件,命名为del_lastUpdated,后缀名直接改为bat即可 )

image-20221214154949482

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工程。

image-20221201184702136

基本信息描述完毕之后,勾选web开发相关依赖。

点击Finish之后,就会联网创建这个SpringBoot工程,创建好之后,结构如下:

src - main - java - com.ning - SpringBootQuickStarte1Appication.java

在com.ning这个包下创建一个子包controller,再在controller包下新建一个类:HelloController

编写:

1
2
3
4
5
6
7
8
9
10
11
12
package com.itheima.controller;
import org.springframework.web.bind.annotation.*;

@RestController//注解,非常有用!!!
public class HelloController {

@RequestMapping("/hello")
public String hello(){
System.out.println("Hello World ~");
return "Hello World ~";
}
}

运行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工程,都有一个父工程。依赖的版本号,在父工程中统一管理。

parent标签指示父工程

同时,在刚刚启动的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协议要求:浏览器在向服务器发送请求数据时,或是服务器在向浏览器发送响应数据时,都必须按照固定的格式进行数据传输

格式:

浏览器向服务器进行请求时:

  • 服务器按照固定的格式进行解析
image-20221202111044434

服务器向浏览器进行响应时:

  • 浏览器按照固定的格式进行解析
image-20221202111307819

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
  • 请求头 :第二行开始,上图黄色部分内容就是请求头。格式为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
    9
    Content-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给浏览器响应数据。

image-20220826165340157

那将来浏览器发送请求,会携带请求数据,包括:请求行、请求头;请求到达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
2
//根据指定的参数名获取请求参数的数据值
String request.getParameter("参数名")

SpringBoot接收:

在SpringBoot的环境中,对原始的API进行了封装,接收参数的形式更加简单。 如果是简单参数,参数名与形参变量名相同,定义同名的形参即可接收参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
@RestController
public class RequestController {
// http://localhost:8080/simpleParam?name=Tom&age=10
// 第1个请求参数: name=Tom 参数名:name,参数值:Tom
// 第2个请求参数: age=10 参数名:age , 参数值:10

//springboot方式
@RequestMapping("/simpleParam")
public String simpleParam(String name , Integer age ){//形参名和请求参数名保持一致
System.out.println(name+" : "+age);
return "OK";
}
}

postman测试( GET 请求):

postman测试( POST请求 ):

结论:不论是GET请求还是POST请求,对于简单参数来讲,只要保证==请求参数名和Controller方法中的形参名保持一致==,就可以获取到请求参数中的数据值。

如果方法形参名称与请求参数名称不一致,controller方法中的形参还能接收到请求参数值吗?

1
2
3
4
5
6
7
8
9
10
11
12
@RestController
public class RequestController {
// http://localhost:8080/simpleParam?name=Tom&age=20
// 请求参数名:name

//springboot方式
@RequestMapping("/simpleParam")
public String simpleParam(String username , Integer age ){//请求参数名和形参名不相同
System.out.println(username+" : "+age);
return "OK";
}
}

答案:运行没有报错。 controller方法中的username值为:null,age值为20

  • 结论:对于简单参数来讲,请求参数名和controller方法中的形参名不一致时,无法接收到请求数据

那么如果我们开发中,遇到了这种请求参数名和controller方法中的形参名不相同,怎么办?

解决方案:可以使用Spring提供的==@RequestParam注解==完成映射

在方法形参前面加上 @RequestParam 然后通过value属性执行请求参数名,从而完成映射。代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
@RestController
public class RequestController {
// http://localhost:8080/simpleParam?name=Tom&age=20
// 请求参数名:name

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

注意事项:

@RequestParam中的required属性默认为true(默认值也是true),代表该请求参数必须传递,如果不传递将报错

如果该参数是可选的,可以将required属性设置为false

1
2
3
4
5
@RequestMapping("/simpleParam")
public String simpleParam(@RequestParam(name = "name", required = false) 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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class User {
private String name;
private Integer age;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Integer getAge() {
return age;
}

public void setAge(Integer age) {
this.age = age;
}

@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}

Controller方法:

1
2
3
4
5
6
7
8
9
10
@RestController
public class RequestController {
//实体参数:简单实体对象
@RequestMapping("/simplePojo")
public String simplePojo(User user){
System.out.println(user);
return "OK";
}
}
//user实体类中的属性必须与请求参数一致,为age和name

Postman测试:

  • 参数名和实体类属性名一致时,均为name:一切正常
  • 不一致时,请求变成了username:则 User{name='null', age = 10}

上面我们讲的呢是简单的实体对象,下面我们在来学习下复杂的实体对象。

复杂实体对象指的是,在实体类中有一个或多个属性,也是实体对象类型的。如下:

  • User类中有一个Address类型的属性(Address是一个实体类),即实体类中包含实体类

  • 复杂实体对象的封装,需要遵守如下规则:

    • 请求参数名与形参对象属性名相同,按照对象层次结构关系即可接收嵌套实体类属性参数

定义POJO实体类:

  • Address实体类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class Address {
private String province;
private String city;

public String getProvince() {
return province;
}

public void setProvince(String province) {
this.province = province;
}

public String getCity() {
return city;
}

public void setCity(String city) {
this.city = city;
}

@Override
public String toString() {
return "Address{" +
"province='" + province + '\'' +
", city='" + city + '\'' +
'}';
}
}
  • User实体类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class User {
private String name;
private Integer age;
private Address address; //地址对象

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Integer getAge() {
return age;
}

public void setAge(Integer age) {
this.age = age;
}

public Address getAddress() {
return address;
}

public void setAddress(Address address) {
this.address = address;
}

@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", address=" + address +
'}';
}
}

Controller方法:

1
2
3
4
5
6
7
8
9
@RestController
public class RequestController {
//实体参数:复杂实体对象
@RequestMapping("/complexPojo")
public String complexPojo(User user){
System.out.println(user);
return "OK";
}
}

Postman测试:新加的内容为address.province和address.city

数组集合参数

数组集合参数的使用场景:在HTML的表单中,有一个表单项是支持多选的(复选框),可以提交选择的多个值。其实多个值也是一个一个的提交。后端程序接收上述多个值的方式有两种:数组和集合

数组参数:请求参数名与形参数组名称相同且请求参数为多个,定义数组类型形参即可接收参数

Controller方法:

1
2
3
4
5
6
7
8
9
@RestController
public class RequestController {
//数组集合参数
@RequestMapping("/arrayParam")
public String arrayParam(String[] hobby){
System.out.println(Arrays.toString(hobby));
return "OK";
}
}

Postman测试

在前端请求时,有两种传递形式:

方式一: xxxxxxxxxx?hobby=game&hobby=java 方式二:xxxxxxxxxxxxx?hobby=game,java

集合参数:请求参数名与形参集合对象名相同且请求参数为多个,@RequestParam 绑定参数关系

默认情况下,请求中参数名相同的多个值,是封装到数组。如果要封装到集合,要使用@RequestParam绑定参数关系

image-20221203211640646

Controller方法:

1
2
3
4
5
6
7
8
9
@RestController
public class RequestController {
//数组集合参数
@RequestMapping("/listParam")
public String listParam(@RequestParam 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
2
3
4
5
6
7
8
9
@RestController
public class RequestController {
//日期时间参数
@RequestMapping("/dateParam")
public String dateParam(@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime updateTime){
System.out.println(updateTime);
return "OK";
}
}

Postman测试:

xxxxxxxxxx?updatetime=2024-4-25 10:05:45

JSON参数

JSON: JavaScript Object Notation(JavaScript 对象表示法)

JSON 是存储和交换文本信息的语法,类似XML;JSON 比XML 更小、更快,更易解析;JSON 易于人阅读和编写

如果是比较复杂的参数,前后端通过会使用JSON格式的数据进行传输。 (JSON是开发中最常用的前后端数据交互方式)

我们学习JSON格式参数,主要从以下两个方面着手:

  1. Postman在发送请求时,如何传递json格式的请求参数
  2. 在服务端的controller方法中,如何接收json格式的请求参数

Postman发送JSON格式数据:

服务端Controller方法接收JSON格式数据:

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

  • @RequestBody注解:将JSON数据映射到形参的实体类对象中(JSON中的key和实体类中的属性名保持一致)

实体类:Address

1
2
3
4
5
6
public class Address {
private String province;
private String city;

//省略GET , SET 方法
}

实体类:User

1
2
3
4
5
6
7
public class User {
private String name;
private Integer age;
private Address address;

//省略GET , SET 方法
}

Controller方法:

1
2
3
4
5
6
7
8
9
@RestController
public class RequestController {
//JSON参数
@RequestMapping("/jsonParam")
public String jsonParam(@RequestBody User user){
System.out.println(user);
return "OK";
}
}

Postman测试:

xxxx/jsonParam:发送JSON数据,在后端成功接收

路径参数

传统的开发中请求参数是放在请求体(POST请求)传递或跟在URL后面通过?key=value的形式传递(GET请求)。

在现在的开发中,经常还会直接在请求的URL中传递参数。例如:

1
2
http://localhost:8080/user/1		
http://localhost:880/user/1/0

上述的这种传递请求参数的形式呢,我们称之为:路径参数。

学习主要掌握在后端的controller方法中,如何接收路径参数。

路径参数:

  • 前端:通过请求URL直接传递参数
  • 后端:使用{…}来标识该路径参数,需要使用@PathVariable获取路径参数

Controller方法:

1
2
3
4
5
6
7
8
9
@RestController
public class RequestController {
//路径参数
@RequestMapping("/path/{id}")
public String pathParam(@PathVariable Integer id){
System.out.println(id);
return "OK";
}
}

Postman测试:xxxx/path/1

传递多个路径参数:

Postman:xxxx/path/1/SJN

Controller方法:

1
2
3
4
5
6
7
8
9
@RestController
public class RequestController {
//路径参数
@RequestMapping("/path/{id}/{name}")
public String pathParam2(@PathVariable Integer id, @PathVariable String name){
System.out.println(id+ " : " +name);
return "OK";
}
}

响应

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public class Result {
private Integer code;//响应码,1 代表成功; 0 代表失败
private String msg; //响应码 描述字符串
private Object data; //返回的数据

public Result() { }
public Result(Integer code, String msg, Object data) {
this.code = code;
this.msg = msg;
this.data = data;
}

public Integer getCode() {
return code;
}

public void setCode(Integer code) {
this.code = code;
}

public String getMsg() {
return msg;
}

public void setMsg(String msg) {
this.msg = msg;
}

public Object getData() {
return data;
}

public void setData(Object data) {
this.data = data;
}

//增删改 成功响应(不需要给前端返回数据)
public static Result success(){
return new Result(1,"success",null);
}
//查询 成功响应(把查询结果做为返回数据响应给前端)
public static Result success(Object data){
return new Result(1,"success",data);
}
//失败响应
public static Result error(String msg){
return new Result(0,msg,null);
}
}

改造Controller:

1
2
3
4
5
6
7
8
9
@RestController
public class ResponseController {
//响应统一格式的结果
@RequestMapping("/hello")
public Result hello(){
System.out.println("Hello World ~");
//return new Result(1,"success","Hello World ~");
return Result.success("Hello World ~");
}

原本是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),也称为持久层。负责数据访问操作,包括数据的增、删、改、查。=》解决数据访问问题

基于三层架构的程序执行流程:

  1. 前端发起的请求,由Controller层接收(Controller响应数据给前端)

  2. Controller层调用Service层来进行逻辑处理(Service层处理完后,把处理结果返回给Controller层)

  3. Serivce层调用Dao层(逻辑处理过程中需要用到的一些数据要从Dao层获取)

  4. Dao层操作文件中的数据(Dao拿到的数据会返回给Service层)

对任一层进行变更维护,都不会影响到其他层的处理

为了实现三层架构的思想,可以在工程代码中建立以下三个包:

  • 控制层包名:com.ning.controller
  • 业务逻辑层包名:xxxx.service
  • 数据访问层包名:xxxx.dao

分别实现:

控制层:接收前端发送的请求,对请求进行处理,并响应数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@RestController
public class EmpController {
//业务层对象
private EmpService empService = new EmpServiceA();

@RequestMapping("/listEmp")
public Result list(){
//1. 调用service层, 获取数据
List<Emp> empList = empService.listEmp();

//3. 响应数据
return Result.success(empList);
}
}

业务逻辑层:处理具体的业务逻辑

  • 业务接口
1
2
3
4
5
//业务逻辑接口(制定业务标准)
public interface EmpService {
//获取员工列表
public List<Emp> listEmp();
}
  • 业务实现类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//业务逻辑实现类(按照业务标准实现)
public class EmpServiceA implements EmpService {
//调用数据访问层dao层的:new dao层对象
private EmpDao empDao = new EmpDaoA();
//重写接口方法
@Override
public List<Emp> listEmp() {
//1. 调用dao, 获取数据
List<Emp> empList = empDao.listEmp();

//2. 对数据进行转换处理 - gender, job
empList.stream().forEach(emp -> {
//处理 gender 1: 男, 2: 女
String gender = emp.getGender();
if("1".equals(gender)){
emp.setGender("男");
}else if("2".equals(gender)){
emp.setGender("女");
}

//处理job - 1: 讲师, 2: 班主任 , 3: 就业指导
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;
}
}
  • 数据访问实现类
1
2
3
4
5
6
7
8
9
10
11
//数据访问实现类
public class EmpDaoA implements EmpDao {
@Override
public List<Emp> listEmp() {
//1. 加载并解析emp.xml
String file = this.getClass().getClassLoader().getResource("emp.xml").getFile();
System.out.println(file);
List<Emp> empList = XmlParserUtils.parse(file, Emp.class);
return empList;
}
}

三层架构的好处:

  1. 复用性强
  2. 便于维护
  3. 利用扩展

解耦

解耦:解除耦合,什么是耦合呢?

首先需要了解软件开发涉及到的两个概念:内聚和耦合。

  • 内聚:软件中各个功能模块内部的功能联系。

  • 耦合:衡量软件中各个层/模块之间的依赖、关联的程度。

软件设计原则:高内聚低耦合。

高内聚指的是:一个模块中各个元素之间的联系的紧密程度,如果各个元素(语句、程序段)之间的联系程度越高,则内聚性越高,即 "高内聚"。

低耦合指的是:软件中各个层、模块之间的依赖关联程序越低越好。

程序中高内聚的体现:

  • 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层的代码解耦

  • 思路:
    1. 删除Controller层、Service层中new对象的代码(不new了)
    2. Service层及Dao层的实现类,交给IOC容器管理 (使用Spring提供的注解:==@Component==,就可以实现类交给IOC容器管理)
    3. 为Controller及Service注入运行时依赖的对象(使用Spring提供的注解:==@Autowired== ,就可以实现程序运行时IOC容器自动注入需要的依赖对象)
      • Controller程序中注入依赖的Service层对象
      • Service程序中注入依赖的Dao层对象

完整的三层代码:

  • Controller层:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@RestController
public class EmpController {

@Autowired //运行时,从IOC容器中获取该类型对象,赋值给该变量
//不new了
private EmpService empService ;

@RequestMapping("/listEmp")
public Result list(){
//1. 调用service, 获取数据
List<Emp> empList = empService.listEmp();

//3. 响应数据
return Result.success(empList);
}
}
  • Service层:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
@Component //实现2. 将当前对象交给IOC容器管理,成为IOC容器的bean
public class EmpServiceA implements EmpService {

@Autowired //实现3. 运行时,从IOC容器中获取该类型对象,赋值给该变量
private EmpDao empDao ;

@Override
public List<Emp> listEmp() {
//1. 调用dao, 获取数据
List<Emp> empList = empDao.listEmp();

//2. 对数据进行转换处理 - gender, job
empList.stream().forEach(emp -> {
//处理 gender 1: 男, 2: 女
String gender = emp.getGender();
if("1".equals(gender)){
emp.setGender("男");
}else if("2".equals(gender)){
emp.setGender("女");
}

//处理job - 1: 讲师, 2: 班主任 , 3: 就业指导
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;
}
}

Dao层:

1
2
3
4
5
6
7
8
9
10
11
@Component //将当前对象交给IOC容器管理,成为IOC容器的bean 实现2.
public class EmpDaoA implements EmpDao {
@Override
public List<Emp> listEmp() {
//1. 加载并解析emp.xml
String file = this.getClass().getClassLoader().getResource("emp.xml").getFile();
System.out.println(file);
List<Emp> empList = XmlParserUtils.parse(file, Emp.class);
return empList;
}
}

接下来呢,我们学习下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是按照名称注入