初识Spring Boot

众生云海，一念初见

已于 2022-06-18 11:40:00 修改

阅读量528

点赞数 10

分类专栏： SpringBoot Spring JavaWeb 文章标签： spring boot spring java

于 2022-06-06 12:15:50 首次发布

本文链接：https://blog.csdn.net/qq_24431059/article/details/125144166

版权

JavaWeb 同时被 3 个专栏收录

23 篇文章 2 订阅

订阅专栏

Spring

10 篇文章 0 订阅

订阅专栏

SpringBoot

2 篇文章 0 订阅

订阅专栏

文章目录

一、学习目标与任务
- 1.1学习目标
- 1.2学习任务
二、Spring Boot概述
三、搭建Spring Boot项目
四、Spring Boot项目的三个核心文件
五、Spring Boot的Web项目的启动方式
- 5.1Spring Boot Web项目启动方式
- 5.1Spring Boot-内置Web容器
六、Yaml语法学习
七、使用Maven构建多模块项目
八、本文总结

一、学习目标与任务

1.1学习目标

搭建Spring Boot项目
使用Spring Boot改造掌上游戏管理平台的框架
使用Maven构建多模块项目

1.2学习任务

理解Spring Boot的定义和作用
掌握Spring Boot三个核心文件的使用
掌握Spring Boot项目的简单操作
掌握使用Maven构建多模块项目的方法

二、Spring Boot概述

2.0 Spring回顾

Spring是Java EE编程领域的一个轻量级开源J2EE应用程序框架，该框架由一个叫Rod Johnson的程序员在 2002 年最早提出并随后创建，是为了解决企业级编程开发中的复杂性，实现敏捷开发的应用型框架，很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。

Spring是一个开源容器框架，它集成各类型的工具，通过核心的Bean factory实现了底层的类的实例化和生命周期的管理。在整个框架中，各类型的功能被抽象成一个个的 Bean，这样就可以实现各种功能的管理，包括动态加载和切面编程。 Spring是独特的，因为若干个原因：

它定位的领域是许多其他流行的framework没有的。Spring致力于提供一种方法管理你的业务对象。
Spring是全面的和模块化的。Spring有分层的体系结构，这意味着你能选择使用它孤立的任何部分，它的架构仍然是内在稳定的。例如，你可能选择仅仅使用Spring来简单化JDBC的使用，或用来管理所有的业务对象。

它的设计从底部帮助你编写易于测试的代码。Spring是用于测试驱动工程的理想的framework。
Spring对你的工程来说，它不需要一个以上的framework。Spring是潜在地一站式解决方案，定位于与典型应用相关的大部分基础结构。它也涉及到其他framework没有考虑到的内容。

Spring是如何简化Java开发的？

为了降低Java开发的复杂性，Spring采用了以下4种关键策略：

基于POJO的轻量级和最小侵入性编程，所有东西都是Bean；
通过IOC，依赖注入（DI）和面向接口实现松耦合；
基于切面（AOP）和惯例进行声明式编程；
通过切面和模版减少样式代码，RedisTemplate，xxxTemplate；

2.1Spring Boot-概述与特点

在这里插入图片描述

Spring Boot 是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

说的直白点 SpringBoot就是一个JavaWeb的开发框架，和SpringMVC类似，对比其他JavaWeb框架的好处，官方说是简化开发，约定大于配置， you can “just run”，能迅速的开发web应用，几行代码开发一个http接口。

Spring Boot 基于 Spring 开发，Spirng Boot 本身并不提供 Spring 框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于 Spring 框架的应用程序。也就是说，它并不是用来替代 Spring 的解决方案，而是和 Spring 框架紧密结合用于提升 Spring 开发者体验的工具。Spring Boot 以==约定大于配置的核心思想，默认帮我们进行了很多设置，多数 Spring Boot 应用只需要很少的 Spring 配置。同时它集成了大量常用的第三方库配置（例如 Redis、MongoDB、Jpa、RabbitMQ、Quartz 等等），Spring Boot 应用中这些第三方库几乎可以零配置的开箱即用==。

SpringBoot其实不是什么新的框架，它默认配置了很多框架的使用方式，就像maven整合了所有的jar包，spring boot整合了所有的框架

Spring Boot 出生名门，从一开始就站在一个比较高的起点，又经过这几年的发展，生态足够完善，Spring Boot 已经当之无愧成为 Java 领域最热门的技术。

SpringBoot特点：

