So lösen Sie die Probleme beim Aufbau der offiziellen SpringBoot-Website und beim schnellen Start

Überblick über SpringBoot

SpringBoot ist ein neues Framework, das vom Pivotal-Team bereitgestellt wird, um den anfänglichen Konstruktions- und Entwicklungsprozess von Spring-Anwendungen zu vereinfachen. SpringBoot 是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程。

大家已经感受了 SpringBoot 程序，回过头看看 SpringBoot 主要作用是什么，就是简化 Spring 的搭建过程和开发过程。

原始 Spring 环境搭建和开发存在以下问题：

• 配置繁琐依赖

• 设置繁琐

SpringBoot 程序优点恰巧就是针对 Spring 的缺点

• 自动配置。这个是用来解决 Spring 程序配置繁琐的问题

• 起步依赖。这个是用来解决 Spring 程序依赖设置繁琐的问题

• 辅助功能（内置服务器,…）。我们在启动 SpringBoot 程序时既没有使用本地的 tomcat 也没有使用 tomcat 插件，而是使用 SpringBoot 内置的服务器。

接下来我们来说一下 SpringBoot 的起步依赖

起步依赖

我们使用 Spring Initializr 方式创建的 Maven 工程的的 pom.xml 配置文件中自动生成了很多包含 starter 的依赖，如下图

这些依赖就是启动依赖，接下来我们探究一下他是如何实现的。

探索父工程

从上面的文件中可以看到指定了一个父工程，我们进入到父工程，发现父工程中又指定了一个父工程，如下图所示

再进入到该父工程中，在该工程中我们可以看到配置内容结构如下图所示

上图中的 properties 标签中定义了各个技术软件依赖的版本，避免了我们在使用不同软件技术时考虑版本的兼容问题。在 properties 中我们找 servlet 和 mysql 的版本如下图

dependencyManagement 标签是进行依赖版本锁定，但是并没有导入对应的依赖；如果我们工程需要那个依赖只需要引入依赖的 groupid 和 artifactId 不需要定义 version。

而 build 标签中也对插件的版本进行了锁定，如下图

看完了父工程中 pom.xml 的配置后不难理解我们工程的的依赖为什么都没有配置 version。

探索依赖

在我们创建的工程中的 pom.xml 中配置了如下依赖

进入到该依赖，查看 pom.xml 的依赖会发现它引入了如下的依赖

里面的引入了 spring-web 和 spring-webmvc 的依赖，这就是为什么我们的工程中没有依赖这两个包还能正常使用 springMVC 中的注解的原因。

而依赖 spring-boot-starter-tomcat ，从名字基本能确认内部依赖了 tomcat，所以我们的工程才能正常启动。

结论：以后需要使用技术，只需要引入该技术对应的起步依赖即可

小结

starter

• SpringBoot 中常见项目名称，定义了当前项目使用的所有项目坐标，以达到减少依赖配置的目的

parent

