JavaWeb后端开发：Maven和SpringBoot

Web后端开发

Maven

Maven是apache旗下的一个开源项目，是一款用于管理和构建Java项目的工具。Maven基于项目对象模型(POM)的概念，通过一小段描述信息来管理项目的构建。

官网：http://maven.apache.org/

【Apache软件基金会】成立于1999年7月，是目前世界上最大的最受欢迎的开源软件基金会，也是一个专门为支持开源项目而生的非盈利性组织。

开源项目：https://www.apache.org/index.html#projects-list

Maven流程

仓库：用于存储资源，管理各种jar包。

本地仓库：自己计算机上的一个目录。
中央仓库：由Maven团队维护的全球唯一的。仓库地址：https://repo1.maven.org/maven2/
远程仓库（私服）：一般由公司团队搭建的私有仓库。（一般使用阿里云的私服：http://maven.aliyun.com/nexus/content/groups/public/）

Maven的作用

1.依赖管理：管理项目依赖的资源(jar包)，避免版本冲突问题。Maven在pom.xml文件中的<dependencies></dependencies>、<dependency></dependency>标签下定义依赖的资源。

2.统一项目结构：提供标准、统一的项目结构。

3.项目构建：标准跨平台（Linux、Windows、MacOS）的自动化项目构建方式。

Maven安装

参考安装链接：全站最全Maven下载安装配置教学（2024更新…全版本）建议收藏…赠送IDEA配置Maven教程-CSDN博客

1.解压apache-maven-3.6.1-bin.zip（安装最新版本即可）。

2.配置本地仓库：修改conf/settings.xml中的<localRepository>为一个指定目录。在解压的Maven目录下新建mvn_repo文件夹，将该文件夹作为本地仓库的目录。

1	`<localRepository>D:\Programs\apache-maven-3.9.9\mvn_repo</localRepository> <!-- 配置本地仓库 -->`

3.配置阿里云私服：修改conf/settings.xml中的<mirrors>标签，为其添加如下子标签：

<mirror>
    <id>alimaven</id>
    <name>aliyun maven</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    <mirrorOf>central</mirrorOf>
</mirror>

4.配置环境变量: MAVEN_HOME为maven的解压目录，并将其bin目录加入PATH环境变量。

5.测试是否安装成功：mvn -v

C:\Users\srr18>mvn -v
Apache Maven 3.9.9 (8e8579a9e76f7d015ee5ec7bfcdc97d260186937)
Maven home: D:\Programs\apache-maven-3.9.9
Java version: 21.0.4, vendor: Oracle Corporation, runtime: D:\Programs\Java\jdk-21
Default locale: zh_CN, platform encoding: UTF-8
OS name: "windows 11", version: "10.0", arch: "amd64", family: "windows"

IDEA集成Maven

配置Maven环境

1.新建Empty Project，打开Project Structure配置项目的SDK和Language level为自己的Java版本。

2.Settings->Build, Execution, Deployment->Maven，按照下图所示设置Maven路径。

Settings->Build, Execution, Deployment->Maven->Runner，设置JRE，我是默认Use Project JDK。

3.Settings->Build, Execution, Deployment->Compiler->Java Compiler，设置Project bytecode version，我这里是same as language level（新版本的IDEA不用修改，旧版本的改成和JDK对应版本就行）。

【注意】上述是局部配置，如果需要全局配置，则Customize->All setting...里面修改即可。关闭当前工程项目，再重新打开IDEA即可出现Customize。

创建Maven项目

方法一：

1.new->Module，选择Java，Build system选择Maven，点击create创建完成。

2.得到的Maven项目结构如下图所示，在test文件夹下可以新建目录resources，存放项目资源。在src->main->java下新建package，然后新建class，编写代码，即可运行该程序。

3.如果需要使用Junit进行测试，则需要在pom.xml文件下配置依赖。然后右键运行即可。可以在maven面板中选择该项目->Lifecycle->compile进行编译，产生的文件会在和src同级的target目录下。

<!-- 依赖配置 -->
<dependency>
    <groupId>junit</groupId>XML
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

方法二：

1.new->Module，选择Maven Archetype，Archetype选择org.apache.maven.archetypes:maven-archetype-quickstart，点击create创建完成。

2.得到的Maven项目结构如下图所示，在main和test文件夹下可以新建目录resources，存放项目资源。在src->main->java下有默认创建好的包，包下有App.java文件，可以右键运行。

Maven坐标

Maven中的坐标是资源的唯一标识，通过该坐标可以唯一定位资源位置。使用坐标来定义项目或引入项目中需要的依赖。

