【SpringBoot】| Spring Boot 概述和入门程序剖析

╰+攻爆jí腚メ 2024-03-26 16:45 9阅读 0赞

**目录**

一：Spring Boot 入门

1. Spring能做什么？

2. SpringBoot特点

3. 如何学习SpringBoot

4. 创建Spring Boot项目

Maven的配置

入门案例：

SpringBoot中几个重要的注解

5. 了解自动配置原理

依赖管理

自动配置

6. SpringBoot核心配置文件

多环境测试

自定义配置

7. SpringBoot中使用JSP（了解）

8. SpringBoot中使用ApplicationContext（上下文对象）

9. CommandLineRunner接口 & ApplicationRunner接口

图书推荐：集齐“Java四大名著”召唤神龙

--------------------

## 一：Spring Boot 入门 ##

> SpringBoot是Spring家族中的一个成员， 可以简化Spring、SpringMVC的使用。它的核心还是IOC容器，底层是Spring！

### 1. Spring能做什么？ ###

**微服务：**将项目的工程拆分成一个个微小的功能模块，每一个微小的功能模块就是一个微服务。

>  *  微服务是一种架构风格；
>  *  一个应用拆分为一组小型服务；
>  *  每个服务运行在自己的进程内，也就是可独立部署和升级；
>  *  服务之间使用轻量级HTTP交互；
>  *  服务围绕业务功能拆分；
>  *  可以由全自动部署机制独立部署；
>  *  去中心化，服务自治。服务可以使用不同的语言、不同的存储技术；

**响应式：**基于异步非阻塞的方式，应用之间构建一个异步数据流的方式，异步数据流允许占用少量的线程资源，可以构建一个高吞吐量的开发。

**分布式、云开发：**将项目拆分成很多微小的服务就会产生分布式应用。

> **分布式的困难：**远程调用、服务发现、负载均衡、服务容错、配置管理、服务监控、链路追踪、日志管理、任务调度。
> 
> **分布式的困难：**SpringBoot + SpringCloud。

**无服务开发：**函数式开发，上到云平台。

**事件驱动：**构建一个实时的数据流，有了实时数据流就可以通过响应的方式，让系统占用少量的资源，完成高吞吐量的业务。

**批处理：**自动化任务。

![52e8aecb924743dea411b65f9b0ac2df.png][]

####  ####

### 2. SpringBoot特点 ###

**特点如下：**

> ①Create stand-alone Spring applications.
> 
> **解释：创建一个独立spring应用**（用SpringBoot实际上还是用spring，SpringBoot是一个高级框架，实际上底层是Spring）。
> 
> ②Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files).
> 
> **解释：内嵌Web服务器**，如：Tomcat、Jetty或Undertow服务器（无需部署WAR文件）。
> 
> ③Provide opinionated 'starter' dependencies to simplify your build configuration.
> 
> **解释：提供了starter起步依赖**，简化应用的配置。比如：使用MyBatis框架 ， 需要在Spring项目中，配置MyBatis的对象 SqlSessionFactory ， Dao的代理对象等；现在在SpringBoot项目中，在pom.xml里面, 只需要加入一个 mybatis-spring-boot-starter依赖，就表示上面两个等配置已经配置好了。
> 
> ④Automatically configure Spring and 3rd party libraries whenever possible.
> 
> **解释：****自动配置Spring以及第三方功能**（就是把spring中的，第三方库中的对象都提前创建好，放到容器中， 可以直接使用）。
> 
> ⑤Provide production-ready features such as metrics, health checks, and externalized configuration
> 
> **解释：提供生产级别的监控，健康检查及外部化配置**（以前修改了代码需要重新打包部署，现在可以实时监控变化）。
> 
> ⑥Absolutely no code generation and no requirement for XML configuration
> 
> **解释：不用生成代码， 不用使用xml做配置。**

####  ####

### 3. 如何学习SpringBoot ###

**SpringBoot的官方文档查找：**[Spring Boot][]

![d051e29e2814433d8e74f75ba15c1ff5.png][]

**SpringBoot的官网架构：**

![1de84c6872d5cea11c9d12ffad36c1e2.png][]

![77a40369d9952e0d191a42d81756f0e9.png][]

####  ####

**查看版本更新了什么新特性：** [Home · spring-projects/spring-boot Wiki · GitHub][Home _ spring-projects_spring-boot Wiki _ GitHub]

![de4b6397e94e46e782d3e95592fa486a.png][]

### 4. 创建Spring Boot项目 ###

#### **Maven的配置** ####

> 找到Maven的配置文件的settngs.xml配置，C:\\dev\\maven\_work\\apache-maven-3.3.9\\conf\\settings.xml，配置成阿里云的镜像和JDK编译的版本。

<mirrors>
          <mirror>
            <id>nexus-aliyun</id>
            <mirrorOf>central</mirrorOf>
            <name>Nexus aliyun</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public</url>
          </mirror>
      </mirrors>
     
      <profiles>
             <profile>
                  <id>jdk-1.8</id>
                  <activation>
                    <activeByDefault>true</activeByDefault>
                    <jdk>1.8</jdk>
                  </activation>
                  <properties>
                    <maven.compiler.source>1.8</maven.compiler.source>
                    <maven.compiler.target>1.8</maven.compiler.target>
                    <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
                  </properties>
             </profile>
      </profiles>