• 所有 SpringBoot

  Jeder hat das SpringBoot-Programm erlebt. Schauen wir zurück und sehen, was die Hauptfunktion von SpringBoot ist, nämlich den Konstruktions- und Entwicklungsprozess von Spring zu vereinfachen . 🎜🎜Die ursprüngliche Konstruktion und Entwicklung der Spring-Umgebung weist die folgenden Probleme auf: 🎜
  • 🎜Umständliche Konfiguration und Abhängigkeiten🎜
  • 🎜Umständliche Einrichtung 🎜
  🎜🎜SpringBoot Der Vorteil des Programms besteht darin, dass es automatisch gegen die Mängel von Spring🎜
  • 🎜. Dies wird verwendet, um das Problem der umständlichen Konfiguration von Spring-Programmen🎜
  • 🎜Startabhängigkeiten zu lösen. Dies wird verwendet, um das Problem der umständlichen Einrichtung von Spring-Programmabhängigkeiten🎜
  • 🎜Hilfsfunktionen (eingebauter Server,…) zu lösen. Als wir das Programm SpringBoot gestartet haben, haben wir weder das lokale Plug-in tomcat noch das Plug-in tomcat verwendet, sondern SpringBoot Eingebauter Server. 🎜
  🎜🎜Als nächstes sprechen wir über die Startabhängigkeiten von SpringBoot🎜

  Startabhängigkeiten

  🎜Wir haben es mit der Methode Spring Initializr erstelltpom.xml des Code>Maven-Projekts generiert automatisch viele Abhängigkeiten, die starter enthalten, wie unten gezeigt🎜🎜🎜🎜Diese Abhängigkeiten sind Startabhängigkeiten. Lassen Sie uns als Nächstes untersuchen Sehen Sie, wie er es geschafft hat. 🎜

  Untersuchen Sie das übergeordnete Projekt

  🎜Aus der obigen Datei können Sie ersehen, dass ein übergeordnetes Projekt angegeben ist. Wir geben das übergeordnete Projekt ein und stellen fest, dass im übergeordneten Projekt ein anderes übergeordnetes Projekt angegeben ist Abbildung unten🎜🎜🎜🎜Dann geben Sie im übergeordneten Projekt die Konfigurationsinhaltsstruktur ein, wie unten gezeigt🎜🎜🎜🎜Das Tag properties im obigen Bild definiert die Version jeder technischen Softwareabhängigkeit. Dies erspart uns die Verwendung unterschiedlicher Softwaretechnologien. Bedenken Sie Versionskompatibilitätsprobleme. In properties finden wir die Versionen von servlet und mysql wie unten gezeigt🎜🎜🎜🎜dependencyManagement-Tag dient zum Sperren der Abhängigkeitsversion , aber es importiert nicht die entsprechende Abhängigkeit; wenn unser Projekt diese Abhängigkeit benötigt, müssen wir nur die groupid und artifactId der Abhängigkeit einführen Version. 🎜🎜Das build-Tag sperrt auch die Plug-in-Version, wie unten gezeigt🎜🎜🎜🎜Nachdem Sie die Konfiguration von pom.xml im übergeordneten Projekt gelesen haben, ist dies nicht schwierig Verstehen Sie, warum unser Projekt von keiner der beiden version abhängig ist. 🎜

  Abhängigkeiten untersuchen

  🎜Die folgenden Abhängigkeiten sind in pom.xml in dem von uns erstellten Projekt konfiguriert🎜🎜🎜🎜Geben Sie die Abhängigkeit ein und zeigen Sie die Abhängigkeiten von pom.xml an Code> Sie werden feststellen, dass die folgenden Abhängigkeiten eingeführt werden🎜🎜<img src="https://img.php.cn/upload/article/000/887/227/168376831086142.png" alt="Aufbau der offiziellen SpringBoot-Website und Schnellstartprobleme So lösen Sie ">🎜🎜Die Abhängigkeiten von <code>spring-web und spring-webmvc werden eingeführt. Aus diesem Grund kann unser Projekt weiterhin funktionieren, ohne auf diese angewiesen zu sein zwei Pakete. Der Grund für die normale Verwendung der Anmerkungen in springMVC. 🎜🎜Und es hängt von spring-boot-starter-tomcat ab. Anhand des Namens können wir grundsätzlich bestätigen, dass es intern von tomcat abhängt, sodass unser Projekt normal starten kann. 🎜🎜Fazit: Wenn Sie in Zukunft Technologie verwenden müssen, müssen Sie nur die der Technologie entsprechenden Startabhängigkeiten einführen🎜

  Zusammenfassung

  🎜Starter🎜
  • 🎜SpringBoot Gemeinsame Projektnamen definieren alle Projektkoordinaten, die vom aktuellen Projekt verwendet werden, um die Abhängigkeitskonfiguration zu reduzieren🎜
  🎜🎜parent 🎜
  • 🎜Alle Projekte, die vom SpringBoot-Projekt geerbt werden sollen, definieren mehrere koordinierte Versionsnummern (Abhängigkeitsverwaltung, nicht Abhängigkeit), um dies zu erreichen Der Zweck von Reduzierung von Abhängigkeitskonflikten🎜

  • spring-boot-starter-parent (2.5.0) und spring-boot-starter-parent (2.4.6 ) Insgesamt 57 verschiedene Koordinatenversionen G und A, V werden von SpringBoot bereitgestellt / blockquote>spring-boot-starter-parent（2.5.0）与 spring-boot-starter-parent（2.4.6）共计57处坐标版本不同

  实际开发

  使用任意坐标时，仅书写GAV中的G和A，V由SpringBoot提供

  G：groupid

  A：artifactId

  V：version

  如发生坐标错误，再指定version（要小心版本冲突）

  程序启动

  创建的每一个 SpringBoot 程序时都包含一个类似于下面的类，我们将这个类称作引导类

  @SpringBootApplication
  public class Springboot01QuickstartApplication {
      
      public static void main(String[] args) {
          SpringApplication.run(Springboot01QuickstartApplication.class, args);
      }
  }

  注意：

  • SpringBoot 在创建项目时，采用jar的打包方式

  • SpringBoot 的引导类是项目的入口，运行 main 方法就可以启动项目

  因为我们在 pom.xml 中配置了 spring-boot-starter-web 依赖，而该依赖通过前面的学习知道它依赖 tomcat ，所以运行 main 方法就可以使用 tomcat 启动咱们的工程。

  切换web服务器

  现在我们启动工程使用的是 tomcat 服务器，那能不能不使用 tomcat 而使用 jetty 服务器，jetty 在我们 maven 高级时讲 maven 私服使用的服务器。而要切换 web 服务器就需要将默认的 tomcat 服务器给排除掉，怎么排除呢？使用 exclusion 标签

  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <exclusions>
          <exclusion>
              <artifactId>spring-boot-starter-tomcat</artifactId>
              <groupId>org.springframework.boot</groupId>
          </exclusion>
      </exclusions>
  </dependency>

  现在我们运行引导类可以吗？运行一下试试，打印的日志信息如下

  

  程序直接停止了，为什么呢？那是因为排除了 tomcat 服务器，程序中就没有服务器了。所以此时不光要排除 tomcat 服务器，还要引入 jetty 服务器。在 pom.xml 中因为 jetty 的起步依赖

  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-jetty</artifactId>
  </dependency>

  接下来再次运行引导类，在日志信息中就可以看到使用的是 jetty 服务器

  

  小结：
  通过切换服务器，我们不难发现在使用 SpringBoot 换技术时只需要导入该技术的起步依赖即可。

  spring与springboot的对比

  我们前文做完入门案例后，可以发现两者有很大的不同:

  

  坐标

  • Spring 程序中的坐标需要自己编写，而且坐标非常多

  • SpringBoot 程序中的坐标是我们在创建工程时进行勾选自动生成的

  web3.0配置类

  • Spring 程序需要自己编写这个配置类。这个配置类大家之前编写过，肯定感觉很复杂

  • SpringBoot 程序不需要我们自己书写

  配置类

  • Spring/SpringMVC 程序的配置类需要自己书写。而 SpringBoot 程序则不需要书写。

  注意：基于Idea的 Spring Initializr 快速构建 SpringBoot 工程时需要联网。

  官网构建工程

  在入门案例中之所以能快速构建 SpringBoot 工程，是因为 Idea 使用了官网提供了快速构建 SpringBoot 工程的组件实现的。那如何在官网进行工程构建呢？通过如下步骤构建

  进入SpringBoot官网

  进入到 SpringBoot 官网后拖到最下方就可以看到如下内容

  

  然后点击 Spring Initializr 超链接就会跳转到如下页面

  

  这个页面内容是不是感觉很眼熟的，这和我们使用 Idea 快速构建 SpringBoot 工程的界面基本相同。在上面页面输入对应的信息

  选择依赖

  选择 Spring Web 可以点击上图右上角的 ADD DEPENDENCIES... CTRL + BWenn ein Koordinatenfehler auftritt, geben Sie die Version erneut an (achten Sie auf Versionskonflikte)

  Programmstart

  #🎜🎜#Jedes SpringBoot Programm erstellt Jedes Mal, wenn es eine Klasse ähnlich der folgenden enthält, nennen wir diese Klasse die Bootstrap-Klasse#🎜🎜#

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

  #🎜🎜#Hinweis: #🎜🎜#
  #🎜🎜# # 🎜🎜#SpringBoot Verwenden Sie beim Erstellen eines Projekts die JAR-Verpackungsmethode #🎜🎜##🎜🎜##🎜🎜##🎜🎜#SpringBoots Boot-Klasse ist der Projekteingang, führen Sie die main-Methode aus, um das Projekt zu starten#🎜🎜##🎜🎜#
  #🎜🎜#Weil wir < in pom.xml</code konfiguriert haben > code>spring-boot-starter-web hängt davon ab, und diese Abhängigkeit weiß aus der vorherigen Studie, dass sie von tomcat abhängt, also wird main ausgeführt Die Methode kann tomcat verwenden, um unser Projekt zu starten. #🎜🎜#

  Webserver wechseln

  #🎜🎜#Jetzt starten wir das Projekt mit dem tomcat-Server. Können wir ihn anstelle von tomcat < verwenden? code>jetty-Server, jetty ist der Server, der von privaten maven-Servern verwendet wird, wenn wir über fortgeschrittene maven sprechen. Um zum web-Server zu wechseln, müssen Sie den Standard-tomcat-Server ausschließen. Verwenden Sie das Tag exclusion #🎜🎜#

  java -jar 包名.jar

  #🎜🎜#Jetzt führen wir die Bootstrap-Klasse aus, okay? Versuchen Sie es auszuführen. Die gedruckten Protokollinformationen lauten wie folgt#🎜🎜##🎜🎜##🎜🎜##🎜🎜#Das Programm wurde direkt gestoppt, warum? Denn wenn der tomcat-Server ausgeschlossen wird, gibt es keinen Server im Programm. Daher muss zu diesem Zeitpunkt nicht nur der tomcat-Server ausgeschlossen, sondern auch der jetty-Server eingeführt werden. In pom.xml, da die Startabhängigkeit von jetty #🎜🎜#rrreee#🎜🎜# ist. Führen Sie als Nächstes die Boot-Klasse erneut aus, und Sie können die verwendeten sehen Es ist Steg server#🎜🎜##🎜🎜##🎜🎜#

  #🎜🎜#Zusammenfassung:
  Durch den Serverwechsel ist es nicht schwierig Wir stellen fest, dass wir SpringBoot verwenden. Beim Technologiewechsel müssen Sie nur die Startabhängigkeiten der Technologie importieren. #🎜🎜#

  Vergleich zwischen Spring und Springboot

  #🎜🎜#Nachdem wir den obigen Einführungsfall abgeschlossen haben, können wir feststellen, dass es einen großen Unterschied zwischen den beiden gibt: #🎜🎜## 🎜🎜# #🎜🎜## 🎜🎜#Koordinaten#🎜🎜#
  #🎜🎜##🎜🎜#Frühling Die Koordinaten im Programm müssen von Ihnen selbst geschrieben werden, und es gibt viele Koordinaten#🎜🎜##🎜🎜##🎜🎜##🎜🎜#SpringBoot Die Koordinaten im Programm werden automatisch eingegeben generiert durch Überprüfung, wenn wir das Projekt erstellen#🎜🎜## 🎜🎜#
  #🎜🎜#web3.0-Konfigurationsklasse#🎜🎜#
  #🎜🎜##🎜🎜#Spring-Programm muss diese Konfigurationsklasse selbst schreiben. Jeder hat diese Konfigurationsklasse schon einmal geschrieben und sie muss sich sehr kompliziert anfühlen
  #🎜🎜#Konfigurationsklasse#🎜🎜#
  #🎜 🎜##🎜🎜#Spring/SpringMVC</code > Die Konfigurationsklasse des Programms muss selbst geschrieben werden. Das <code>SpringBoot-Programm muss nicht geschrieben werden. #🎜🎜##🎜🎜#

  #🎜🎜#Hinweis: Eine Internetverbindung ist erforderlich, um schnell ein SpringBoot-Projekt basierend auf dem Spring Initializr</code von Idea zu erstellen >. #🎜🎜#</blockquote><h3>Offizielles Website-Erstellungsprojekt</h3>#🎜🎜#Der Grund, warum das <code>SpringBoot-Projekt im Einstiegsfall schnell erstellt werden kann, liegt an Idee</code > Sie wird mithilfe der auf der offiziellen Website bereitgestellten Komponenten implementiert, um das <code>SpringBoot-Projekt schnell zu erstellen. Wie erstellt man also das Projekt auf der offiziellen Website? Erstellen Sie die folgenden Schritte: #🎜🎜#

  Betreten Sie die offizielle Website von SpringBoot

  #🎜🎜#Betreten Sie die offizielle Website von SpringBoot und ziehen Sie sie nach unten, um den folgenden Inhalt anzuzeigen#🎜 🎜##🎜 🎜##🎜🎜 ##🎜🎜#Dann klicken Sie auf Spring Initializr und der Hyperlink springt zur folgenden Seite#🎜🎜##🎜🎜##🎜🎜##🎜🎜#Denken Sie? Kommt Ihnen der Inhalt dieser Seite bekannt vor? Dies ist, was wir verwenden. Idee Die Schnittstelle zum schnellen Erstellen von SpringBoot-Projekten ist grundsätzlich dieselbe. Geben Sie die entsprechenden Informationen auf der Seite oben ein #🎜🎜#

  Abhängigkeiten auswählen

  #🎜🎜#Wählen Sie Spring Web Sie können oben auf ABHÄNGIGKEITEN HINZUFÜGEN... STRG klicken rechte Ecke des Bildes oben + B-Taste, die folgende Oberfläche wird angezeigt #🎜🎜#

  

  生成工程

  以上步骤完成后就可以生成 SpringBoot 工程了。在页面的最下方点击 GENERATE CTRL + 回车 按钮生成工程并下载到本地，如下图所示

  

  打开下载好的压缩包可以看到工程结构和使用 Idea 生成的一模一样，如下图

  

  而打开 pom.xml 文件，里面也包含了父工程和 Spring Web 的依赖。

  通过上面官网的操作，我们知道 Idea 中快速构建 SpringBoot 工程其实就是使用的官网的快速构建组件，那以后即使没有 Idea 也可以使用官网的方式构建 SpringBoot 工程。

  SpringBoot工程快速启动

  问题引入

  

  以后我们和前端开发人员协同开发，而前端开发人员需要测试前端程序就需要后端开启服务器，这就受制于后端开发人员。为了摆脱这个受制，前端开发人员尝试着在自己电脑上安装 Tomcat 和 Idea ，在自己电脑上启动后端程序，这显然不现实。

  我们后端可以将 SpringBoot 工程打成 jar 包，该 jar 包运行不依赖于 Tomcat 和 Idea 这些工具也可以正常运行，只是这个 jar 包在运行过程中连接和我们自己程序相同的 Mysql 数据库即可。这样就可以解决这个问题，如下图

  

  那现在问题是如何打包呢？

  打包

  由于我们在构建 SpringBoot 工程时已经在 pom.xml 中配置了如下插件

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

  所以我们只需要使用 Maven 的 package 指令打包就会在 target 目录下生成对应的 Jar 包。

  注意：该插件必须配置，不然打好的 jar 包也是有问题的。

  启动

  进入 jar 包所在位置，在 命令提示符 中输入如下命令

  java -jar 包名.jar

  执行上述命令就可以看到 SpringBoot 运行的日志信息

  

Das obige ist der detaillierte Inhalt vonSo lösen Sie die Probleme beim Aufbau der offiziellen SpringBoot-Website und beim schnellen Start. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!