Was ist das Prinzip des Spring Boot?

Was ist das Prinzip von Spring Boot:

1. Einführung in den Inhalt

Einführung von Spring Boot durch „Spring Boot Experience“. " Was kann getan werden? In diesem Artikel werden hauptsächlich die grundlegenden Implementierungsideen seiner verschiedenen Funktionspunkte analysiert, um ein umfassendes rationales Verständnis von Spring Boot zu erhalten.

• Abhängigkeitsverwaltung: Spring Boot hat viele Starter durchgeführt, und Starter sind nur ein Einstieg, der uns beim Importieren von Abhängigkeiten hilft und das Projektabhängigkeitsmanagement vereinfacht

• Automatische Konfiguration: Spring Boot bietet Konfigurationsklassen für viele gängige Komponenten und Frameworks basierend auf der Spring-Code-Konfiguration und vereinfacht dadurch die Projektkonfiguration

• Eingebetteter Container: ein gemeinsamer Webcontainer, der Java integriert und vereinfacht Entwicklungsumgebungskonstruktion und ist die Grundlage für das Packen von Plug-Ins zum Packen von Webanwendungen in ausführbare Dateien

• Maven-Plug-In: Wird zum Packen von JAR-Dateien oder WAR-Dateien verwendet, die direkt ausgeführt werden können , sofort einsatzbereit für das Projekt Bieten Sie Unterstützung und natürlich gibt es einige kleine Funktionen, die die Entwicklung unterstützen

• Heißstart: Reduzieren Sie die Anzahl der wiederholten Starts von Containern während des Entwicklungsprozesses und die Entwicklungseffizienz verbessern

• Anwendungsüberwachung: Bietet grundlegende Dienste für Anwendungsprüfung, Gesundheitsüberwachung und Metrikdatenerfassung

• CLI (Befehlszeilentool ): Für Rapid Prototyping besteht keine Notwendigkeit,

2. Starter-Abhängigkeiten zu verwenden: starter

In einem regulären Maven-Projekt, wenn Sie ein bestimmtes Framework verwenden möchten oder Komponente müssen Sie eine große Anzahl von Abhängigkeiten importieren und auf die Versionsübereinstimmung der Abhängigkeiten usw. achten. Das Problem besteht darin, dass Spring Boot eine große Anzahl von Startern bereitstellt. Solche Starter verwenden die Abhängigkeitsübertragung von Maven, um uns beim Import zu helfen damit verbundene Abhängigkeiten. Die folgende POM-Datei fügt beispielsweise webbezogene Abhängigkeiten hinzu, einschließlich Spring Web, Spring MVC usw.:

    .......    <dependencies>
        <!--Web应用程序的典型依赖项-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.1.1.RELEASE</version>
        </dependency>

    </dependencies>
    .......

Prinzip: Wir haben gerade eine Abhängigkeit eec96f44c7c1be047b36f06c1ea837e7 importiert, aber die Abhängigkeiten Verwenden Sie die Abhängigkeitsübertragung von Maven, um eine große Anzahl von Paketen zu importieren, die in der Webentwicklung verwendet werden. Wenn wir die Datei 35ffd8e0928e307213da87b63bd3711a dekomprimieren, finden wir das JAR Tatsächlich enthält sie keinen wesentlichen Inhalt, da es sich nur um ein POM-Projekt handelt. Der wesentliche Inhalt befindet sich in der Datei af26ebdadc0a793eec8fe280ca9c1087 Das wird von mavne erstellt. Beim Herunterladen der JAR-Datei werden viele Abhängigkeiten in der Datei deklariert, z. B. spring-webmvc, spring-web usw.

Kurz gesagt: Wenn unser Projekt von einem bestimmten Starter abhängt, hängt der Starter von vielen anderen Abhängigkeiten ab, und die Abhängigkeitsübertragung von Maven fügt die Abhängigkeiten, von denen der Starter abhängt, zu unserem Projekt hinzu. Der Starter ist lediglich ein Importvermittler für unsere Projektabhängigkeiten.

Informationen zur Abhängigkeitsübertragung von Maven finden Sie in den entsprechenden Informationen. Eine kurze Beschreibung lautet wie folgt:

Projekt A hängt von B ab und B hängt von C ab. Projekt A muss nur deklarieren, dass es von B abhängt, aber nicht, dass es von C abhängt. Maven verwaltet automatisch die Bereitstellung dieser Abhängigkeit.

