Springboot ist dasselbe wie Spring, beide sind Bergbaukonstruktionen, aber Springboot ist ein Gerüst, das auf der Grundlage des Spring-Frameworks entwickelt wurde und das Spring-Framework teilweise optimiert, um die Effizienz der Projektentwicklung zu verbessern.

2. Vorteile der Verwendung von Springboot für die Entwicklung

Was sind die Designprinzipien von Springboot und welche Vorteile bietet die Verwendung von Springboot für die Entwicklung? (M)

Das Designprinzip von Springboot: Konvention geht über Konfiguration

Aufgrund seiner überlegenen Designprinzipien bietet es Vorteile gegenüber SpringFramework:
① Im Vergleich zu SpringFramework, das eine große Anzahl von XML-Dateien konfigurieren muss, um das Programm auszuführen, hat Springboot intern viele Standardkonfigurationen vereinbart und verschiedene Konfigurationsdateien bereitgestellt, damit Benutzer Konfigurationselemente anpassen können

②Der Konfigurationspfad vieler Frameworks von Drittanbietern (hauptsächlich einschließlich der Konfigurationsinformationen verschiedener Frameworks) wird in Springboot vereinbart, und zu Beginn des Projekts können verschiedene Konfigurationsinformationen geladen werden, um die schnelle Konfiguration von Frameworks von Drittanbietern zu realisieren

③ Springboot integriert den Webcontainer intern, es ist nicht erforderlich, andere Webcontainer zu konfigurieren

④ Springboot verfügt über mehr Überwachungsindikatoren, die den Betrieb des Projekts besser verstehen können

3. Erstellen Sie manuell ein Springboot-Projekt

① Erstellen Sie ein Projekt und wählen Sie Abhängigkeiten aus

②Richten Sie die Hot-Bereitstellung ein (einige Codeänderungen können wirksam werden, ohne dass eine manuelle erneute Ausführung erforderlich ist)

③ Deaktivieren Sie JMX: Denn wenn es nicht ausgeschlossen ist, wird beim Start des Projekts ein Fehler gemeldet. Obwohl sich dieser Fehler nicht auf die Implementierung unseres Projekts auswirkt, fügen wir ihn aus Gründen der Standardisierung dennoch hinzu

④ Deaktivieren Sie Tomcat und ersetzen Sie es durch Undertow (keine obligatorische Option, da Undertow etwas effizienter als Tomcat ist).

⑤ Ändern Sie den Codesatz

Viertens. Springboot-Konfigurationsdatei

1. Voraussetzungen

Profitieren Sie von den Designprinzipien von Springboot: Springboot stimmt (konfiguriert) viele Standardkonfigurationen und lädt sie, wenn das Springboot-Projekt startet. Das heißt, auch wenn der Benutzer keine Konfiguration durchführt, lädt das Springboot-Projekt auch einige Konfigurationselemente Standardmäßig stellt Springboot Benutzerkonfigurationsdateien bereit, mit denen Benutzer Projektkonfigurationen anpassen können

2. Zwei Konfigurationsdateien und Vergleich

SpringBoot verwendet standardmäßig die folgenden zwei globalen Konfigurationsdateien und ihre Dateinamen sind festgelegt.

application.properties

application.yml

Unter diesen ist application.yml eine in der YAML-Sprache geschriebene Datei, die wie application.properties beim Start von Spring Boot automatisch gelesen werden kann und der Standardwert der automatischen Konfiguration von Spring Boot geändert werden kann. Beide haben ähnliche Funktionen und können die Spring Boot-Konfiguration abschließen (z. B. Tomcat-Port angeben, Mybatis konfigurieren usw.), aber die Priorität von Eigenschaften ist höher als die von YAML.

3. Springboot scannt standardmäßig den Speicherort der Konfigurationsdatei

Wenn das Springboot-Projekt ausgeführt wird, scannt es standardmäßig den folgenden Pfad, findet die Konfigurationsdatei und passt die Konfiguration des Projekts an.

Datei:./config/