Maven坐标主要组成：

groupId：定义当前Maven项目隶属组织名称（通常是域名反写，例如：com.itheima）。
artifactId：定义当前Maven项目名称（通常是模块名称，例如 order-service、goods-service）。
version：定义当前项目版本号。

<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>

导入Maven项目

方法一：

方法二：

依赖管理

Maven依赖仓库：

Maven Repository: Search/Browse/Explore (mvnrepository.com)

依赖配置

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

配置：

在pom.xml中编写<dependencies>标签。
在<dependencies>标签中使用<dependency>引入坐标。
定义坐标的groupId，artifactId，version。
点击刷新按钮（右上角），或者在Maven面板中刷新，引入最新加入的坐标。

注意：

1.如果引入的依赖，在本地仓库不存在，将会连接远程仓库/中央仓库，然后下载依赖。（这个过程会比较耗时，耐心等待）

2.如果不知道依赖的坐标信息，可以到https://mvnrepository.com/中搜索。

依赖传递

依赖具有传递性：

直接依赖：在当前项目中通过依赖配置建立的依赖关系。

间接依赖：被依赖的资源如果依赖其他资源，当前项目间接依赖其他资源。

排除依赖：排除依赖指主动断开依赖的资源，被排除的资源无需指定版本。使用<exclusion></exclusion>排除资源。

<dependency>    
    <groupId>com.itheima</groupId>    
    <artifactId>maven-projectB</artifactId>    
    <version>1.0-SNAPSHOT</version>    
    <exclusions>        
        <exclusion>            
            <groupId>junit</groupId>            
            <artifactId>junit</artifactId>        
        </exclusion>    
    </exclusions>
</dependency>

依赖范围

依赖的jar包，默认情况下，可以在任何地方使用。可以通过<scope></scope >设置其作用范围。

作用范围：

主程序范围有效。（main文件夹范围内）
测试程序范围有效。（test文件夹范围内）
是否参与打包运行。（package指令范围内）

scope值	主程序	测试程序	打包（运行）	范例
compile（默认）	Y	Y	Y	log4j
test	-	Y	-	junit
provided	Y	Y	-	servlet-api
runtime	-	Y	Y	jdbc驱动

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.10</version>
    <scope>test</scope >
</dependency>

生命周期

Maven的生命周期就是为了对所有的maven项目构建过程进行抽象和统一。

Maven中有3套相互独立的生命周期：

clean：清理工作。
default：核心工作，如：编译、测试、打包、安装、部署等。
site：生成报告、发布站点等。

每套生命周期包含一些阶段（phase），阶段是有顺序的，后面的阶段依赖于前面的阶段。

重要的生命周期阶段：

clean：移除上一次构建生成的文件。

target文件夹会被清除。
compile：编译项目源代码。

生成target文件夹。
test：使用合适的单元测试框架运行测试(junit)。

控制台会显示TESTs的测试运行结果。
package：将编译后的文件打包，如：jar、war等。

在target文件夹下会新生成一堆文件夹和两个jar包：maven-project01-1.0-SNAPSHOT.jar和maven-project01-1.0-SNAPSHOT-jar-with-dependencies.jar，其中maven-project01是项目的名字，1.0-SNAPSHOT是版本。可以当作压缩文件，使用解压缩文件打开。maven-project01-1.0-SNAPSHOT-jar-with-dependencies.jar是包含依赖的包，在其ch文件夹下，就是该项目所有的依赖。

install：安装项目到本地仓库。

在本地仓库目录下，可以找到该项目，如：D:\Programs\apache-maven-3.9.9\mvn_repo\org\example\maven-project01。控制台也会显示安装的地址：

1
2

[INFO] Installing E:\2_学习\JavaWeb\code\itheima_web_project\maven-project\pom.xml to D:\Programs\apache-maven-3.9.9\mvn_repo\com\itheima\maven-project\1.0-SNAPSHOT\maven-project-1.0-SNAPSHOT.pom
[INFO] Installing E:\2_学习\JavaWeb\code\itheima_web_project\maven-project\target\maven-project-1.0-SNAPSHOT.jar to D:\Programs\apache-maven-3.9.9\mvn_repo\com\itheima\maven-project\1.0-SNAPSHOT\maven-project-1.0-SNAPSHOT.jar

注意：在同一套生命周期中，当运行后面的阶段时，前面的阶段都会运行。

执行指定生命周期的两种方式：