SpringBoot基于Spring4.0设计，不仅继承了Spring框架原有的优秀特性，而且还通过简化配置来进一步简化了Spring应用的整个搭建和开发过程。另外SpringBoot通过集成大量的框架使得依赖包的版本冲突，以及引用的不稳定性等问题得到了很好的解决。

SpringBoot特征：

可以创建独立的Spring应用程序，并且基于其Maven或Gradle插件，可以创建可执行的JARs和WARs；
内嵌Tomcat或Jetty等Servlet容器；
提供自动配置的“starter”项目对象模型（POMS）以简化Maven配置；
尽可能自动配置Spring容器；
提供准备好的特性，如指标、健康检查和外部化配置；
绝对没有代码生成，不需要XML配置

为什么使用SpringBoot?

现有框架技术种类繁多，且多以整合方式运用,配置繁多、流程复杂，影响开发效率。而SpringBoot简化Spring应用的初始搭建以及开发过程。

下图中我们对比SpringBoot和SSM框架可以看出SpringBoot让我们开发中减少了配置的编写，提升了开发效率。

在这里插入图片描述

2.2Spring Boot-优势

SpringBoot优势

1.简化配置

减少配置： 约定优于配置

优化配置： 单一配置文件（application.properties/application.yml），配置集中，便于管理提供所有配置属性的元数据，便于IDE提供上下文帮助和代码补全。

2.简化部署

内置Web容器，只需运行项目的启动类即可实现部署运行

3.简化监测

提供Actuator模块监控运行指标、健康度、线程信息、请求调用等，非常适用于微服务架构的系统中。

4.与主流框架无缝集成

三、搭建Spring Boot项目

3.1搭建Spring Boot项目-环境要求

Spring Boot 的环境要求

环境	版本
JDK	1.8+
项目构建工具	Maven3.8.1或 Gradle4.4+
Spring Framework	5.1.6 Release或更高版本
Web容器	Tomcat9+或Jetty9.4+

3.2搭建Spring Boot项目-2种创建方式

项目创建方式一：使用Spring Initializr 的 Web页面创建项目

打开使用Spring Initializr 的 Web页面创建项目
填写项目信息
点击 “GENERATE CTRL” 按钮生成项目；下载此项目
解压项目包，并用IDEA以Maven项目导入，一路下一步即可，直到项目导入完毕。
如果是第一次使用，可能速度会比较慢，包比较多、需要耐心等待一切就绪。

在这里插入图片描述

项目创建方式二：使用 IDEA 直接创建项目

使用IDEA创建项目模块
使用Spring Initializr生成项目结构
使用Maven进行项目构建，根据需求设置Maven坐标等内容
选择依赖的Spring Boot版本和组件
设置项目名称和项目的存储位置，完成构建

使用Spring Initializr生成项目结构

使用Maven进行项目构建，根据需求设置Maven坐标等内容

在这里插入图片描述

选择依赖的Spring Boot版本和组件,设置项目名称和项目的存储位置，完成构建。

在这里插入图片描述

项目构建后：

在这里插入图片描述

项目结构分析：

通过上面步骤完成了基础项目的创建。就会自动生成以下文件。

程序的主启动类
一个 application.properties 配置文件
一个测试类
一个 pom.xml

pom.xml 分析:

打开 pom.xml ，看看Spring Boot项目的依赖：

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!-- 父依赖 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.aiden</groupId>
    <artifactId>teaching-springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>teaching-springboot</name>
    <description>Study Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!-- web场景启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- springboot单元测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- 打包插件 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

3.3搭建Spring Boot项目-编写HTTP接口

编写HTTP接口

在主程序的同级目录下，新建一个controller包，一定要在同级目录下，否则识别不到
在包中新建一个``类
通过启动类 StudySpringbootApplication 运行项目
编写完毕后，从主程序启动项目，打开浏览器发起请求，看页面返回；
控制台输出了 Tomcat 访问的端口号！

HelloController类：

package com.aiden.teachingspringboot.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author Aiden
 */
@RestController
public class HelloController {
    @GetMapping("hello")
    public String hello(){
        return "Hello Spring Boot";
    }
}

通过启动类 StudySpringbootApplication 运行项目

在这里插入图片描述

浏览器输入“localhost:8080/hello” 进行访问：

在这里插入图片描述

简单几步，就完成了一个web接口的开发，SpringBoot就是如此简单。所以常用它来建立我们的微
服务项目！

四、Spring Boot项目的三个核心文件

4.1Spring Boot核心文件 -POM文件

POM文件

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!-- 父依赖 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.aiden</groupId>
    <artifactId>teaching-springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>teaching-springboot</name>
    <description>Study Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!-- web场景启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- springboot单元测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <!-- 剔除依赖 -->
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <!-- 打包插件 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