2. Automatische Konfiguration: AutoConfiguration

Spring Boot konfiguriert automatisch verwandte Komponenten oder Frameworks unter Verwendung von Standardwerten, wodurch die Konfigurationsdateien des Projekts erheblich reduziert werden und Einen eigenen Verarbeitungsablauf basierend auf der Codekonfiguration hinzugefügt. Der folgende Inhalt stellt zunächst kurz die codebasierte Konfiguration von Spring vor und stellt dann vor, was Spring Boot tut.

(1) Spring-Code-basierte Konfiguration

Vor Spring 3 war die Verwendung des Spring-Kontexts im Allgemeinen wie folgt:

Spring-Konfigurationsdatei

<!-- 数据源 -->
 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
 <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
 <property name="url" value="jdbc:oracle:thin:@localhost:1521:xe" />
 <property name="username" value="hr" />
 <property name="password" value="hr" /></bean>
 <!--组件扫描-->
 <context:component-scan base-package="com.demo.spring.sample.step03.?rvic?" />

Geschäftscode

package com.demo.spring.sample.step03.service.impl;.......@Service("userService")
public class UserService implements IUserService {   
   @Autowired
   private IUserDAO userDAO = null;
}

Spring-Kontext erstellen

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

Zusammenfassung:

Weisen Sie Spring über den Komponentenscan an, den Klassenpfad nach @Component, @Repository, @Service, @ zu durchsuchen. Für mit Controller annotierte Klassen instanziiert Spring diese Klassen und registriert die Instanzen im Spring-Kontext. Allerdings werden Beans von Drittanbietern wie Datenquellen und Eigenschaftendateien weiterhin mithilfe von XML-Dateien konfiguriert ist immer noch nicht machbar. Ja, wenn es notwendig ist, ist es relativ mühsam.

Die Verwendung von XML-Konfigurationsdateien hat Vor- und Nachteile. Einer der Nachteile besteht darin, dass Sie den Bean-Instanziierungsprozess nicht zu sehr anpassen können. Für die obige Datenquelle müssen Sie sie beispielsweise nur instanziieren Um den JDBC-Treiber von Oracle im Klassenpfad zu haben, ist dies nicht möglich. Ein weiterer Nachteil besteht darin, dass die Codelogik verstreut ist, da ein Teil der Logik natürlich in XML konfiguriert ist. Der Vorteil besteht darin, dass die Konfiguration zentralisiert ist und es bequem ist, Konfigurationen zu wechseln.

Nach Spring 3 können Sie den Spring-Container auf folgende Weise verwenden:

Spring-Konfigurationsklasse

@Configuration // 表明当前类提供Spring配置文件的作用，Spring上下文会从当前类的注解中提取配置信息
@ComponentScan(basePackages = "com.demo.spring.sample.step08") 
// 开启组件扫描
public class AppConfig {
    @Bean // 表示这个方法实例化一个bean，id=dataSource
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(userName);
        dataSource.setPassword(password);
        return dataSource;
    }}

Geschäftscode

package com.demo.spring.sample.step03.service.impl;.......@Service("userService")
public class UserService implements IUserService {   
   @Autowired
   private IUserDAO userDAO = null;
}

Spring-Kontext erstellen

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

Zusammenfassung:

XML-basierte Konfiguration wird beim Erstellen eines Spring-Kontexts nicht mehr verwendet. Die Konfigurationsdatei verschwindet und wird durch die AppConfig-Klasse ersetzt. und diese Klasse kann über @Bean-annotierte Methoden verfügen. Der Container ruft diese Methoden automatisch auf, um die Bean zu instanziieren.

(2), die automatische Konfiguration von Spring Boot

Spring Boot hat dazu beigetragen, eine große Anzahl von Klassen zu schreiben, die mit @Configuration annotiert sind. Jede Klasse stellt eine Komponenten- oder Framework-Konfiguration bereit, z. B. die statische innere Klasse DataSourceConfiguration Dbcp2 in .java, das die Konfiguration von DBCP-Datenquellen ermöglicht

//DBCP 数据源配置.
@Configuration //这个注解在实际代码中没有加，当前类被其它配置类Import
@ConditionalOnClass(org.apache.commons.dbcp2.BasicDataSource.class)
@ConditionalOnMissingBean(DataSource.class)
@ConditionalOnProperty(name = "spring.datasource.type",  matchIfMissing = true,havingValue = "org.apache.commons.dbcp2.BasicDataSource")
static class Dbcp2 {