在IDEA中，右侧的maven工具栏，选中对应的生命周期，双击执行。
在命令行该项目路径下，通过命令执行。如：mvn clean、mvn compile、mvn package、mvn test。

SpringBoot

官网：Spring | Home

Spring发展到今天已经形成了一种开发生态圈，Spring提供了若干个子项目，每个项目用于完成特定的功能。

SpringBootWeb快速入门

方法一：

1.创建springboot工程，填写模块信息。

勾选web开发相关依赖。

方法二：

如果遇到网络不好，在IDEA里无法创建SpringBoot工程。可以通过访问SpringBoot的官网Spring Initializr，在网页创建SpringBoot工程，下载压缩包后解压即可。

【报错】

（1）Dependency 'org.springframework.boot:spring-boot-starter-test:' not found

参考链接：

首次使用IDEA创建maven项目出现“Dependency ‘org.springframework.boot:spring-boot-starter-web:‘ not found”问题_dependency ‘org.springframework.boot:spring-boot-s-CSDN博客

这里指出需要在pom.xml文件下点击图标下载maven所需的仓库。

Dependency ‘org.springframework.boot:spring-boot-starter-test:not found 的解决方法_dependency ‘org.springframework.boot:spring-boot-s-CSDN博客

这个是点击下载键导包。

（2）ERROR:JAVA: 错误: 不支持发行版本 5 解决方法

出现原因：本地配置jdk和idea默认的jdk不匹配

参考链接：

ERROR:JAVA: 错误: 不支持发行版本 5 解决方法-CSDN博客

我是使用方法一更改的。让SDK、language level、Project bytecode version的版本是一致的。

【补充：Project bytecode version、language level、JDK】

出现版本不一致的解决方法：

（3）java: 程序包org.springframework.boot不存在

参考链接：解决java: 程序包org.springframework.boot不存在的解决方法_idea java: 程序包org.springframework.boot不存在-CSDN博客

使用上述链接的方法二可以解决：在该工程下命令行，通过mvn -U idea:idea命令重新加载maven包。

E:\2_学习\JavaWeb\code\itheima_web_project\springboot-web-quickstart>mvn -U idea:idea
[INFO] Not adding resource directory as it has an incompatible target path or filtering: E:\2_学习\JavaWeb\code\itheima_web_project\springboot-web-quickstart\src\main\resources
[INFO] jdkName is not set, using [java version21.0.4] as default.
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  43.804 s
[INFO] Finished at: 2024-10-10T15:21:34+08:00
[INFO] ------------------------------------------------------------------------

运行上述步骤还不行，可以重启IDEA，然后就可以了。

（4）Error: Cannot download 'https://start.spring.io/starter.zip?type=maven-project&bootVersion=3.3.4&groupId=com.itheima&artifactId=springboot-web-test&name=springboot-web-test&version=0.0.1-SNAPSHOT&language=java&packageName=com.itheima&javaVersion=17&packaging=jar&description=springboot-web-test&dependencies=web': Connection reset , response: 200 OK

可能是网络不好，关掉重写再来一次就可以了。

2.定义HelloController类，添加方法hello，并添加注解。

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String hello() {
        System.out.println("hello surourou");
        return "hello surourou";
    }
}

3.运行启动类SpringbootWebQuickstartApplication，打开浏览器使用链接http://localhost:8080/hello进行测试。

HTTP协议

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

特点：

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

HTTP请求数据格式

1.请求行：请求数据第一行（请求方式、资源路径、协议）。

2.请求头：第二行开始，格式key：value。

key	value
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	HTTP请求主体的大小（单位：字节）。

3.请求体：POST请求，存放请求参数。（请求头和请求体之间有空行。）

注意：

请求方式GET：请求参数在请求行中，没有请求体，如：/brand/findAll?name=OPPO&status=1。GET请求大小是有限制的。
请求方式POST：请求参数在请求体中，POST请求大小是没有限制的。

HTTP响应格式

1.响应行：响应数据第一行（协议、状态码、描述）。

状态码	状态
1xx	响应中-临时状态码，表示请求已经接收，告诉客户端应该继续请求或者如果它已经完成则忽略它。
2xx	成功-表示请求已经被成功接收，处理已完成。
3xx	重定向-重定向到其他地方；让客户端再发起一次请求以完成整个处理。
4xx	客户端错误-处理发生错误，责任在客户端。如: 请求了不存在的资源、客户端未被授权、禁止访问等。
5xx	服务器错误-处理发生错误，责任在服务端。如：程序抛出异常等。
200	客户端请求成功。
404	请求资源不存在，般是URL输入有误，或者网站资源被删除了。
500	服务器发生不可预期的错误。