配置中主要有四个部分：

项目元数据 ：创建时候输入的Project Metadata部分，也就是Maven项目的基本元素，包括：groupId、artifactId、version、name、description等。
parent ：继承spring-boot-starter-parent的依赖管理，控制版本与打包等内容。
dependencies ：项目具体依赖，这里包含了spring-boot-starter-web用于实现HTTP接口（该依赖中包含了Spring MVC），官网对它的描述是：使用Spring MVC构建Web（包括RESTful）应用程序的入门者，使用Tomcat作为默认嵌入式容器。spring-boot-starter-test用于编写单元测试的依赖包。更多功能模块的使用将在后面逐步展开。
build ：构建配置部分。默认使用了spring-boot-maven-plugin，配合spring-boot-starter-parent就可以把Spring Boot应用打包成JAR来直接运行。

4.2Spring Boot应用打包成JAR运行

使用Spring Boot应用打包成JAR运行示例：

在这里插入图片描述

打包后jar包生成位置：

在这里插入图片描述

打开系统管理员 Windows PowerShell 输入java -jar jar包名称 运行即可。

java -jar teaching-springboot-0.0.1-SNAPSHOT.jar

在这里插入图片描述

打开浏览器输入localhost:8080/hello运行测试：

在这里插入图片描述

4.3Spring Boot核心文件-启动类

启动类
main()方法
组合注解 @SpringBootApplication
@Target
@Retention
@Document
@Inherited
@SpringBootConfiguration ：可代替Spring的applicationContext.xml配置文件
@EnableAutoConfiguration ：启动Spring Boot的自动配置
@ComponentScan ：扫描启动类同目录及子目录下的所有注解标注的组件

4.4Spring Boot核心文件-application.properties

包含Spring Boot项目大部分的配置信息
放在项目资源路径resources的根路径下
Spring Boot项目能够自动识别

application.properties / application.yml

#配置服务端口号
server.port=8080
#配置项目的访问根路径
server.servlet.context-path=/teachingspringboot/
#配置日志的输出路径
logging.file.path=E:\\logs
#配置日志的输出格式
logging.pattern.file=%d-%msg%n
logging.file.name=E:\\logs\\日志文件名.log

五、Spring Boot的Web项目的启动方式

5.1Spring Boot Web项目启动方式

在本地Web容器中启动
- 通过Maven将项目打包成war文件
- 将war文件拷贝至本地Web容器中部署运行
使用Maven启动项目
- 进入项目根路径
- 执行 mvn spring-boot:run 命令
使用Java命令启动项目
- 通过Maven将项目打包成jar文件
- 进入jar文件所在目录
- 使用 java -jar 命令运行jar文件

5.1Spring Boot-内置Web容器

使用内置的Web容器启动

Spring Boot支持三种内置容器：Tomcat、Jetty和Undertow
默认的内置Web容器是Tomcat
修改POM文件可以替换内置的Web容器

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 <exclusions> <!-- 禁用Tomcat容器 -->
     <exclusion>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-tomcat</artifactId>
     </exclusion>
 </exclusions>
</dependency>
<!-- 添加与Jetty相关的依赖 -->
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

六、Yaml语法学习

6.1配置文件

SpringBoot使用一个全局的配置文件，配置文件名称是固定：

application.properties
- 语法结构： key=value
application.yml
- 语法结构：key：空格 value

配置文件的作用 ：主要用于修改SpringBoot自动配置的默认值，因为SpringBoot在底层都给我们自动配置好了；比如我们可以在配置文件中修改Tomcat 默认启动的端口号！

修改Tomcate默认端口号：

server.port=8081

6.2yaml 概述

YAML是 “YAML Ain’t a Markup Language” （YAML不是一种标记语言）的递归缩写。

在开发的这种语言时，YAML 的意思其实是：“Yet Another Markup Language”（仍是一种标记语言）

这种语言以数据做为中心，而不是以标记语言为重点！

以前的配置文件，大多数都是使用xml来配置；比如一个简单的端口配置，我们来对比下yaml和xml。

传统xml配置：

<server>
	<port>8081<port>
</server>

yaml配置：

server：
	prot: 8080

6.3yaml基础语法

语法要求：

空格不能省略
以缩进来控制层级关系，只要是左边对齐的一列数据都是同一个层级的。
属性和值的大小写都是十分敏感的。

字面量 ：普通的值 [ 数字，布尔值，字符串 ]

字面量直接写在后面就可以，字符串默认不用加上双引号或者单引号；

k: v

注意事项：