Datei:./config/*/

Datei:./

Klassenpfad:/config/

Klassenpfad:/

Hinweis: Datei: bezieht sich auf das Stammverzeichnis des aktuellen Projekts; Klassenpfad: bezieht sich auf den Klassenpfad des aktuellen Projekts , nämlich das Ressourcenverzeichnis.

Die Konfigurationsdateien an allen oben genannten Speicherorten werden geladen und ihre Prioritäten werden in der Reihenfolge verringert . Je kleiner die Sequenznummer, desto höher die Priorität. Zweitens hat application.properties am selben Speicherort Vorrang vor application.yml.

Dateien an allen Speicherorten werden geladen und Konfigurationen mit hoher Priorität überschreiben Konfigurationen mit niedriger Priorität, um komplementäre Konfigurationen zu bilden, nämlich:

Wenn derselbe Konfigurationsinhalt vorhanden ist, überschreibt der Inhalt mit hoher Priorität den Inhalt mit niedriger Priorität.
Wenn unterschiedliche Konfigurationsinhalte vorhanden sind, werden der Inhalt mit hoher und niedriger Priorität kombiniert.

4. Erklären Sie die Eigenschaftendatei im Detail

1. Grammatische Regeln

Schlüssel=Wert, im Allgemeinen Wert ohne doppelte oder einfache Anführungszeichen

2. Priorität

Abhängig vom Speicherort der Datei ist auch die Priorität der Konfigurationsdatei unterschiedlich

Datei:./config/

Datei:./

Klassenpfad:/config/

Klassenpfad:/

Von oben nach unten allmählich abnehmende Priorität

3. Benutzerdefinierte Konfiguration und Lesen von Konfigurationsinformationen

Lesen Sie die Informationen in der Konfigurationsdatei über @Value

In der Konfigurationsdatei:

spring.datasource.url=jdbc:mysql://127.0.0.1:3306/testdb?characterEncoding=utf8
spring.datasource.name=root
spring.datasource.password=abc123

 @Value("${spring.datasource.url}")
    private String url;
    @Value("${spring.datasource.name}")
    private String name;
    @Value("${spring.datasource.password}")
    private String password;

Rufen Sie das benutzerdefinierte Objekt in der Konfigurationsklasse über @ConfigurationProperties(prefix = "") ab

In der Konfigurationsdatei:

# 创建自定义对象
user.username=zhangsan
user.userId=1
user.list[0]=1
user.list[1]=2
user.map.1=hhh

Im Unterricht:

@ConfigurationProperties(prefix = "user")
public class User {
    private String username;
    private int userId;
    private List<Integer>list;
    private Hashtable<Integer,String>map;
    //使用init方法判断
    @PostConstruct
    public void init(){
        System.out.println(username+userId+list+map);
    }

5. Detaillierte Erläuterung des Springboot-Protokolls

1. Das Konzept des Protokolls (einschließlich Framework)

Protokollinformationen, die auf der Konsole gedruckt werden, wenn das Programm ausgeführt wird:
Protokoll-Framework

Gängige Protokoll-Frameworks wie: log4j, logback , slf4j, jdk-logging, commons-logging ... Aber sobald diese Frameworks die Konvertierung des verwendeten Protokoll-Frameworks beinhalten, ist dies sehr unpraktisch, sodass slf4j ins Leben gerufen wurde und slf4j For verwendet Durch die Überbrückung des Protokoll-Frameworks ist die Verwendung des Protokolls nach der Einführung von slf4j relativ einfach: Sie müssen lediglich das Abhängigkeitspaket eines bestimmten Protokoll-Frameworks + das Abhängigkeitspaket von slf4j importieren und die Konfigurationsklassen und -methoden von slf4j verwenden gleichmäßig.

2. Die Rolle von Protokollen

Probleme finden und lokalisieren

Zeichnen Sie Benutzeranmeldeinformationen für die Big-Data-Analyse auf

Notieren Sie die Betriebsinformationen des Systems, um die Datenwiederherstellung zu erleichtern und den Bediener zu lokalisieren

Zeichnen Sie die Ausführungszeit des Programms auf, um eine zukünftige Optimierung des Programms zu erleichtern

3. Protokollebene

Die standardmäßige Protokolldruckstufe aller Projekte ist „Info“ (es werden nur „Informationen“ gedruckt, d. h. die darüber liegende Protokollstufe).

Die Protokollebene erhöht sich schrittweise von oben nach unten. Wir können die Protokolldruckebene des Projekts ändern, indem wir die Konfigurationsdatei festlegen

# 当前项目日志的打印级别是debug
logging.level.root=debug
# 设置具体某个包下的日志打印级别
logging.level.com.ljl.springmvc_adv.controller.loginController=info

4. Protokollerstellung und -druck

Die Verwendung ist wie folgt:

package com.example.demo.Controller;

@Controller
@ResponseBody
public class LoggerController {

    // 1. 得到日志对象
    private Logger logger = LoggerFactory.getLogger(LoggerController.class);

    // 2. 打印日志
    @RequestMapping("/logger")
    public String logger(){
        logger.trace("日志级别: trace");
        logger.debug("日志级别: degue");
        logger.info("日志级别: info");
        logger.warn("日志级别: warn");
        logger.error("日志级别: error");
        return "logger";
    }
}

In der Standardkonfiguration werden im Allgemeinen nur die Protokolle der Infoebene und höher gedruckt

Nachdem wir

@Slf4j
@Component
public class LoggerTest {
    public static void main(String[] args) {
        log.debug("这是debug级别的日志......");
        log.info("这是info级别的日志......");
        log.warn("这是warn级别的日志......");
        log.error("这是error级别的日志......");
    }
}

5.Lombok-Ergänzung

Jeder denkt über eine Frage nach: Warum werden viele Methoden automatisch generiert, auch wenn sie nach dem Hinzufügen der @Data-Annotation nicht geschrieben werden?
Vergleichen wir die Dateiklasse vor und nach der Kompilierung

Unsere Dateiklasse in der Datei, die wir schreiben, sieht folgendermaßen aus:

@Data
@Repository//注入到容器
@ConfigurationProperties(prefix = "user")
public class User {
    private String username;
    private int userId;
    private List<Integer>list;
    private Hashtable<Integer,String>map;
    //使用init方法判断
    @PostConstruct
    public void init(){
        System.out.println(username+userId+list+map);
    }

}

Nach der Zusammenstellung:

package com.example.springboot_study.test;

import java.util.Hashtable;
import java.util.List;
import javax.annotation.PostConstruct;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Repository;

@Repository
@ConfigurationProperties(
    prefix = "user"
)
public class User {
    private String username;
    private int userId;
    private List<Integer> list;
    private Hashtable<Integer, String> map;

    @PostConstruct
    public void init() {
        System.out.println(this.username + this.userId + this.list + this.map);
    }

    public User() {
    }

    public String getUsername() {
        return this.username;
    }

    public int getUserId() {
        return this.userId;
    }

    public List<Integer> getList() {
        return this.list;
    }

    public Hashtable<Integer, String> getMap() {
        return this.map;
    }

    public void setUsername(final String username) {
        this.username = username;
    }

    public void setUserId(final int userId) {
        this.userId = userId;
    }

    public void setList(final List<Integer> list) {
        this.list = list;
    }

    public void setMap(final Hashtable<Integer, String> map) {
        this.map = map;
    }

    public boolean equals(final Object o) {
        if (o == this) {
            return true;
        } else if (!(o instanceof User)) {
            return false;
        } else {
            User other = (User)o;
            if (!other.canEqual(this)) {
                return false;
            } else if (this.getUserId() != other.getUserId()) {
                return false;
            } else {
                label49: {
                    Object this$username = this.getUsername();
                    Object other$username = other.getUsername();
                    if (this$username == null) {
                        if (other$username == null) {
                            break label49;
                        }
                    } else if (this$username.equals(other$username)) {
                        break label49;
                    }

                    return false;
                }

                Object this$list = this.getList();
                Object other$list = other.getList();
                if (this$list == null) {
                    if (other$list != null) {
                        return false;
                    }
                } else if (!this$list.equals(other$list)) {
                    return false;
                }

                Object this$map = this.getMap();
                Object other$map = other.getMap();
                if (this$map == null) {
                    if (other$map != null) {
                        return false;
                    }
                } else if (!this$map.equals(other$map)) {
                    return false;
                }

                return true;
            }
        }
    }

    protected boolean canEqual(final Object other) {
        return other instanceof User;
    }

    public int hashCode() {
        int PRIME = true;
        int result = 1;
        result = result * 59 + this.getUserId();
        Object $username = this.getUsername();
        result = result * 59 + ($username == null ? 43 : $username.hashCode());
        Object $list = this.getList();
        result = result * 59 + ($list == null ? 43 : $list.hashCode());
        Object $map = this.getMap();
        result = result * 59 + ($map == null ? 43 : $map.hashCode());
        return result;
    }

    public String toString() {
        return "User(username=" + this.getUsername() + ", userId=" + this.getUserId() + ", list=" + this.getList() + ", map=" + this.getMap() + ")";
    }
}

Durch diesen Vergleich können wir die folgende Schlussfolgerung ziehen: Lombok fügt der Klasse während der Kompilierung den Code seiner eigenen Anmerkungen hinzu, damit die Anmerkungen wirksam werden.

Springboot zum ersten Mal kennenlernen [lehren, wie man ein Springboot-Projekt erstellt] + ausführliche Erklärung der Springboot-Protokolle [sehr detailliert]

1. Das Konzept von Springboot

1. Was ist Springboot?