2.响应头：第二行开始，格式key：value。

key	value
Content-Type	表示该响应内容的类型，例如text/html，application/json。
Content-Length	表示该响应内容的长度（字节数）。
Content-Encoding	表示该响应压缩算法，例如gzip。
Cache-Control	指示客户端应如何缓存，例如max-age=300表示可以最多缓存300秒。
Set-Cookie	告诉浏览器为当前页面所在的域设置cookie。

3.响应体：最后一部分，存放响应数据。（响应头和响应体之间有空行。）

Web服务器

Web服务器是一个软件程序，对HTTP协议的操作进行封装，使得程序员不必直接对协议进行操作，让Web开发更加便捷。主要功能是部署Web项目，对外提供网上信息浏览服务。

Tomcat

概念：Tomcat是Apache软件基金会一个核心项目，是一个开源免费的轻量级Web服务器，支持Servlet/JSP少量JavaEE规范。

JavaEE：Java Enterprise Edition，Java企业版。指Java企业级开发的技术规范总和。包含13项技术规范：JDBC、JNDI、EJB、RMI、JSP、Servlet、XML、JMS、Java IDL、JTS、JTA、JavaMail、JAF。
JavaSE：Java标准版。
JavaME：Java小型版。

Tomcat也被称为Web容器、Servlet容器。Servlet程序需要依赖于Tomcat才能运行。

官网：https://tomcat.apache.org/

Tomcat基本使用

下载：官网下载，地址 https://tomcat.apache.org/download-90.cgi

安装：绿色版，直接解压即可。

卸载：直接删除目录即可。

启动：双击bin\startup.bat。

控制台中文乱码：修改conf/ logging.properties。

java.util.logging.ConsoleHandler.level = ALL
java.util.logging.ConsoleHandler.formatter = org.apache.juli.OneLineFormatter
# java.util.logging.ConsoleHandler.encoding = UTF-8
java.util.logging.ConsoleHandler.encoding = GBK
# 修改为GBK，在控制台才不会出现中文乱码

关闭：

直接×掉运行窗口：强制关闭。
bin\shutdown.bat：正常关闭。
Ctrl+C：正常关闭。

Tomcat部署项目：将项目放置到webapps目录下，即部署完成。

访问Web项目地址：http://localhost:8080/ ，若访问webapps目录下的项目，则通过 http://localhost:8080/demo/ 访问到webapps/demo/index.html。

【常见问题】

1.启动窗口一闪而过：检查JAVA_HOME：D:\Programs\Java\jdk-21环境变量是否正确配置。

2.端口号冲突：找到对应程序，将其关闭掉。

配置Tomcat端口号（conf/server.xml）：

<Connector port="8080" protocol="HTTP/1.1"
    connectionTimeout="20000"
    redirectPort="8443"
    maxParameterCount="1000"
               />

注意：HTTP协议默认端口号为80，如果将Tomcat端口号改为80，则将来访问Tomcat时，将不用输入端口号。

SpringBootWeb入门程序解析

起步依赖：

spring-boot-starter-web：包含了Web应用开发所需要的常见依赖。

spring-boot-starter-test：包含了单元测试所需要的常见依赖。

官方提供的starter：https://docs.spring.io/spring-boot/docs/2.7.4/reference/htmlsingle/#using.build-systems.starters

SpringBootWeb内嵌Tomcat服务器：

基于Springboot开发的Web应用程序，内置了tomcat服务器，当启动类运行时，会自动启动内嵌的tomcat服务器。

SpringBoot请求

Postman

Postman是一款功能强大的网页调试与发送网页HTTP请求的Chrome插件。

作用：常用于进行接口测试。

注意：有时候使用Postman发送请求没有反应，返回数据一片空白，大概率不是程序的问题，重启一下Postman就好了。

简单参数

原始方式

在原始的web程序中，获取请求参数，需要通过HttpServletRequest对象手动获取。

package com.itheima.controller;

@RestController
public class RequestController {//在com.itheima.controller包下
    //原始方式
    @RequestMapping("/simpleParam")
    public String simpleParam(HttpServletRequest request) {
        //获取请求参数
        String name = request.getParameter("name");
        String ageStr = request.getParameter("age");

        int age = Integer.parseInt(ageStr);
        System.out.println(name + ":" + age);
        return name + ":" + age;
    }
}

Postman请求：http://localhost:8080/simpleParam?name=surourou&age=18