" " 双引号，不会转义字符串里面的特殊字符，特殊字符会作为本身想表示的意思；
- 示例： name: "hello \n yaml" 输出： hello 换行 yaml
’ ’ 单引号，会转义特殊字符，特殊字符最终会变成和普通字符一样输出
- 示例： name: ‘hello \n yaml’ 输出： hello\n yaml

对象、Map（键值对）语法

#对象、Map格式
k:
	v1:
	v2:

对象的属性和值的关系，注意缩进；示例：

student:
	name: aiden
	age: 30

行内写法示例：

student: {name: aiden,age: 30}

数组（ List、set ）

用 - 值表示数组中的一个元素,示例：

animal:
	-dog
	-cat
	-penguin

行内写法示例：

animal: [cat,dog,penguin]

修改SpringBoot的默认端口号示例：

server:
	port: 8088

6.4注入配置文件

yaml文件更强大的地方在于，他可以给我们的实体类直接注入匹配值

实体类直接注入匹配值示例：

1.在springboot项目中的resources目录下新建一个文件application.yml

2.编写一个实体类 class Dog{ }

package com.aiden.teachingspringboot.controller.pojo;

import org.springframework.stereotype.Component;

/**
 * 狗狗类
 * @author Aiden
 */
@Component //注入bean到容器中
public class Dog {
    private String name;//昵称
    private String strain;//品种

    public Dog() {}

    public Dog(String name, String strain) {
        this.name = name;
        this.strain = strain;
    }

    public String getName() {
        return name;
    }

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

    public String getStrain() {
        return strain;
    }

    public void setStrain(String strain) {
        this.strain = strain;
    }

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

3.使用 @Value 给bean注入属性值示例：

@Component //注入bean到容器中
public class Dog {
 	 @Value("旺财")
 	 private String name;//昵称
 	 @Value("中华田园犬")
	 private String strain;//品种
}

4.在SpringBoot的测试类下注入狗狗输出一下

package com.aiden.teachingspringboot;

import com.aiden.teachingspringboot.pojo.Dog;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class TeachingSpringbootApplication {
 @Autowired
 Dog dog;//注入狗狗对象

 @Test
 void contextLoads() {
     System.out.println(dog);//输出狗狗信息
 }
}

5.测试运行，结果输出成功，@Value注入成功。

在这里插入图片描述

七、使用Maven构建多模块项目

7.1使用Maven构建多模块项目思路

创建父项目
父项目中不需要编写任何代码，可以把src目录删除
创建子模块，通常按职责划分子模块
- beans：存放实体类
- common：存放工具类、枚举类等项目中的核心类
- dao：存放数据访问层代码
- service：存放业务层代码
- controller：存放控制器层代码

7.2配置模块之间的依赖关系

在父项目中统一管理通用的依赖，子模块继承父项目
子模块之间可以直接线性依赖

Maven依赖有继承性和传递性

所谓继承：

即当B项目依赖A项目时，B项目可以继承A项目引入的全部依赖。除了这种情形外，在多模块项目中，子模块和父模块之间也存在继承关系，这类似于Java中的继承关系，即子模块会继承父项目中的全部依赖。

所谓传递:

即当B项目依赖A项目，C项目依赖B项目时，C项目除了可以继承B项目引入的依赖，还会继承A项目引入的依赖。

聚合：

对父项目进行Maven的操作，子模块也会进行同样的操作。即当对父项目打包时，所有的子项目都会打包。这种通过父项目来操作子项目进行Maven操作的情形，就叫聚合。注意：使用聚合时，父项目的pom文件中packaging 都是pom。

7.3模块之间的依赖关系配置

父项目pom文件片段配置代码示例：

<!-- 父项目pom文件片段 -->
<groupId>com.aiden</groupId>
<artifactId>parent</artifactId>
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>
<modules>
	<module>beans</module>
	<module>common</module>
	<module>dao</module>
	……
</modules>

子模块pom文件片段配置代码示例：

<!-- 子模块pom文件片段 -->
<parent>
	<artifactId>parent</artifactId>
	<groupId>com.aiden</groupId>
	<version>1.0-SNAPSHOT</version>
</parent>

7.4多模块项目常见问题

对于只是部分子模块会用到的依赖，不会放到父项目中

而由子模块分别引入某个依赖，可能产生版本不一致的问题

在父项目的pom文件中使用<dependencyManagement>标签管理依赖的版本号

<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>commons-logging</groupId>
			<artifactId>commons-logging</artifactId>
			<version>1.2</version>
		</dependency>
	</dependencies>
</dependencyManagement>