   @Bean
   @ConfigurationProperties(prefix = "spring.datasource.dbcp2")
   public org.apache.commons.dbcp2.BasicDataSource dataSource(
         DataSourceProperties properties) {
      return createDataSource(properties,
            org.apache.commons.dbcp2.BasicDataSource.class);
   }

}

Zusammenfassung:

当Spring Boot启动的基本步骤走完后，  如果启用了自动配置，Spring Boot会加载50d40f95c57eb2493885ff1d73d54fff下的24f1ab0d6dc6fb50ace902cbd083b53c文件中的内容，该文件中定义了有关自动配置的信息，其中EnableAutoConfiguration对应的每一个类中都加入了注解@Configuration，也就是说这样的每一个类都相当于Spring的一个或多个配置文件，而其中加注解@Bean的方法是bean的工厂方法,会由Spring上下文自动调用，并且将返回的对象注册到上下文中。

spring.factories文件中自动配置类的部分内容

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
......
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
......

(三)、如何覆盖自动配置的属性

Spring Boot的自动配置会采用大量的默认值(约定由于配置)，可以通过在类路径下提供application.properties或者application.yml配置文件来覆盖默认值，当然部分属性值必须通过该配置文件来提供，比如如果要使用Spring Boot对数据源的自动配置，则在配置文件中必须提供jdbc的url，否则会抛出异常。

三、集成内嵌容器 ：main方法

Spring Boot支持的内嵌容器Tomcat、Jetty、Undertow本身就支持在Java中内嵌使用，因为这些容器本身就是使用Java编写的，只不过Spring Boot在main方法的调用链中根据自动配置嵌入了这样的容器。

不使用这样的内嵌容器也是可以的，在Maven中移除这样的依赖就可以，当然这个时候如果要通过Spring Boot使用Web相关框架，则需要打包为war包后独立部署，或者在开发过程中使用IDE环境的开发部署功能。

不使用内嵌容器的Web应用在打包时需要对工程进行一定的修改。

四、打包可运行文件 ：maven-plugin

Maven使用的默认打包工具支持打包jar文件或者war文件，但是打包后的jar文件中不能再嵌入jar文件，而打包后的war文件不能直接运行，为了把工程所有文件打包为一个可直接运行的jar文件或war文件，spring提供了一个maven插件来解决这样的问题。当然这个插件还提诸如spring-boot:run这样的开发功能

五、热启动 ：devtools

在开发过程中，当完成一个功能单元后，我们会启动程序查看运行效果，如果代码需要再次修改，则修改后需要关掉程序，然后重启程序，这个过程不断迭代，从而完成代码的编写、调试。

Spring Boot 热启动通过重写容器的类加载器，完成程序的部分重启，从而简化、加速程序的调试过程。spring-boot-devtools通过两个类加载器分别加载依赖库和项目代码，当spring-boot-devtools发现项目的编译输出路径下有变化时，通过其中的一个类加载器重新加载所有的项目自有代码，从而完成热启动。这样的热启动比冷启动(关闭、重启)要快很多，到底快多少取决于项目自有代码的数量。

和热启动对应的还有一个热替换，是指单独地替换被修改的某一个class到jvm中，甚至可以单独替换class的某个方法，这种方式比热启动要快，通常使用 JavaAgent 拦截默认加载器的行为来实现，spring有个独立的项目Spring Loaded就是这么做的，但是项目已经被移到了 attic 了，也就是被Spring束之高阁，所以不建议使用。

六、应用监控：actuator

如果类路径中有actuator这个组件的话，Spring Boot的自动配置会自动创建一些端点(端点：遵循Restful设计风格的资源，对应于Controller的某一个处理请求的方法)，这些端点接受请求后返回有关应用的相关信息，比如：健康信息、线程信息等。返回的是json格式的数据，而使用 Spring Boot Admin 可以实现这些 JSON 数据的视图展现，当然也可以为其他应用监控系统监控当前系统提供服务。

七、问题：

为什么pom文件中要继承spring-boot-starter-parent？

spring-boot-starter-parent是spring-boot提供的一个pom，在该pom中定义了很多属性，比如：java源文件的字符编码，编译级别等，还有依赖管理、资源定义的相关pom配置，项目的pom如果继承starter-parent，可以减少相关配置

推荐教程： 《java教程》

Das obige ist der detaillierte Inhalt vonWas ist das Prinzip des Spring Boot?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!