SpringBoot方式

参数名与形参变量名相同，定义形参即可接收参数。SpringBoot会自动进行类型转换。

//SpringBoot方式
@RequestMapping("/simpleParamSpringBoot")
public String simpleParamSpringBoot(String name, int age) {
    System.out.println(name + ":" + age);
    return "simpleParamSpringBoot : " + name + ":" + age;
}

注意：使用该方式可以发送GET和POST请求，POST请求需要在boy里面填写键值信息。

Postman的GET请求：http://localhost:8080/simpleParamSpringBoot?name=surourou&age=18

如果方法形参名称与请求参数名称不匹配，程序不会报错，但是传入的值会变成null。可以使用@RequestParam完成映射。注意： @RequestParam中的required属性默认为true，代表该请求参数必须传递，如果不传递将报错。如果该参数是可选的，可以将required属性设置为false。

//SpringBoot方式
@RequestMapping("/simpleParamSpringBoot")
public String simpleParamSpringBoot(@RequestParam(name = "name") String username, int age) {
    System.out.println(username + ":" + age);
    return "simpleParamSpringBoot : " + username + ":" + age;
}

实体参数

简单实体对象

简单实体对象：请求参数名与形参对象属性名相同，定义POJO接收即可。

package com.itheima.pojo;

public class User {//在com.itheima.pojo包下
    private String name;
    private int age;