**第一种方式：[https://start.spring.io][https_start.spring.io]，使用国外的地址，必须联网**

①新建项目

![2bddd03e0d7d4204b4d96cad630ae26b.png][]

②设置基本信息

![f3da0d9eff644f049509f939f0e2184f.png][]

③选择依赖的列表

![f43e5210809d4a3890c354b4ed81b242.png][]

④项目的结构

![dbf68828b31e4b54a3f844522232e53a.png][]

⑤生成的pom.xml配置

<?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>3.0.3</version>
            <relativePath/>
        </parent>
        
        <groupId>com.zl</groupId>
        <artifactId>study-springboot-002</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>study-springboot-002</name>
        <description>study-springboot-002</description>
        
        <properties>
            <java.version>1.8</java.version>
        </properties>
        <dependencies>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            
            <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>

**第二种方式：**[https://start.springboot.io][https_start.springboot.io]**，使用国外的地址，必须联网，创建项目的步骤同上**

①对于其他版本的高版本的IDEA是以下界面

![acecb67a5d544f8e8b22f1432ffe2e85.png][]

②也可以在浏览器上直接输入[https://start.springboot.io][https_start.springboot.io] 进行设置

![d1190f80e8174bc687ab8814ae624cdc.png][]

③选择好以后，点击生成GENERATE，会下载一个压缩包

![f66505f604cd48df9787365980a9f4b4.png][]

④解压这个压缩包，就可以把项目导进去

![e517f5de7922492a924991d4fde218df.png][]

**第三种方式：使用 maven 向导创建项目**

**根据官方文档的提示：**[Getting Started][]

![437bba2b343740ab9042bb523f2ad195.png][]

①创建一个普通的Maven项目

![9a726fa3abaa4392b59cb6e66183b647.png][]

②手动添加父parent和web的依赖

> **添加父依赖：**spring-boot-start-parent作为【版本仲裁中心】 统一控制导入依赖的版本信息。
> 
> **web的依赖：**spring-boot-start-web用来写web项目的起步依赖。

③手动添加项目缺失的目录

![6a9966cce98347a9b3fce26ff6828150.png][]

#### **入门案例：** ####

**第一步：创建一个SpringBoot的web工程项目**

**第二步：创建一个Controller，发出请求**

注：在使用springmvc框架的时候，在处理json的时候需要用到spring框架特有的注解@ResponseBody或者@RestController注解，这两个注解都会处理返回的数据格式，使用了该类型注解后返回的不再是视图，不会进行转跳，而是返回json或xml数据格式，输出在页面上。

> ①**@ResponseBody注解**，一般是使用在单独的方法上的，需要哪个方法返回json数据格式，就在哪个方法上使用，具有针对性。
> 
> ②**@RestController复合注解**，一般是使用在类上的，它表示的意思其实就是结合了**@Controller和@ResponseBody两个注解**，如果哪个类下的所有方法需要返回json数据格式的，就在哪个类上使用该注解，具有统一性；需要注意的是，使用了@RestController注解之后，其本质相当于在该类的所有方法上都统一使用了@ResponseBody注解，所以该类下的所有方法都会返回json数据格式，输出在页面上，而不会再返回视图。

package com.zl.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    // 以下两个注解写成一个
    @RestController
    
    // @Controller // 类要想当做controller使用，就添加这个注解
    public class HelloSpringBoot {
        @RequestMapping("/hello")
        // @ResponseBody // 把返回的String字符串当做数据来用，返回给浏览器
        public String helloSpringBoot(){
            return "欢迎使用SpringBoot！";
        }
    }

**第三步：启动入口类**

> （1）这个类是自动生成的，也可以自己创建；使用@SpringBootApplication注解就表明这是一个SpringBoot项目！
> 
> （2）在类中编写main方法，方法中只写一行代码，调用SpringApplication类的静态run()方法，表示主方法跑起来：参数一个是当前类的.class、一个是主方法中的参数args。

**注：这个类的执行会启动内置的Tomcat服务器！**

package com.zl;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class Application {
    
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    
    }

**第四步：进行访问**

![a0e6daabc2344d44b311c03af7bcbedb.png][]

这里的端口号还可以在application.properties中进行更改

![0b7c817939f74a49878a1fcd18783d87.png][]

**第五步：创建一个可执行的jar包（简化了部署）**

> 默认的打包方式是jar包，对于web应用我们需要写上打包方式为war包，然后部署到Tomcat服务器上进行应用。现在可以通过一个插件直接就打成jar包，进行运行！

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

①找到生命周期进行打包

![23f6c131fc1944e8afbd644188c383ae.png][]

②得到以下.jar文件

![f6bfba0dd5e54dd8bfee7a27c6814857.png][]

③找到.jar文件的位置，使用cmd命令行执行打包的jar文件

![d15ba0979814482398731682d9d4179d.png][]

④ 使用java -jar \*.jar就可以运行

![eb912bada6c34c48b380bd09f5ce9550.png][]

#### **SpringBoot中几个重要的注解** ####

> **①@SpringBootApplication注解：** @SpringBootApplication注解其实是一个复合注解，是由 @SpringBootConfiguration注解、@EnableAutoConfiguration注解、@ComponentScan 联合在一起组成的；从源码中就可以看出：

![0c2d32c0a19e46a1a7258db21b85e949.png][]

> **②@SpringBootConfiguration注解：** 这个注解就是@Configuration这个注解的功能，使用@SpringBootConfiguration这个**注解的类就是当做配置文件作用**，从源码中就可以看出：

![d97acb38b3c04c3eba2dc3cad640d267.png][]

**注：**既然有@Configuration功能，结合@Bean注解，就可以把一个对象放到Spring容器当中

package com.zl;
    
    import com.zl.controller.Student;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.Bean;
    
    @SpringBootApplication
    public class Application {
    
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    
        // 声明对象，把这个对象注入到Spring容器当中
        @Bean
        public Student myStudent(){
            return new Student();
        }
    
    }

> **③@EnableAutoConfiguration注解：**启用自动配置， 把java对象配置好，注入到spring容器中。例如：可以把mybatis的对象创建好，放入到容器中。

> **④@ComponentScan注解：**组件扫描器， 扫描注解，根据注解的功能，创建java bean，给属性赋值等。组件扫描器默认扫描的包是 @ComponentScan 注解所在的类， 类所在的包和子包。 所以对于带有@SpringBootApplication注解的入口类Application建议放在主包下！

### 5. 了解自动配置原理 ###

#### **依赖管理** ####

> 例如：我们引入父依赖后并写上版本号，后面在引入其它依赖（实际上采用了自动版本仲裁机制），就不需要写版本号，此时就是父依赖作为依赖管理！

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
      </parent>
      
      <dependencies>
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

实际上spring-boot-start-parent的父项目是spring-boot-dependencies

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.3.4.RELEASE</version>
      </parent>

点进去spring-boot-dependencies找到properties属性几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制！

<properties>
        <activemq.version>5.15.13</activemq.version>
        <antlr2.version>2.7.7</antlr2.version>
        <appengine-sdk.version>1.9.82</appengine-sdk.version>
        <artemis.version>2.12.0</artemis.version>
        <aspectj.version>1.9.6</aspectj.version>
        <assertj.version>3.16.1</assertj.version>
        <atomikos.version>4.0.6</atomikos.version>
        <awaitility.version>4.0.3</awaitility.version>
        <bitronix.version>2.1.4</bitronix.version>
        <build-helper-maven-plugin.version>3.1.0</build-helper-maven-plugin.version>
        <byte-buddy.version>1.10.14</byte-buddy.version>
        <caffeine.version>2.8.5</caffeine.version>
        <cassandra-driver.version>4.6.1</cassandra-driver.version>
        <classmate.version>1.5.1</classmate.version>
        <commons-codec.version>1.14</commons-codec.version>
        <commons-dbcp2.version>2.7.0</commons-dbcp2.version>
        <commons-lang3.version>3.10</commons-lang3.version>
        <commons-pool.version>1.6</commons-pool.version>
        <commons-pool2.version>2.8.1</commons-pool2.version>
        <couchbase-client.version>3.0.8</couchbase-client.version>
        <db2-jdbc.version>11.5.4.0</db2-jdbc.version>
        <dependency-management-plugin.version>1.0.10.RELEASE</dependency-management-plugin.version>
        <derby.version>10.14.2.0</derby.version>
        <dropwizard-metrics.version>4.1.12.1</dropwizard-metrics.version>
        <ehcache.version>2.10.6</ehcache.version>
        <ehcache3.version>3.8.1</ehcache3.version>
        <elasticsearch.version>7.6.2</elasticsearch.version>
        <embedded-mongo.version>2.2.0</embedded-mongo.version>
        <exec-maven-plugin.version>1.6.0</exec-maven-plugin.version>
        <flatten-maven-plugin.version>1.2.5</flatten-maven-plugin.version>
        <flyway.version>6.4.4</flyway.version>
        <freemarker.version>2.3.30</freemarker.version>
        <git-commit-id-plugin.version>3.0.1</git-commit-id-plugin.version>
        <glassfish-el.version>3.0.3</glassfish-el.version>
        <glassfish-jaxb.version>2.3.3</glassfish-jaxb.version>
        <groovy.version>2.5.13</groovy.version>
        <gson.version>2.8.6</gson.version>
        <h2.version>1.4.200</h2.version>
        <hamcrest.version>2.2</hamcrest.version>
        <hazelcast.version>3.12.9</hazelcast.version>
        <hazelcast-hibernate5.version>1.3.2</hazelcast-hibernate5.version>
        <hibernate.version>5.4.21.Final</hibernate.version>
        <hibernate-validator.version>6.1.5.Final</hibernate-validator.version>
        <hikaricp.version>3.4.5</hikaricp.version>
        <hsqldb.version>2.5.1</hsqldb.version>
        <htmlunit.version>2.40.0</htmlunit.version>
        <httpasyncclient.version>4.1.4</httpasyncclient.version>
        <httpclient.version>4.5.12</httpclient.version>
        <httpcore.version>4.4.13</httpcore.version>
        <infinispan.version>10.1.8.Final</infinispan.version>
        <influxdb-java.version>2.18</influxdb-java.version>
        <jackson-bom.version>2.11.2</jackson-bom.version>
        <jakarta-activation.version>1.2.2</jakarta-activation.version>
        <jakarta-annotation.version>1.3.5</jakarta-annotation.version>
        <jakarta-jms.version>2.0.3</jakarta-jms.version>
        <jakarta-json.version>1.1.6</jakarta-json.version>
        <jakarta-json-bind.version>1.0.2</jakarta-json-bind.version>
        <jakarta-mail.version>1.6.5</jakarta-mail.version>
        <jakarta-persistence.version>2.2.3</jakarta-persistence.version>
        <jakarta-servlet.version>4.0.4</jakarta-servlet.version>
        <jakarta-servlet-jsp-jstl.version>1.2.7</jakarta-servlet-jsp-jstl.version>
        <jakarta-transaction.version>1.3.3</jakarta-transaction.version>
        <jakarta-validation.version>2.0.2</jakarta-validation.version>
        <jakarta-websocket.version>1.1.2</jakarta-websocket.version>
        <jakarta-ws-rs.version>2.1.6</jakarta-ws-rs.version>
        <jakarta-xml-bind.version>2.3.3</jakarta-xml-bind.version>
        <jakarta-xml-soap.version>1.4.2</jakarta-xml-soap.version>
        <jakarta-xml-ws.version>2.3.3</jakarta-xml-ws.version>
        <janino.version>3.1.2</janino.version>
        <javax-activation.version>1.2.0</javax-activation.version>
        <javax-annotation.version>1.3.2</javax-annotation.version>
        <javax-cache.version>1.1.1</javax-cache.version>
        <javax-jaxb.version>2.3.1</javax-jaxb.version>
        <javax-jaxws.version>2.3.1</javax-jaxws.version>
        <javax-jms.version>2.0.1</javax-jms.version>
        <javax-json.version>1.1.4</javax-json.version>
        <javax-jsonb.version>1.0</javax-jsonb.version>
        <javax-mail.version>1.6.2</javax-mail.version>
        <javax-money.version>1.0.3</javax-money.version>
        <javax-persistence.version>2.2</javax-persistence.version>
        <javax-transaction.version>1.3</javax-transaction.version>
        <javax-validation.version>2.0.1.Final</javax-validation.version>
        <javax-websocket.version>1.1</javax-websocket.version>
        <jaxen.version>1.2.0</jaxen.version>
        <jaybird.version>3.0.9</jaybird.version>
        <jboss-logging.version>3.4.1.Final</jboss-logging.version>
        <jboss-transaction-spi.version>7.6.0.Final</jboss-transaction-spi.version>
        <jdom2.version>2.0.6</jdom2.version>
        <jedis.version>3.3.0</jedis.version>
        <jersey.version>2.30.1</jersey.version>
        <jetty-el.version>8.5.54</jetty-el.version>
        <jetty-jsp.version>2.2.0.v201112011158</jetty-jsp.version>
        <jetty-reactive-httpclient.version>1.1.4</jetty-reactive-httpclient.version>
        <jetty.version>9.4.31.v20200723</jetty.version>
        <jmustache.version>1.15</jmustache.version>
        <johnzon.version>1.2.8</johnzon.version>
        <jolokia.version>1.6.2</jolokia.version>
        <jooq.version>3.13.4</jooq.version>
        <json-path.version>2.4.0</json-path.version>
        <json-smart.version>2.3</json-smart.version>
        <jsonassert.version>1.5.0</jsonassert.version>
        <jstl.version>1.2</jstl.version>
        <jtds.version>1.3.1</jtds.version>
        <junit.version>4.13</junit.version>
        <junit-jupiter.version>5.6.2</junit-jupiter.version>
        <kafka.version>2.5.1</kafka.version>
        <kotlin.version>1.3.72</kotlin.version>
        <kotlin-coroutines.version>1.3.8</kotlin-coroutines.version>
        <lettuce.version>5.3.4.RELEASE</lettuce.version>
        <liquibase.version>3.8.9</liquibase.version>
        <log4j2.version>2.13.3</log4j2.version>
        <logback.version>1.2.3</logback.version>
        <lombok.version>1.18.12</lombok.version>
        <mariadb.version>2.6.2</mariadb.version>
        <maven-antrun-plugin.version>1.8</maven-antrun-plugin.version>
        <maven-assembly-plugin.version>3.3.0</maven-assembly-plugin.version>
        <maven-clean-plugin.version>3.1.0</maven-clean-plugin.version>
        <maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
        <maven-dependency-plugin.version>3.1.2</maven-dependency-plugin.version>
        <maven-deploy-plugin.version>2.8.2</maven-deploy-plugin.version>
        <maven-enforcer-plugin.version>3.0.0-M3</maven-enforcer-plugin.version>
        <maven-failsafe-plugin.version>2.22.2</maven-failsafe-plugin.version>
        <maven-help-plugin.version>3.2.0</maven-help-plugin.version>
        <maven-install-plugin.version>2.5.2</maven-install-plugin.version>
        <maven-invoker-plugin.version>3.2.1</maven-invoker-plugin.version>
        <maven-jar-plugin.version>3.2.0</maven-jar-plugin.version>
        <maven-javadoc-plugin.version>3.2.0</maven-javadoc-plugin.version>
        <maven-resources-plugin.version>3.1.0</maven-resources-plugin.version>
        <maven-shade-plugin.version>3.2.4</maven-shade-plugin.version>
        <maven-source-plugin.version>3.2.1</maven-source-plugin.version>
        <maven-surefire-plugin.version>2.22.2</maven-surefire-plugin.version>
        <maven-war-plugin.version>3.2.3</maven-war-plugin.version>
        <micrometer.version>1.5.5</micrometer.version>
        <mimepull.version>1.9.13</mimepull.version>
        <mockito.version>3.3.3</mockito.version>
        <mongodb.version>4.0.5</mongodb.version>
        <mssql-jdbc.version>7.4.1.jre8</mssql-jdbc.version>
        <mysql.version>8.0.21</mysql.version>
        <nekohtml.version>1.9.22</nekohtml.version>
        <neo4j-ogm.version>3.2.16</neo4j-ogm.version>
        <netty.version>4.1.52.Final</netty.version>
        <netty-tcnative.version>2.0.34.Final</netty-tcnative.version>
        <nio-multipart-parser.version>1.1.0</nio-multipart-parser.version>
        <oauth2-oidc-sdk.version>7.1.1</oauth2-oidc-sdk.version>
        <nimbus-jose-jwt.version>8.19</nimbus-jose-jwt.version>
        <ojdbc.version>19.3.0.0</ojdbc.version>
        <okhttp3.version>3.14.9</okhttp3.version>
        <oracle-database.version>19.3.0.0</oracle-database.version>
        <pooled-jms.version>1.1.2</pooled-jms.version>
        <postgresql.version>42.2.16</postgresql.version>
        <prometheus-pushgateway.version>0.9.0</prometheus-pushgateway.version>
        <quartz.version>2.3.2</quartz.version>
        <querydsl.version>4.3.1</querydsl.version>
        <r2dbc-bom.version>Arabba-SR7</r2dbc-bom.version>
        <rabbit-amqp-client.version>5.9.0</rabbit-amqp-client.version>
        <reactive-streams.version>1.0.3</reactive-streams.version>
        <reactor-bom.version>Dysprosium-SR12</reactor-bom.version>
        <rest-assured.version>3.3.0</rest-assured.version>
        <rsocket.version>1.0.2</rsocket.version>
        <rxjava.version>1.3.8</rxjava.version>
        <rxjava-adapter.version>1.2.1</rxjava-adapter.version>
        <rxjava2.version>2.2.19</rxjava2.version>
        <saaj-impl.version>1.5.2</saaj-impl.version>
        <selenium.version>3.141.59</selenium.version>
        <selenium-htmlunit.version>2.40.0</selenium-htmlunit.version>
        <sendgrid.version>4.4.8</sendgrid.version>
        <servlet-api.version>4.0.1</servlet-api.version>
        <slf4j.version>1.7.30</slf4j.version>
        <snakeyaml.version>1.26</snakeyaml.version>
        <solr.version>8.5.2</solr.version>
        <spring-amqp.version>2.2.11.RELEASE</spring-amqp.version>
        <spring-batch.version>4.2.4.RELEASE</spring-batch.version>
        <spring-data-releasetrain.version>Neumann-SR4</spring-data-releasetrain.version>
        <spring-framework.version>5.2.9.RELEASE</spring-framework.version>
        <spring-hateoas.version>1.1.2.RELEASE</spring-hateoas.version>
        <spring-integration.version>5.3.2.RELEASE</spring-integration.version>
        <spring-kafka.version>2.5.6.RELEASE</spring-kafka.version>
        <spring-ldap.version>2.3.3.RELEASE</spring-ldap.version>
        <spring-restdocs.version>2.0.5.RELEASE</spring-restdocs.version>
        <spring-retry.version>1.2.5.RELEASE</spring-retry.version>
        <spring-security.version>5.3.4.RELEASE</spring-security.version>
        <spring-session-bom.version>Dragonfruit-SR1</spring-session-bom.version>
        <spring-ws.version>3.0.10.RELEASE</spring-ws.version>
        <sqlite-jdbc.version>3.31.1</sqlite-jdbc.version>
        <sun-mail.version>1.6.5</sun-mail.version>
        <thymeleaf.version>3.0.11.RELEASE</thymeleaf.version>
        <thymeleaf-extras-data-attribute.version>2.0.1</thymeleaf-extras-data-attribute.version>
        <thymeleaf-extras-java8time.version>3.0.4.RELEASE</thymeleaf-extras-java8time.version>
        <thymeleaf-extras-springsecurity.version>3.0.4.RELEASE</thymeleaf-extras-springsecurity.version>
        <thymeleaf-layout-dialect.version>2.4.1</thymeleaf-layout-dialect.version>
        <tomcat.version>9.0.38</tomcat.version>
        <unboundid-ldapsdk.version>4.0.14</unboundid-ldapsdk.version>
        <undertow.version>2.1.4.Final</undertow.version>
        <versions-maven-plugin.version>2.7</versions-maven-plugin.version>
        <webjars-hal-browser.version>3325375</webjars-hal-browser.version>
        <webjars-locator-core.version>0.45</webjars-locator-core.version>
        <wsdl4j.version>1.6.3</wsdl4j.version>
        <xml-maven-plugin.version>1.0.2</xml-maven-plugin.version>
        <xmlunit2.version>2.7.0</xmlunit2.version>
      </properties>

如果此时需要换版本号怎们办呢？

> 查看spring-boot-dependencies里面规定当前依赖的版本 用的 key。就是用上面的properties标签对应的属性进行重写；实际上使用的是就近原则！

开发导入starter场景启动器

> （1）见到很多**spring-boot-starter-\***： \*就某种场景；官方的启动器，只要引入starter，这个场景的所有常规需要的依赖我们都自动引入！SpringBoot所有支持的场景：[Developing with Spring Boot][]  
> （2）见到的 **\*-spring-boot-starter**： 第三方为我们提供的简化开发的场景启动器。  
> （3）所有场景启动器（start）最底层的依赖是spring-boot-start

<dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter</artifactId>
          <version>2.3.4.RELEASE</version>
          <scope>compile</scope>
        </dependency>

#### 自动配置 ####

> 我们直接执行启动类就可以访问，实际上是自动进行了一系列的配置！

①自动配好Tomcat

> （1）引入Tomcat依赖；
> 
> （2）配置Tomcat；

②自动配好SpringMVC常见功能，如：前端控制器DispatcherServlet、字符编码问题CharaterEncodingFilter、视图解析器ViewResolver

> （1）引入SpringMVC全套组件；实际上启动类的SpringBootApplication类的静态方法放回的是IOC容器，通过这个IOC容器的getBeanDefinitionNames方法就可以查看容器里面的组件！
> 
> （2）自动配好SpringMVC常用组件（功能）；

package com.zl;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.ConfigurableApplicationContext;
    
    
    @SpringBootApplication
    public class MyApplication {
        public static void main(String[] args) {
            // 实际上返回的是IOC容器
            ConfigurableApplicationContext applicationContext = SpringApplication.run(MyApplication.class, args);
            // 查看容器里面的组件
            String[] names = applicationContext.getBeanDefinitionNames();
            for (String name : names) {
                System.aout.println(name);
            }
        }
    }

③默认的包结构

> （1）**主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来**，不需要以前的包扫描配置；
> 
> （2）要想改变扫描路径，使用@SpringBootApplication注解的scanBasePackages属性去指定(scanBasePackages=**"com.zl"**)，或者使用@ComponentScan注解指定扫描路径；
> 
> （3）@SpringBootApplication是一个复合注解等同于以下三个注解：

@SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan("com.zl")

④按需加载所有自动配置项

> （1）在实际上开发中有非常多的场景（start），引入了哪些场景这个场景的自动配置才会开启；
> 
> （2）SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面；

### 6. SpringBoot核心配置文件 ###

> 配置文件名称是：**application**，扩展名有：**properties、yml**；例如：**application.properties或者application.yml。**

**注：**使用**properties扩展**名配置是**key=value**的格式，使用**yml扩展**名配置是**key:value**的格式

第一步：创建一个controller

package com.zl.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    @Controller
    public class SpringController {
        @RequestMapping("/spring")
        @ResponseBody
        public String doSome(){
            return "hello SpringBoot";
        }
    }

第二步：创建启动类，对于启动类我们可以删除自动生成的，自己手写一个

> ①类名随意，里面有一个主方法，在主方法中调用SpringApplication的run方法，一个参数是本类.class，另一个参数是上面main方法的参数args。
> 
> ②给本类增加上@SpringBootApplication注解。

package com.zl;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class MyApplication {
        public static void main(String[] args) {
            SpringApplication.run(MyApplication.class,args);
        }
    }

第三步：使用application.properties/yml配置文件，配置端口号、上下文的路径等

①采用默认的

![48df0fed63d145d78ba9d88612bd1f48.png][]

②自己进行配置application.properties，\#代表注释

#设置端口号
    server.port=8082
    #设置访问应用上下文路径，contextpath
    server.servlet.context-path=/myboot

![fc05da12dd7f456c9606a417af157b1f.png][]

③使用yml的配置方式，application.yml

> yml是一种yaml格式的配置文件，主要采用一定的空格、换行等格式排版进行配置。 yaml是一种直观的能够被计算机识别的的数据序列化格式，容易被人类阅读，yaml 类似于xml，但是语法比xml 简洁很多，**值与前面的冒号配置项必须要有一个空格**， yml 缀也可以使用 yaml 后缀。

server:
      port: 8082
      servlet:
        context-path: /myboot

**注意：** 当两种格式配置文件同时存在，**默认使用的是properties**，在SpringBoot2.4开始，使用的是yml配置文件，**推荐使用 yml格式配置文件**。

#### **多环境测试** ####

> 在实际开发的过程中，我们的项目会经历很多的阶段（开发->测试->上线），每个阶段的配置也会不同，例如：端口、上下文根、数据库等，那么这个时候为了方便在不同的环境之间切换，SpringBoot 提供了多环境配置，具体步骤如下：

**注：**为每个环境创建一个配置文件，命名必须以**application-环境标识.properties**或**yml**！

开发环境application-dev.properties：

#配置端口号
    server.port=8081
    #配置应用根路径
    server.servlet.context-path=/mydev

测试环境application-test.properties：

#配置端口号
    server.port=8082
    #配置应用根路径
    server.servlet.context-path=/mytest

上线环境application-onlion.properties：

#配置端口号
    server.port=8083
    #配置应用根路径
    server.servlet.context-path=/myonlion

在application.properties中指定要使用的配置文件

#激活使用哪个配置文件
    spring.profiles.active=dev
    spring.profiles.active=test
    spring.profiles.active=onlion

#### **自定义配置** ####

（1）@Value注解

> 注：在application.properties中添加自定义的配置项，然后在类中需要时，使用**@Value($\{变量名\})**注解进行引入。

application.properties配置

#配置端口号
    server.port=8082
    #context-path
    server.servlet.context-path=/myboot
    
    #自定义key=value
    school.name=大连大学
    school.website=www.baidu.com
    school.address=辽宁省大连市
    
    site=www.sina.com.cn

在controller中联合@Value注解获取数据

> 注：这例也可以使用@ConfigurationProperties注解指定配置的前缀，后缀与实体类的属性名相同也可以完成属性的赋值。

package com.zl.controller;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    @Controller
    public class DataController {
    
        // 定义变量接收赋值
        @Value("${server.port}")
        private Integer port;
        @Value("${server.servlet.context-path}")
        private String contextPath;
        // 自定义的
        @Value("${school.name}")
        private String name;
        @Value("${site}")
        private String site;
    
    
        @RequestMapping("/data")
        @ResponseBody
        public String queryData(){
            return name+","+site+",项目访问的地址"+contextPath+",使用的端口"+port;
        }
    }

执行结果：

![c0b2dd4bc25a42b5b693b51110051326.png][]

（2）@ConfigurationProperties注解

> 前面我们是一个个取出值，现在我们将整个文件映射成一个Java对象，用于自定义配置项比较多的情况！

**工作原理：**定义一个类使用@ConfigurationProperties注解，并指定前缀prefix，它会根据这个前缀到配置中找以这个前缀开头的属性；如果以这个前缀开头的后面的属性与我们定义的Java对象的属性相同就赋上值！

定义一个School类

> **关键点：配置文件的数据与School类中的属性怎么对应上？**
> 
> 使用@ConfigurationProperties注解，指定一个前缀！

package com.zl.vo;
    
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    
    @Component // 创建对象
    @ConfigurationProperties(prefix = "school") // 把school开头的配置项找出来
    public class School {
        private String name;
        private String website;
        private String address;
    
        public School() {
        }
        public School(String name, String website, String address) {
            this.name = name;
            this.website = website;
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "School{" +
                    "name='" + name + '\'' +
                    ", website='" + website + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getWebsite() {
            return website;
        }
    
        public void setWebsite(String website) {
            this.website = website;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    }

进行测试：

package com.zl.controller;
    
    import com.zl.vo.School;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import javax.annotation.Resource;
    
    @Controller
    public class DataController {
    
        @Resource // 赋值
        private School school;
    
        @RequestMapping("/school")
        @ResponseBody
        public School querySchool(){
            return school;
        }
    }

执行结果：

![e839c055480d4e87b32a6a813af4726c.png][]

实际上还有一个报错信息，让我们添加一个依赖，当然不添加也不影响的项目的正常运行

![b2d6b2f1220f4cadb1dacc80150e0090.png][]

添加以下依赖

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>

### **7. SpringBoot中使用JSP（了解）** ###

> SpringBoot不推荐使用jsp ，而是使用模板技术代替jsp，作为视图来使用！

**使用jsp需要配置：**

①加入一个处理jsp的依赖， 负责编译jsp文件

<dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-jasper</artifactId>
    </dependency>

②如果需要使用servlet， jsp，jstl的功能，还需要加对应的依赖

<dependency>
    	<groupId>javax.servlet</groupId>
    	<artifactId>jstl</artifactId>
    </dependency>
    
    <dependency>
    	<groupId>javax.servlet</groupId>
    	<artifactId>javax.servlet-api</artifactId>
    </dependency>
    
    <dependency>
    <groupId>javax.servlet.jsp</groupId>
    	<artifactId>javax.servlet.jsp-api</artifactId>
    	<version>2.3.1</version>
    </dependency>

③在resources下创建一个存放jsp的目录，一般叫做webapp，这个目录默认是不能创建jsp文件，需要我们手动更改webapp目录的属性

![cc73db237df64ed188a9e7fb70ee9b62.png][]

编写index.jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>index.jsp</title>
    </head>
    <body>
    <h1>使用jsp显示Controller中的数据${data}</h1>
    </body>
    </html>

④需要在pom.xml指定jsp文件编译后的存放目录；META-INF/resources（固定的）

<build>
            
            <resources>
                <resource>
                    
                    <directory>src/main/webapp</directory>
                    
                    <targetPath>META-INF/resources</targetPath>
                    
                    <includes>
                        
                        <include>**/*.*</include>
                    </includes>
                </resource>
            </resources>
    
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>

⑤创建Controller， 访问jsp

package com.zl.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    import javax.servlet.http.HttpServletRequest;
    
    
    @Controller
    public class JspController {
        // 方法一：使用HttpServletRequest对象
        /*public String doJsp(HttpServletRequest request){
            request.setAttribute("data","SpringBoot使用JSP进行显示");
            // 返回视图的逻辑名称
            return  "index";
        }*/
        // 方法二：使用Model对象
        @RequestMapping("/myjsp")
        public String doJsp(Model model){
            model.addAttribute("data","SpringBoot使用JSP进行显示");
            // 返回视图的逻辑名称
            return  "index";
        }
    }

⑥在application.propertis文件中配置视图解析器

#配置端口号
    server.port=9090
    #配置context-path
    server.servlet.context-path=/myboot
    #配置视图解析器
    # / 就是src/main/webapp
    spring.mvc.view.prefix=/
    spring.mvc.view.suffix=.jsp

### 8. SpringBoot中使用ApplicationContext（上下文对象） ###

> 怎么使用容器对象？要想从容器中获取对象，通过SpringApplication.run(Application.class, args); 返回值获取容器，返回值类型是什么呢？通过源码分析：

先定位到SpringApplication的run方法

![f266b170904349079179cba0a2437a01.png][]

run方法的返回值是ConfigurableApplicationContext接口

![9e784fc49c724db495c4f3dac2457df4.png][]

ConfigurableApplicationContext接口继承ApplicationContext接口

![30f73559b01c42fbb1881fe6eddb2bc1.png][]

所以**run方法**的**返回值**其实就是一个**ApplicationContext容器（**Spring容器中创建ClassPathXmlApplicationContext对象时，返回的结果就是ApplicationContext\[是ClassPathXmlApplicationContext的父类\]，然后调用getBean方法就能获取对象**）**！

**案例：在main方法中使用SpringApplication.run()方法获取返回的Spring容器上下文对象，再调用getBean()方法进行调用！**

创建一个UserService 接口：

package com.zl.service;
    
    public interface UserService {
        void sayHello(String name);
    }

编写UserService接口的实现类：

package com.zl.service.impl;
    
    import com.zl.service.UserService;
    import org.springframework.stereotype.Service;
    
    @Service("userService") // 交给Spring容器管理
    public class UserServiceImpl implements UserService {
        @Override
        public void sayHello(String name) {
            System.out.println("对"+name+"说sayHello");
        }
    }

在入口方法中取出被Spring容器管理的UserServiceImpl 类：

package com.zl;
    
    import com.zl.service.UserService;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ConfigurableApplicationContext;
    
    @SpringBootApplication
    public class Application {
        public static void main(String[] args) {
            // 返回一个ConfigurableApplicationContext接口容器或者父接口的
            // ConfigurableApplicationContext cac = SpringApplication.run(Application.class, args);
            ApplicationContext cac = SpringApplication.run(Application.class, args);
            // 调用getBean方法，获取交给Spring容器管理的对象
            UserService userService = cac.getBean("userService", UserService.class);
            // 方法的调用
            userService.sayHello("张三");
        }
    }

执行结果：

![ae1622da6e01449eb430d4365380b958.png][]

### 9. CommandLineRunner接口 & ApplicationRunner接口 ###

> （1）开发中可能会有这样的情景：需要在容器启动后执行一些内容；比如：读取配置文件，数据库连接之类的；SpringBoot 给我们提供了两个接口来帮助我们实现这种需求，这两个接口分别为**CommandLineRunner**和 **ApplicationRunner**，它们的**执行时机为容器启动完成的时候（容器对象创建好后，自动执行run方法）**。
> 
> （2）这**两个接口中有一个run()方法**，我们**只需要实现这个方法**即可。
> 
> （3）这两个接口的不同之处在于：ApplicationRunner中run()方法的参数为**ApplicationArguments**，而CommandLineRunner接口中run方法的参数为**String 数组**。

ApplicationRunner接口

package org.springframework.boot;
    
    @FunctionalInterface
    public interface ApplicationRunner {
        void run(ApplicationArguments args) throws Exception;
    }

CommandLineRunner接口

package org.springframework.boot;
    
    @FunctionalInterface
    public interface CommandLineRunner {
        void run(String... args) throws Exception;
    }

案例：

编写SomeService接口

package com.zl.service;
    
    public interface SomeService {
        String doSome(String name);
    }

编写SomeService接口的实现类SomeServiceImpl

package com.zl.service.impl;
    
    import com.zl.service.SomeService;
    import org.springframework.stereotype.Service;
    
    @Service("someService") // 交给Spring容器管理
    public class SomeServiceImpl implements SomeService {
        @Override
        public String doSome(String name) {
            return  name+"----》去打篮球了！";
        }
    }

让启动口类Application实现CommandLineRunner接口，并重写run()方法

package com.zl;
    
    import com.zl.service.SomeService;
    import org.springframework.boot.CommandLineRunner;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    
    @SpringBootApplication
    public class Application implements CommandLineRunner {
    
        @Resource // 下面容器创建好以后就会给属性赋值
        private SomeService someService;
    
        public static void main(String[] args) {
            System.out.println("准备创建容器对象"); // 1
    
            // 创建容器对象
            SpringApplication.run(Application.class, args);
    
            System.out.println("容器对象创建好之后"); // 3
        }
    
        @Override
        public void run(String... args) throws Exception {
            // 在这个run方法里做自定义的操作
            System.out.println("容器对象创建好，马上执行的！"); // 2
    
            // 调用容器中对象的方法
            // 在这里执行，已经保证1的容器对象创建好了
            String str = someService.doSome("张大傻");
            System.out.println(str);
        }
    }

执行顺序结果：

![2cd246de28c44a32ab937ec7f07361c3.png][]

## **图书推荐：集齐“Java四大名著”召唤神龙** ##

> **Java 28岁了，当打之年，并且还会打很多年。为即将或正在使用Java的你推荐Java“此生错过必遗憾”系列书单。看看你还缺哪本？请补齐。优惠购书链接就在文中，拿好不谢！**

**1. Java****核心技术第****12****版开发基础****+****高级特性**

> “Java四大名著”之一Core Java最新版，一键打包全套2册！建议入门小白和准备升级到Java17的开发者购买。本书根据Java17新特性全面升级！赠送作者亲授视频课+海量代码集。

![bab22121620b4c2b90735a0eeded5210.png][]

**限时秒杀链接：**[点击购买][Link 1]

**2. Java核心技术第11版基础知识+高级特性**

> “Java四大名著”之一Core Java次新版，一键打包全套2册！建议实际生产环境仍在使用Java8、Java11开发且暂时没有升级版本打算的开发者购买。本书基于Java9-11编写，赠送作者亲授视频课+海量代码集。

![945ccccffed348cba966dd981edc0d4d.png][]

**限时秒杀链接：**[点击购买][Link 2]

**3. Java编程思想\[Thinking in Java\]**

> “Java四大名著”之一，需要有一定编程基础的人才可阅读，即使很多内容还无法理解，但每次读完一定会有所收获。本书单最前面推荐的《Java核心技术》侧重技术，而《Java编程思想》侧重于“思想”，本书为你剖析Java中各个内容的设计理念。这是一本伴随我们技术成长的好书，买一本放在旁边，摸着就有底气。

![f4597889901141629cb14aa962839c01.png][]

**限时秒杀链接：**[点击购买][Link 3]

**4. Effective Java 中文版（原书第3版）**

> “Java四大名著”之一，适合已经掌握Java核心技术的程序员，想更加深入地了解Java编程语言的开发者阅读。针对如何编写高效、设计优良的程序提出了最实用、最权威的指导方针，通过90条简短、独立的经验法则，探索新的设计模式和语言习惯用法，帮你更加有效地使用Java编程语言及其基本类库，指引你少走弯路。这些经验规则涵盖了大多数开发人员每天所面临的问题的解决方案。是Java开发人员案头上的一本不可或缺的参考书。

![9b871a3b2a65409581ed2592e40d9ce1.png][]

**限时秒杀链接：**[点击购买][Link 4]

**5. Java语言程序设计基础篇+进阶篇**

> 本套书相较于《Java核心技术》更加的基础，如果你阅读《Java核心技术》有些吃力，建议从本书读起。畅销20余年的“长城书”一键打包全套！被世界各地的大学选作教材，更新至Java9、10和11。本书通过示例讲解问题求解技巧，提供大量的程序清单，每章配有丰富的复习题和编程练习题，帮助读者掌握编程技术并解决实际开发中遇到的问题。

![51e0a7f328bb46da8c96f7fa6139ac13.png][]

**限时秒杀链接：**[点击购买][Link 5]

**6. Java****并发编程实战**

> 让注重实战的你更快领悟Java并发编程的要领，快速构建大规模并发应用程序。“Java四大名著”之一《Effective Java》的作者Joshua Bloch参与编写。本书是Java并发编程领域的里程碑著作！从并发编程的基本理论入手，逐步介绍了在设计Java并发程序时各种重要的设计原则、设计模式与思维模式。另一本蚂蚁金服方腾飞老师写的《Java并发编程的艺术》也适合一并阅读。

![53887cbf3d124f9c88698e265aabd8a6.png][]

**限时秒杀链接：**[点击购买][Link 6]

**7.** **软件架构实践**

> 让你少走弯路的进阶架构师避坑指南！图书届奥斯卡Jolt大奖双冠王作品！全球10余个国出版。卡内基梅隆等名校教材，IEEE杂志10佳图书，软件架构图书事实标准。

![1d2e579413654c4688bb9583b7a091d0.png][]

**限时秒杀链接：**[点击购买][Link 7]

> 以上图书当当网全部限时秒杀，满100-50，买的越多，优惠越多！了解更多好书点击：[Core Java 全面升级！][Core Java]

[52e8aecb924743dea411b65f9b0ac2df.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/0e60dc17804749eb8e41edfb61c3739b.png
[Spring Boot]: https://spring.io/projects/spring-boot#learn
[d051e29e2814433d8e74f75ba15c1ff5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/74f2ef2fe307499b97e166640a370389.png
[1de84c6872d5cea11c9d12ffad36c1e2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/a482e7c378e042e0ab3705bc49c50f7d.png
[77a40369d9952e0d191a42d81756f0e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/e66794e243e74d55a78e84639d9ff9ef.png
[Home _ spring-projects_spring-boot Wiki _ GitHub]: https://github.com/spring-projects/spring-boot/wiki#release-notes
[de4b6397e94e46e782d3e95592fa486a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/c19d85c9b0be4515b481173ff78a16a5.png
[https_start.spring.io]: https://start.spring.io
[2bddd03e0d7d4204b4d96cad630ae26b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/666eba9e0eec4c3faa406c1b4bc94e29.png
[f3da0d9eff644f049509f939f0e2184f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/8f90dae1eba047b9808cf23dc777daed.png
[f43e5210809d4a3890c354b4ed81b242.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/cb610e640d5848fc867dcfa3be63990b.png
[dbf68828b31e4b54a3f844522232e53a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/6c6a505af34445ceb2327974d4c823c7.png
[https_start.springboot.io]: https://start.springboot.io
[acecb67a5d544f8e8b22f1432ffe2e85.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/342ea83ed6e149a88cc62c567dc259c0.png
[d1190f80e8174bc687ab8814ae624cdc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/a36cf7e81ec341839410ed1f0122348b.png
[f66505f604cd48df9787365980a9f4b4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/8f611820455b42ac8dc2e0403872a227.png
[e517f5de7922492a924991d4fde218df.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/75b1e0232eb048028a290831b44b17e8.png
[Getting Started]: https://docs.spring.io/spring-boot/docs/2.7.13/reference/html/getting-started.html#getting-started.first-application.pom
[437bba2b343740ab9042bb523f2ad195.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/1d23d18050b049b7b19f229502821859.png
[9a726fa3abaa4392b59cb6e66183b647.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/f364e31f84c340ccb3471f25c6734101.png
[6a9966cce98347a9b3fce26ff6828150.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/2faaa237b61149c1b1c62da33745cf09.png
[a0e6daabc2344d44b311c03af7bcbedb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/5bbbed8f3ed6449b924485ac667f9715.png
[0b7c817939f74a49878a1fcd18783d87.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/f5a5a5ee82c94155b0ef2936530f82bd.png
[23f6c131fc1944e8afbd644188c383ae.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/ea53d8a7910643b3949ec8f9181c06bf.png
[f6bfba0dd5e54dd8bfee7a27c6814857.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/2fa5bcc8e9f641b0851c3fe91b2f35f6.png
[d15ba0979814482398731682d9d4179d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/8d1a857d7f4b42cf8d3b22de0f733dd2.png
[eb912bada6c34c48b380bd09f5ce9550.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/6787a9f3fba34014b244956894272ea1.png
[0c2d32c0a19e46a1a7258db21b85e949.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/5157dd74953e41feae3d16eee8f125b3.png
[d97acb38b3c04c3eba2dc3cad640d267.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/7db9dbffa6b64a86b11b8cc8f2539995.png
[Developing with Spring Boot]: https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.build-systems.starters
[48df0fed63d145d78ba9d88612bd1f48.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/20cf337cf90f4980848d778526d12b0c.png
[fc05da12dd7f456c9606a417af157b1f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/8e96433203f14fbebf0b8a73e364c3f4.png
[c0b2dd4bc25a42b5b693b51110051326.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/19ed93dbf6014653818d5bb91953da64.png
[e839c055480d4e87b32a6a813af4726c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/5e7dd27cde8e47ba84c6d96115be01cc.png
[b2d6b2f1220f4cadb1dacc80150e0090.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/f9b504ec25474fbaac62d469ce39f352.png
[cc73db237df64ed188a9e7fb70ee9b62.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/be409f92a99f4e93b94b2168955a6c56.png
[f266b170904349079179cba0a2437a01.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/18bbaef83e1543f9b319a476b2a53365.png
[9e784fc49c724db495c4f3dac2457df4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/80e133582684466cb8dd77ec15559ac4.png
[30f73559b01c42fbb1881fe6eddb2bc1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/d0783c8514a541bdb4833c39dd2e4644.png
[ae1622da6e01449eb430d4365380b958.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/abbf33847f194c1ea3f4de86f46dea12.png
[2cd246de28c44a32ab937ec7f07361c3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/2adc532847ae4d0099a1857859ab4604.png
[bab22121620b4c2b90735a0eeded5210.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/786bf2b0489946a491aa1d900623e2bf.png
[Link 1]: http://product.dangdang.com/29551728.html
[945ccccffed348cba966dd981edc0d4d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/ed68f1ae9a4341218ac87d27e38609cd.png
[Link 2]: http://product.dangdang.com/1584611092.html
[f4597889901141629cb14aa962839c01.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/5524abcdc11c40ed981c32aa91a39791.png
[Link 3]: http://product.dangdang.com/9317290.html
[9b871a3b2a65409581ed2592e40d9ce1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/88091ba158684dbbbe1fe98f3ad93034.png
[Link 4]: http://product.dangdang.com/26437835.html#ddclick_reco_reco_relate
[51e0a7f328bb46da8c96f7fa6139ac13.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/77af9c76b1a94683a6e2bac1d7aac249.png
[Link 5]: http://product.dangdang.com/11388901254.html
[53887cbf3d124f9c88698e265aabd8a6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/39c45ecab5f54a819e44f64f10ef5718.png
[Link 6]: http://product.dangdang.com/22606835.html
[1d2e579413654c4688bb9583b7a091d0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/0484273d488c4294ab6d94a0374903b8.png
[Link 7]: http://product.dangdang.com/29509971.html
[Core Java]: http://h5.dangdang.com/mix_gys_04001_lzln