    public User(String name, int age) {//1.定义构造函数
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {//2.设置setter方法
        this.name = name;
    }

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

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

@RequestMapping("simplePojo")
public String simplePojo(User user) {
    System.out.println(user);
    return "simplePojo : " + user;
}

Postman请求：http://localhost:8080/simplePojo?name=surourou&age=18

【注意】：User类必须定义构造函数或者setter方法，否则无法获取到传入的参数值，得到的值为默认值：User{name='null', age=0}。正常得到的值为：User{name='surourou', age=18}。

【注意】：虽然上述定义构造函数的方法可行，但是后续需要new User对象赋值时，会出现报错。所以最好还是使用定义setter和getter方法。

复杂实体对象

复杂实体对象：请求参数名与形参对象属性名相同，按照对象层次结构关系即可接收嵌套POJO属性参数。

package com.itheima.pojo;

public class User {
    private String name;
    private int age;
    private Address address;

    //注意：只能使用有全部参数的构造函数，不能加入其他构造函数
    public User(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

/*    //不能加入这个构造函数
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }*/

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

package com.itheima.pojo;

public class Address {
    private String province;
    private String city;

    public Address(String province, String city) {
        this.province = province;
        this.city = city;
    }

    @Override
    public String toString() {
        return "Address{" +
                "province='" + province + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}

@RequestMapping("complexPojo")
public String complexPojo(User user) {
    System.out.println(user);
    return "simplePojo : " + user;
}

Postman请求：http://localhost:8080/complexPojo?name=surourou&age=18&address.province=zhanjiang&address.city=shenzhen

得到的User结果：User{name='surourou', age=18, address=Address{province='zhanjiang', city='shenzhen'}}

数组集合参数

数组参数

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

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

Postman请求：http://localhost:8080/arrayParam?hobby=sing&hobby=rap

集合参数

集合参数：请求参数名与形参集合名称相同且请求参数为多个，@RequestParam绑定参数关系。

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

Postman请求：http://localhost:8080/listParam?hobby=sing&hobby=rap

日期参数

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

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

Postman请求：[日期参数](http://localhost:8080/dateParam?updateTime=2024-10-13 10:55:08)

JSON参数

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

@RequestMapping("jsonParam")
public String jsonParam(@RequestBody User user) {
    System.out.println(user);
    return "jsonParam : " + user;
}

Postman请求：http://localhost:8080/jsonParam

body内容：

{
    "name" : "surourou",
    "age" : 18,
    "address" : {
        "province" : "zhanjiang",
        "city" : "shenzhen"
    }
}

路径参数

路径参数：通过请求URL直接传递参数，使用{…}来标识该路径参数，需要使用@PathVariable获取路径参数。

单个路径：

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

Postman请求：http://localhost:8080/path/8

多个路径：

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

Postman请求：http://localhost:8080/path/8/surourou

SpringBoot响应

@ResponseBody

类型：方法注解、类注解。

位置：Controller方法上/类上。

作用：将方法返回值直接响应，如果返回值类型是实体对象/集合 ，将会转换为JSON格式响应。

说明：@RestController = @Controller + @ResponseBody

统一响应结果

使用Result类统一响应结果格式：

{
    "code": 1,
    "msg": "操作成功",
    "data": …
}
{
    "code": 0,
    "msg" : "密码错误",
    "data": …
}

Result类：

package com.itheima.pojo;

//统一响应结果封装类
public class Result {
    private Integer code ;//1 成功 , 0 失败
    private String msg; //提示信息
    private Object data; //数据 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) {Java
        this.data = data;
    }

    public static Result success(Object data){
        return new Result(1, "success", data);
    }
    public static Result success(){
        return new Result(1, "success", null);
    }
    public static Result error(String msg){
        return new Result(0, msg, null);
    }

    @Override
    public String toString() {
        return "Result{" +
                "code=" + code +
                ", msg='" + msg + '\'' +
                ", data=" + data +
                '}';
    }
}

【注意】：一定要设置Address类的setter和getter方法，否则会报错：com.fasterxml.jackson.databind.exc.InvalidDefinitionException: No serializer found for class com.itheima.pojo.Address and no properties discovered to create BeanSerializer。

参考链接：JAVA—-JSON序列化错误:InvalidDefinitionException: No serializer found for class org.apache.ibatis.execut_java 实体类 json序列号不对的提示信息-CSDN博客

package com.itheima.pojo;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

//@JsonIgnoreProperties(value = { "handler" }) //加入这句不会报错，但是返回的值为空
public class Address {
    private String province;
    private String city;
    public Address(){}
    public Address(String province, String city) {
        this.province = province;
        this.city = city;
    }

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

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

    public String getProvince() {
        return province;
    }

    public String getCity() {
        return city;
    }

    @Override
    public String toString() {
        return "Address{" +
                "province='" + province + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}

@RestController
public class ResponseController {
    @RequestMapping("/hello")
    public Result hello() {
        System.out.println("hello surourou");
        return new Result(1, "success", "hello surourou");
    }

    @RequestMapping("/getAddr")
    public Result getAddr() {
        Address address = new Address();
        address.setProvince("zhanjiang");
        address.setCity("shenzhen");
        return new Result(1, "success", address);
    }

    @RequestMapping("/listAddr")
    public Result listAddr() {
        List<Address> list = new ArrayList<>();
        Address address1 = new Address();
        address1.setProvince("zhanjiang");
        address1.setCity("shenzhen");

        Address address2 = new Address();
        address2.setProvince("guangzhou");
        address2.setCity("foshan");
        list.add(address1);
        list.add(address2);
        return new Result(1, "success", list);
    }
}

案例

案例要求：加载并解析emp.xml文件中的数据，完成数据处理，并在页面展示。

1.在pom.xml文件中引入dom4j的依赖，用于解析XML文件。

<!-- 解析XML -->
<dependency>
    <groupId>org.dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>2.1.3</version>
</dependency>

【注意】如果IDEA内无法加载依赖，使用CMD打开命令行，然后使用mvn -U idea:idea命令即可下载依赖。

2.引入资料中提供的解析XML的工具类XMLParserUtils、对应的实体类Emp、XML文件emp.xml（存放数据）。

package com.itheima.utils;

public class XmlParserUtils {

    public static <T> List<T> parse(String file , Class<T> targetClass)  {
        ArrayList<T> list = new ArrayList<T>(); //封装解析出来的数据
        try {
            //1.获取一个解析器对象
            SAXReader saxReader = new SAXReader();
            //2.利用解析器把xml文件加载到内存中,并返回一个文档对象
            Document document = saxReader.read(new File(file));
            //3.获取到根标签
            Element rootElement = document.getRootElement();
            //4.通过根标签来获取 user 标签
            List<Element> elements = rootElement.elements("emp");

            //5.遍历集合,得到每一个 user 标签
            for (Element element : elements) {
                //获取 name 属性
                String name = element.element("name").getText();
                //获取 age 属性
                String age = element.element("age").getText();
                //获取 image 属性
                String image = element.element("image").getText();
                //获取 gender 属性
                String gender = element.element("gender").getText();
                //获取 job 属性
                String job = element.element("job").getText();

                //组装数据
                Constructor<T> constructor = targetClass.getDeclaredConstructor(String.class, Integer.class, String.class, String.class, String.class);
                constructor.setAccessible(true);
                T object = constructor.newInstance(name, Integer.parseInt(age), image, gender, job);

                list.add(object);
            }Java
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }

}

package com.itheima.pojo;

public class Emp {
    private String name;
    private Integer age;
    private String image;
    private String gender;
    private String job;

    public Emp() {
    }

    public Emp(String name, Integer age, String image, String gender, String job) {
        this.name = name;
        this.age = age;
        this.image = image;
        this.gender = gender;
        this.job = job;
    }

    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 String getImage() {
        return image;
    }

    public void setImage(String image) {
        this.image = image;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", image='" + image + '\'' +
                ", gender='" + gender + '\'' +
                ", job='" + job + '\'' +
                '}';
    }
}

<!-- 在resources目录下 -->
<?xml version="1.0" encoding="UTF-8" ?>
<emps>
    <emp>
        <name>金毛狮王</name>
        <age>55</age>
        <image>https://web-framework.oss-cn-hangzhou.aliyuncs.com/web/1.jpg</image>
        <!-- 1: 男, 2: 女 -->
        <gender>1</gender>
        <!-- 1: 讲师, 2: 班主任 , 3: 就业指导 -->
        <job>1</job>
    </emp>

    <emp>
        <name>白眉鹰王</name>
        <age>65</age>
        <image>https://web-framework.oss-cn-hangzhou.aliyuncs.com/web/2.jpg</image>
        <gender>1</gender>
        <job>1</job>
    </emp>

    <emp>
        <name>青翼蝠王</name>
        <age>45</age>
        <image>https://web-framework.oss-cn-hangzhou.aliyuncs.com/web/3.jpg</image>
        <gender>1</gender>
        <job>2</job>
    </emp>

    <emp>
        <name>紫衫龙王</name>
        <age>38</age>
        <image>https://web-framework.oss-cn-hangzhou.aliyuncs.com/web/4.jpg</image>
        <gender>2</gender>
        <job>3</job>
    </emp>
</emps>

3.引入资料中提供的静态页面文件，放在resources下的static目录下。

【注意】Springboot项目的静态资源（html，css，js等前端资源）默认存放目录为：classpath:/static 、classpath:/public、 classpath:/resources。

classpath是类路径，对于Maven来说，resources就是类路径。

4.编写Controller程序，处理请求，响应数据。

package com.itheima.controller;

@RestController
public class EmpController {
    @RequestMapping("listEmp")
    public Result listEmp(){
        //1.加载并解析emp.xml
        //注意文件路径不要有中文和空格，否则使用下面这句代码会出现错误。如果有中文路径，使用绝对路径访问。
//        String file = this.getClass().getClassLoader().getResource("emp.xml").getFile();
        String file = "E:\\2_学习\\JavaWeb\\code\\itheima_web_project\\springboot-web-test\\src\\main\\resources\\emp.xml";
        //拿到当前类resources目录下的emp.xml文件
        System.out.println(file);
        List<Emp> empList = XmlParserUtils.parse(file, Emp.class);

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

            //处理job：1讲师，2班主任，3就业指导
            if("1".equals(emp.getJob())){
                emp.setJob("讲师");
            }else if("2".equals(emp.getJob())){
                emp.setJob("班主任");
            }else if("3".equals(emp.getJob())){
                emp.setJob("就业指导");
            }
        });

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

分层解耦

三层架构

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

//dao数据访问层，定义接口
package com.itheima.dao;

public interface EmpDao {
    //获取员工列表数据
    public List<Emp> listEmp();
}

//dao数据访问层，实现接口
package com.itheima.dao.impl;

public class EmpDaoA implements EmpDao {
    @Override
    public List<Emp> listEmp() {
        //1.加载并解析emp.xml
        //注意文件路径不要有中文和空格，否则使用下面这句代码会出现错误。如果有中文路径，使用绝对路径访问。
//        String file = this.getClass().getClassLoader().getResource("emp.xml").getFile();
        String file = "E:\\2_学习\\JavaWeb\\code\\itheima_web_project\\springboot-web-test\\src\\main\\resources\\emp.xml";
        //拿到当前类resources目录下的emp.xml文件
        System.out.println(file);
        List<Emp> empList = XmlParserUtils.parse(file, Emp.class);
        return empList;
    }
}

//service业务逻辑层，定义接口
package com.itheima.service;

public interface EmpService {
    //获取员工列表
    public List<Emp>  listEmp();
}

//service业务逻辑层，实现接口
package com.itheima.service.impl;

public class EmpServiceA implements EmpService {
    private EmpDao empDao = new EmpDaoA();
    @Override
    public List<Emp> listEmp() {
        List<Emp> empList = empDao.listEmp();

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

            //处理job：1讲师，2班主任，3就业指导
            if("1".equals(emp.getJob())){
                emp.setJob("讲师");
            }else if("2".equals(emp.getJob())){
                emp.setJob("班主任");
            }else if("3".equals(emp.getJob())){
                emp.setJob("就业指导");
            }
        });

        return empList;
    }
}

//controller控制层
package com.itheima.controller;

@RestController
public class EmpController {
    private EmpService empService = new EmpServiceA();
    @RequestMapping("listEmp")
    public Result listEmp(){
        List<Emp> empList = empService.listEmp();

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

分层解耦

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

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

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

控制反转： Inversion Of Control，简称IOC。对象的创建控制权由程序自身转移到外部（容器），这种思想称为控制反转。

依赖注入： Dependency Injection，简称DI。容器为应用程序提供运行时，所依赖的资源，称之为依赖注入。

Bean对象：IOC容器中创建、管理的对象，称之为bean。

IOC & DI入门

1.Service层及Dao层的实现类，交给IOC容器管理。

1 2	`@Component //将当前类交给IOC容器管理，成为IOC容器中的bean public class EmpServiceA implements EmpService {}`

1 2	`@Component //将当前类交给IOC容器管理，成为IOC容器中的bean public class EmpDaoA implements EmpDao {}`

2.为Controller及Service注入运行时，依赖的对象。

public class EmpController {
    @Autowired //运行时，IOC容器会提供该类型的bean对象，并赋值给该变量，依赖注入
    private EmpService empService;
}

@Component
public class EmpServiceA implements EmpService {
    @Autowired //运行时，IOC容器会提供该类型的bean对象，并赋值给该变量，依赖注入
    private EmpDao empDao;
}

IOC详解

Bean的声明

要把某个对象交给IOC容器管理，需要在对应的类上加上如下注解之一：

注解	说明	位置
`@Component`	声明`bean`的基础注解	不属于以下三类时，用此注解
`@Controller`	`@Component`的衍生注解	标注在控制器类上
`@Service`	`@Component`的衍生注解	标注在业务类上
`@Repository`	`@Component`的衍生注解	标注在数据访问类上（由于与`mybatis`整合，用的少）

注意：

1.声明bean的时候，可以通过value属性指定bean的名字，如果没有指定，默认为类名首字母小写。如：@Repository(value="daoA")/@Repository("daoA")指定该数据访问类名字为daoA。

2.使用以上四个注解都可以声明bean，但是在springboot集成web开发中，声明控制器bean只能用@Controller。

Bean组件扫描

1.前面声明bean的四大注解，要想生效，还需要被组件扫描注解@ComponentScan扫描。

2.@ComponentScan注解虽然没有显式配置，但是实际上已经包含在了启动类声明注解@SpringBootApplication中，默认扫描的范围是启动类所在包及其子包。如果dao不在com.itheima包下，则需要在启动类下声明@ComponentScan({"dao", "com.itheima"})。

DI详解

Bean注入

@Autowired注解，默认是按照类型进行，如果存在多个相同类型的bean，将会报出如下错误：

Description:

Field empService in com.itheima.controller.EmpController required a single bean, but 2 were found:
	- empServiceA: defined in file [E:\2_学习\JavaWeb\code\itheima_web_project\springboot-web-test\target\classes\com\itheima\service\impl\EmpServiceA.class]
	- empServiceB: defined in file [E:\2_学习\JavaWeb\code\itheima_web_project\springboot-web-test\target\classes\com\itheima\service\impl\EmpServiceB.class]

This may be due to missing parameter name information

Action:

Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed

通过以下几种方案来解决：

1.@Primary

@Primary
@Service
public class EmpServiceA implements EmpService {
}

2.@Qualifier：@Autowired + @Qualifier("bean的名称")

@RestController
public class EmpController {
    @Autowired
    @Qualifier(value = "empServiceA")
    private EmpService empService ;
}

3.@Resource：@Resource(name="bean的名称")

@RestController
public class EmpController {
    @Resource(name = "empServiceB")
    private EmpService empService ;
}

@Resource与@Autowired区别：

1.@Autowired是spring框架提供的注解，而@Resource是JDK提供的注解。

2.@Autowired默认是按照类型注入，而@Resource默认是按照名称注入。

JavaWeb

#JavaWeb

JavaWeb后端开发：Maven和SpringBoot

http://surourou8.github.io/2024/10/14/JavaWeb后端开发：Maven和SpringBoot/

作者

Su Rourou

发布于

2024年10月14日

许可协议

JavaWeb后端开发：MySQL和MyBatis 上一篇

JavaWeb前端开发下一篇