Vorwort
Dieser Artikel analysiert das Arbeitsprinzip von Spring Boot 1.3. Federschuh 1.4. Danach wurde festgestellt, dass sich die Verpackungsstruktur ändert und das Boot-Inf-Verzeichnis hinzugefügt wurde, aber das Grundprinzip bleibt unverändert.
Für Änderungen im Klassenloader in Spring Boot 1.4.*Weitere Informationen finden Sie unter: http://www.vevb.com/article/141479.htm
Spring Boot Schnellstart
Im Spring -Boot ist eine sehr attraktive Funktion, dass die Anwendung direkt in ein Glas/Krieg verpackt werden kann, und dann kann dieses Glas/Krieg direkt gestartet werden, ohne einen anderen Webserver zu konfigurieren.
Wenn Sie Frühlingsstiefel noch nicht verwendet haben, können Sie ihn durch die folgende Demo erleben.
Hier ist ein Projekt als Beispiel, um zu demonstrieren, wie das Spring Boot -Projekt starten soll:
git klone [email protected]: hengyunabc/spring-boot-demo.gitmvn spring-boot-demojava -jar target/deMo-0.1-snapshot.jar
Wenn die verwendete IDE Spring STS oder Idee ist, können Sie über den Assistenten ein Spring -Boot -Projekt erstellen.
Sie können sich auch auf das offizielle Tutorial beziehen:
http://docs.spring.io/spring-boot/docs/current-snapshot/reference/htmlsingle/#getting-started-first-anapplication
Zwei Fragen zum Spring Boot
Wenn Sie sich zum ersten Mal mit Spring Boot kontaktieren, haben Sie diese Fragen normalerweise
Lassen Sie uns analysieren, wie der Spring -Stiefel fertig ist.
Wie der Springstiefel begonnen wird, wenn er als einzelnes Glas verpackt ist
Nachdem Maven verpackt ist, werden zwei JAR -Dateien generiert:
Demo-0.0.1-Snapshot.jardemo-0.0.1-Snapshot.jar.original
wobei Demo-0.0.1-Snapshot.jar.original das Standardpaket aus Maven-Jar-Plugin ist.
Demo-0.0.1-Snapshot.jar ist ein JAR-Paket, das vom Spring Start Maven-Plug-In generiert wird und die Anwendungsabhängigkeiten und Spring-Startklassen enthält. Im Folgenden heißt es Fat Jar.
Überprüfen wir zunächst die Verzeichnisstruktur der Pakete, die mit Spring Boot erstellt wurden (lassen Sie sie aus, wenn sie nicht wichtig ist):
├── Meta-inf│ ├── Manifest.mf├├ application.Properties├├ └ └── Beispiel └── Rotbootdemoapplication └── Loader ├── ExecutIVEarchivenivarbe -CLASS.CLASS ├─º Jarlauncher.Class ├── JavaagentDetektor
Schauen wir uns diese Inhalte nacheinander an.
Manifest.mf
Manifest-Version: 1.0Start-Class: com.example.SpringBootDemoApplicationImplementation-Vendor-Id: com.exampleSpring-Boot-Version: 1.3.0.RELEASECreated-By: Apache Maven 3.3.3Build-Jdk: 1.8.0_60Implementation-Vendor: Pivotal Software, Inc.Main-Class: org.springframework.boot.loader.jarlauncher
Sie können sehen, dass die Hauptklasse org.springframework.boot.loader.jarlauncher ist, der Hauptfunktion, die von JAR gestartet wird.
Es gibt auch eine Startklasse, die com.example.springbootDemoApplication ist, die die Hauptfunktion ist, die wir anwenden.
@SpringbootApplicationPublic Class SpringbootDemoApplication {public static void main (String [] args) {SpringApplication.run (SpringbootDemoApplication.Class, Args); }} com/Beispielverzeichnis
Hier ist die .CLASS -Datei der Anwendung.
Lib -Verzeichnis
Hier ist die JAR -Paketdatei, von der die Anwendung abhängt.
Zum Beispiel Frühlingsbohnen, Spring-MVC und andere Gläser.
org/SpringFramework/Boot/Loader -Verzeichnis
Hier ist die .class -Datei des Spring -Bootloaders.
Archivkonzept
Im Spring Boot wird das Konzept des Archivs abstrahiert.
Ein Archiv kann ein Glas (Jarfilearchive) oder ein Dateiverzeichnis (explodedarchive) sein. Es kann als die Schicht der von Spring Boot abstrahierten einheitlichen Zugangsressourcen verstanden werden.
Das obige Demo-0.0.1-Snapshot.jar ist ein Archiv, und dann jedes JAR-Paket unter dem Verzeichnis /lib in der Demo-0.0.1-Snapshot.jar ist ebenfalls ein Archiv.
public abstract Class Archive {public abstract URL Geturl (); public String getMainClass (); öffentliche abstrakte Sammlung <eintrags> getentriies (); öffentliche abstrakte Liste <archive> getNestedarchives (Entryfilter -Filter);Sie können sehen, dass das Archiv eine eigene URL hat, z. B.:
JAR: Datei: /tmp/target/demo-0.0.1-snapshot.jar!/
Es gibt auch eine GetNestedarchives-Funktion, die tatsächlich die Archivliste der Gläser unter Demo-0.0.1-Snapshot.jar/lib zurückgibt. Ihre URLs sind:
Jar: Datei: /tmp/target/demo-0.0.1-snapshot.jar! /lib/aopalliance-1.0.jarjar: file: /tmp/target/demo-0.0.1-snapshot.jar! /lib/spring-bans-4.3.3.3.3.jar
Jarlauncher
Aus Manifest.mf können wir sehen, dass die Hauptfunktion Jarlauncher ist. Lassen Sie uns den unten stehenden Workflow analysieren.
Die Vererbungsstruktur der Jarlauncher -Klasse lautet:
Klasse Jarlauncher erweitert ExecutIVearchivelaunaunerClass ExecutIVearchivesival -Ausdauerer erweitert Launcher
Erstellen Sie ein Archiv mit Demo-0.0.1-Snapshot.jar:
Jarlauncher findet zuerst den Weg des Glas, wo er sich befindet, dh Demo-0.0.1-Snapshot.jar, und erstellt dann ein Archiv.
Der folgende Code zeigt den Trick, wie Sie den Ladeort aus einer Klasse finden:
geschützte endgültige Archivkrepreation () löst eine Ausnahme aus {ProtectionDomain ProtectionDomain = getClass (). getProtectionDomain (); Codesource codesource = ProtectionDomain.getCodesource (); URI -Standort = (codesource == null? Null: codesource.getLocation (). Touri ()); String path = (location == null? Null: location.getschemespecificPart ()); if (path == null) {neue illegaleStateException werfen ("kann das Archiv der Codequelle nicht bestimmen"); } Datei root = new Datei (Pfad); if (! root.exists ()) {werfen Sie neue IllegalStateException ("Codes -Quellarchiv nicht aus" + root); } return (root.isdirectory ()? Neu explodedarchive (root): New Jarfilearchive (root));} Holen Sie sich das Glas unter lib/ und erstellen
Nachdem Jarlauncher das Archiv erstellt hat, verwendet er die Funktion GetNestarchives, um alle JAR-Dateien unter Demo-0.0.1-Snapshot.jar/lib zu erhalten und sie als Liste zu erstellen.
Beachten Sie, dass Archive, wie oben erwähnt, eine eigene URL hat.
Nachdem Sie diese Archiv -URLs erhalten haben, erhalten Sie ein URL [] -Array und verwenden diesen, um einen benutzerdefinierten Klassenloader zu konstruieren: startedurlClassloader.
Nach dem Erstellen des Classloaders lesen Sie die Startklasse von Manifest.mf, dh com.example.springbootDemoapplication, und erstellen Sie dann einen neuen Thread, um die Hauptfunktion der Anwendung zu starten.
/*** Starten Sie die Anwendung mit der Archivdatei und einem vollständig konfigurierten Klassenloader. */Protected void Start (String [] args, String -Mainclass, Classloader Classloader) löst eine Ausnahme aus {Runnable runner = CreateMainMethodrunner (Mainclass, Args, Classloader); Thread RunnerThread = neuer Thread (Läufer); RunnerThread.setContextClassLoader (Classloader); RunnerThread.SetName (Thread.currentThread (). getName ()); RunnerThread.start ();}/*** Erstellen Sie den {@code mainMethodrunner}, der zum Starten der Anwendung verwendet wird. */Protected Runnable CreateMainMethodrunner (String -MainClass, String [] args, classloader classloader) löst eine Ausnahme aus {class <?> runnerClass = classloader.loadClass (runner_class); Constructor <?> Constructor = runnerClass.getConstructor (string.class, String []. Klasse); return (runnable) constructor.newinstance (montclass, args);} LOWNEDURLCLASSOADER
Der Unterschied zwischen StartedurlClassloader und dem normalen URLCASSLOADER besteht darin, dass er die Möglichkeit bietet,. Klasse aus dem Archiv zu laden.
Wenn Sie die von Archive bereitgestellte Getentries -Funktion kombinieren, können Sie die Ressource im Archiv erhalten. Natürlich gibt es noch viele Details im Inneren, also werde ich es unten beschreiben.
Zusammenfassung des Startprozesses für Spring Boot Application
Nachdem Sie dies gesehen haben, können Sie den Startprozess der Spring -Boot -Anwendung zusammenfassen:
Details im Spring Boot Loader
Codeadresse: https://github.com/spring-projects/spring-boot/tree/master/spring-boot-tools/spring-boot-loader
Erweiterungen von Jarfile -URLs
Springstiefel kann mit einem fetten Glas gestartet werden. Das Wichtigste ist, dass es die Lademethode von Jar in Glas implementiert.
Die Definition der ursprünglichen Jarfile -URL von JDK finden Sie hier:
http://docs.oracle.com/javase/7/docs/api/java/net/jarurlconnection.html
Die ursprüngliche Jarfile -URL sieht folgendermaßen aus:
JAR: Datei: /tmp/target/demo-0.0.1-snapshot.jar!/
URL der Ressourcen im JAR -Paket:
Kopieren Sie den Code wie folgt: JAR: Datei: /tmp/target/demo-0.0.1-snapshot.jar! /Com/example/springbootDemoApplication.class
Sie können sehen, dass die Definition für die Ressourcen in Glas durch '!/' Getrennt ist. Die ursprüngliche Jarfile -URL unterstützt nur eine '!/'.
Spring Boot erweitert dieses Protokoll, um mehrere '!/' Zu unterstützen, das Jar in Jar, Jar in Verzeichnisressourcen darstellen kann.
Beispielsweise repräsentiert die folgende URL die Spring-Beans-4.2.3.Release.jar im Lib-Verzeichnis von Demo-0.0.1-Snapshot.jar:
Kopieren Sie den Code wie folgt: jar: file: /tmp/target/demo-0.0.1-snapshot.jar! /Lib/spring-beans-4.2.3.release.jar! /Meta-inf/manifest.mf
Benutzerdefinierte urlstreamhandler, erweitern jarfile und jarurlconnection
Beim Bau einer URL können Sie einen Handler übergeben, und der JDK wird mit einer Standard -Handlerklasse geliefert. Die Anwendung kann den Handler selbst registrieren, um benutzerdefinierte URLs zu verarbeiten.
Öffentliche URL (String -Protokoll, String -Host, Int -Port, String -Datei, UrlstreamHandler -Handler) löscht die Fehlformedurlexception aus
Siehe:
https://docs.oracle.com/javase/8/docs/api/java/net/url.html#url-java.lang.string-java.lang.string-int-java.lang.string--
Spring Boot übernimmt die Logik mehrerer Gläser in Gläsern, indem sie eine benutzerdefinierte Handlerklasse registriert.
Dieser Handler verwendet Softrreference, um alle offenen Jarfiles zu speichern.
Bei der Verarbeitung von URLs wie folgt wird der '!/' -Teparator verarbeitet. Ausgehend von der obersten Ebene konstruieren Sie zuerst die Jarfile Demo-0.0.1-Snapshot.jar und konstruieren Sie dann die Jarfile Spring-Beans-42.2.Release.jar und konstruieren Sie dann die Jarurlconnection, die auf Manifest.mf zeigt.
Kopieren Sie den Code wie folgt: jar: file: /tmp/target/demo-0.0.1-snapshot.jar! /Lib/spring-beans-4.2.3.release.jar! /Meta-inf/manifest.mf
//org.springframework.boot.loader.jar.HandlerPublic Class Handler erweitert UrlStreamHandler {private statische String -Trennzeichen = "!/"; private statische SofTreference <map <Datei, Jarfile >> rootfilecache; @Override Protected urlConnection openConnection (URL URL) löst ioException {if (this.jarfile! } try {return New JarurlConnection (URL, getrootjarfileFromurl (url)); } catch (Ausnahme ex) {return openFallbackConnection (URL, Ex); }} public jarfile getrootjarfileFromurl (url url) löscht IoException {String spec = url.getFile () aus; int separatorIndex = spec.indexof (separator); if (separatorIndex == -1) {werfen Sie eine neue Malformaledurlexception ("Jar -URL nicht enthalten!/ Separator"); } String name = spec.substring (0, separatorIndex); return getrootjarfile (name); } Wie der Classloader auf Ressource liest
Welche Fähigkeiten benötigt es für einen Klassenloader?
Die entsprechende API ist:
öffentliche URL FindResource (String -Name) Public InputStream getResourceAsStream (String -Name)
Wie oben erwähnt, gibt es bei Spring -Boot -Konstrukten für den LaderaLaSloader ein URL [] -Array. Das Array ist die URL des Glas unter dem Lib -Verzeichnis.
Woher wissen JDK oder Classloader, wie man den Inhalt darin für eine URL liest?
In der Tat sieht der Prozess so aus:
Der letzte Anruf ist die GetInputStream () -Funktion von JarurlConnection.
//org.springFramework.boot.loader.jar.jarurlConnection @Override public InputStream getInputStream () löscht IOException {Connect () aus; if (this.jarEntryname.isempty ()) {neue IOException ("kein Eintragsname angegeben"); } return this.jarEentryData.getInputStream (); }Von einer URL bis zum endgültigen Lesen des Inhalts in der URL ist der gesamte Prozess ziemlich kompliziert. Lassen Sie uns zusammenfassen:
Hier gibt es viele Details, nur einige wichtige Punkte sind aufgeführt.
Wie kann URLClassloader GetResource dann?
Bei der Erstellung des URLClassloaders verfügt er über URL [] -Array -Parameter und verwendet dieses Array, um einen URLCASS -Path zu konstruieren:
URLCASSPATH UCP = NEUE URLCASSPATH (URLS);
In der URLCASSPATH wird ein Lader für alle URLs konstruiert, und dann wird versucht, sie nacheinander von diesen Ladern zu erhalten.
Wenn die Akquisition erfolgreich ist, wird sie wie unten als Ressource verpackt.
Ressource getResource (endgültiger String -Name, Boolean Check) {endgültige URL -URL; try {url = new URL (Basis, Parseutil.encodepath (Name, Falsch)); } catch (fehl Formaledurlexception e) {Wirf neu illegalArgumentException ("Name"); } endgültige urlConnection uc; try {if (check) {urlClassPath.Check (url); } uc = url.openconnection (); InputStream in = uc.getInputStream (); if (uc instanceof jarurlConnection) { / * muss sich an die JAR -Datei erinnern, damit sie in Eile geschlossen werden kann. */ JarurlConnection juc = (jarurlConnection) uc; jarfile = jarloader.checkjar (juc.getJarfile ()); }} catch (Ausnahme e) {return null; } return New Resource () {public String getName () {return name; } public url geturl () {return url; } public url getCodesourceURl () {return base; } public InputStream getInputStream () löscht ioException {return uc.getInputStream (); } public int getContentLength () löscht ioException {return uc.getContentLength (); }};}Wie Sie aus dem Code sehen können, wird url.openconnection () tatsächlich aufgerufen. Auf diese Weise kann die gesamte Kette verbunden werden.
Beachten Sie, dass der Code der URLCASSPATH -Klasse im JDK nicht mit sich selbst geliefert wird. Hier sehen Sie http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/7u40-b43/sun/misc/urlclasspath.java#506
Starten Sie die Spring -Boot -Anwendung in IDE/Open -Verzeichnis
Das obige wird nur erwähnt, als die Spring -Boot -Anwendung in einem fetten Glas starten. Das Folgende ist eine Analyse, wie der Springstiefel in der IDE begonnen wird.
In der IDE besteht die Hauptfunktion, die direkt ausgeführt wird, eine eigene Hauptfunktion:
@SpringbootApplicationPublic Class SpringbootDemoApplication {public static void main (String [] args) {SpringApplication.run (SpringbootDemoApplication.Class, Args); }}In der Tat ist die Start der Spring -Boot -Anwendung in der IDE der einfachste Fall, da die Abhängigkeitsgläser in den Klassenpfad gesteckt werden, sodass der Spring Boot gerade gestartet wird.
Eine andere Situation besteht darin, den Spring Boot in einem offenen Verzeichnis zu starten. Das sogenannte offene Verzeichnis besteht darin, das Fettglas zu dekomprimieren und dann die Anwendung direkt zu starten.
java org.springframework.boot.loader.jarlauncher
Zu diesem Zeitpunkt bestimmt Spring Boot, ob es sich derzeit in einem Verzeichnis befindet. In diesem Fall konstruieren Sie ein explodedarchives (der vorherige ist Jarfilearchive), und der anschließende Startprozess ähnelt dem Fettglas.
Bemadungstomcat -Startprozess
Stellen Sie fest, ob es sich in der Webumgebung befindet
Wenn Spring Boot gestartet wird, stellen Sie zunächst fest, ob es sich in der Webumgebung befindet, indem Sie einfach die Servlet -Klasse durchsuchen:
private statische endgültige String [] web_environment_classes = {"javax.servlet.servlet", "org.springFramework.web.Context.ConfigurablewebApplicationContext"}; (! Classutils.isspresent (className, null)) {return false; }} return true;}In diesem Fall wird AnnotationConFigembededWebApplicationContext erstellt, ansonsten ist der Frühlingskontext AnnotationConfigapplicationContext:
//org.springFramework.boot.springApplication Protected ConfigurableApplicationContext CreateApplicationContext () {Class <?> contextclass = this.applicationContextClass; if (contextClass == null) {try {contextclass = class.forname (this.webenvironment? default_web_context_class: default_context_class); } catch (classNotFoundException ex) {neue IllegalStateException werfen ("Ein Standard -ApplicationContext nicht erstellen," + "Bitte eine applicationContextClass angeben", ex); }} return (configurableApplicationContext) beanutils.instantiate (contextClass); } Holen Sie sich die Implementierungsklasse von EmbeddedServletContainerFactory
Spring Start startet den entsprechenden Webserver, indem eingebettete ServletContainerFactory erhalten wird.
Die beiden häufig verwendeten Implementierungsklassen sind tomcatembeddedServletContainerFactory und JettyembeddedServletContainerFactory.
Code zum Starten von Tomcat:
// tomcatembeddedServletContainerFactory@overridePublic EmbeddedServletContainer getembededServletContainer (ServletContextInitializer ... Initializer) {Tomcat tomcat = new tomcat (); File -basierenir = (this.basedirectory! tomcat.setBasedir (basiertir.getabsolutepath ()); Connector Connector = New Connector (this.Protocol); tomcat.getService (). AddConnector (Anschluss); CUPPENICECONNECTOR (Connector); tomcat.setConnector (Anschluss); tomcat.gethost (). setAutodeploy (falsch); tomcat.getEgine (). retbackgroundProcessordelay (-1); für (Connector ConconNector: this.additionalTomcatConnectors) {tomcat.getService (). } prepareContext (tomcat.gethost (), Initializer); Return GettomcatembededServletContainer (Tomcat);}; Für Tomcat wird ein temporäres Dateiverzeichnis erstellt, wie z. B.:
/tmp/tomcat.2233614112516545210.8080, als Basis von Tomcat. Temporäre Tomcat -Dateien wie das Arbeitsverzeichnis werden innen platziert.
Einige Tomcat -Servlets werden ebenfalls initialisiert, wie das wichtigere Standard/JSP -Servlet:
private void addDefaultServlet (Kontextkontext) {Wrapper defaultServlet = context.createwrapper (); defaultServlet.setName ("Standard"); defaultServlet.setServletClass ("org.apache.catalina.servlets.DefaultServlet"); defaultServlet.addinitParameter ("Debug", "0"); defaultServlet.addinitParameter ("Listings", "False"); defaultServlet.SetloadonStartup (1); // Andernfalls kann der Standardstandort eines Spring -DispatcherServlet nicht festgelegt werden. context.addchild (defaultServlet); context.addServletMapping ("/", "Standard");} private void addJSPServlet (Kontextkontext) {Wrapper JSPServlet = context.CreateWrapper (); JSPServlet.SetName ("JSP"); JSPServlet.SetServletClass (getJspServletClassName ()); JSPServlet.addinitParameter ("Fork", "False"); JSPServlet.SetloadonStartup (3); context.addchild (JSPServlet); context.addServletMapping ("*. jsp", "jsp"); context.addServletMapping ("*. jspx", "jsp");} So greifen Sie mit der Spring -Boot -Webanwendung Ressource zu
Wie greife ich auf die Webressource zu, wenn die Spring -Boot -Anwendung als Fatglas verpackt ist?
Es wird tatsächlich über die von Archive bereitgestellte URL und dann durch die Möglichkeit implementiert, auf die von Classloader bereitgestellte Klassenspath -Ressource zuzugreifen.
index.html
Sie müssen beispielsweise einen Index.html konfigurieren, der direkt in das SRC/Main/Ressourcen-/Static -Verzeichnis im Code platziert werden kann.
Für die Index.html -Begrüßungsseite wird ein ViewController erstellt, wenn der Spring Boot initialisiert wird, um zu handhaben:
// ResourcePropertieSpublic Class ResourceProperties implementiert ressourcenoaderaware {private statische endgültige String [] servlet_resource_locations = {"/"}; private statische endgültige String [] classpath_resource_locations = {"classPath:/meta-inf/ressourcen/", "classPath:/ressourcen/", "classPath:/static/", "classPath:/public/"}; // webmvcautoconfigurationAdapter @Override public void addviewController (ViewControllerregistry -Registrierung) {Ressourcenseite = this.resourceProperties.getWelcomePage (); if (Seite! = null) {logger.info ("Begrüßung Seite hinzufügen:" + Seite); Registry.AddViewController ("/"). setViewName ("vorwärts: index.html"); }} Vorlage
Beispielsweise kann die Seitenvorlagendatei im Verzeichnis SRC/Main/Ressourcen/Vorlagen platziert werden. Dies wird jedoch tatsächlich von der Vorlagen -Implementierungsklasse selbst behandelt. Zum Beispiel in der Thymeleafproperties -Klasse:
public static final String default_prefix = "classPath:/templates/";
JSP
Die JSP -Seite ähnelt der Vorlage. Es wird tatsächlich durch das in Frühlings -MVC eingebaute JSTLView behandelt.
Sie können spring.view.prefix konfigurieren, um das Verzeichnis der JSP -Seite festzulegen:
spring.view.prefix:/web-inf/jsp/
Umgang mit einheitlichen Fehlerseiten im Spring Boot
Für Fehlerseiten wird der Spring -Boot auch durch Erstellen eines BasicErrorController gleichmäßig behandelt.
@Controller@RequestMapping ("$ {server.Error.Path: $ {error.path:/error}}") öffentliche Klasse BasicErrortroller erweitert AbstractterrorControllerDie entsprechende Ansicht ist eine einfache HTML -Erinnerung:
@Configuration@ConditionalonProperty (Präfix = "Server.Error.whitelabel", name = "enabled", matchiFming = true) @Conditional (errortemPlatemissingCondition.class) Protected Static Class WhitelabelErViewConfiguration {private spelview defaulterrorview = New Spelview (New Spelview (New Spelview) (New Spelview {private spelview zu "<html> <body> <h1> Whitelabel -Fehler Seite </h1>" + "<p> Diese Anwendung hat kein explizites Zuordnung für/Fehler, also sehen Sie dies als Fallback. + "<div> $ {message} </div> </body> </html>"); @Bean (name = "error") @ConditionalonmissingBean (name = "error") öffentliche Ansicht DefaulterRorView () {return this.DefaulterrorView; }Spring Boot ist eine gute Praxis, die die Standardausnahme vermeidet, wenn herkömmliche Webanwendungen Fehler machen, wodurch es einfach ist, Geheimnisse zu verletzen.
Maven -Verpackungsprozess der Spring -Boot -Anwendung
Erzeugen Sie zuerst ein Glas mit Abhängigkeiten über Maven-Shade-Plugin und verpacken Sie dann die Klassen, die sich auf den Spring-Boot-Loader und das Manifest.MF beziehen.
Implementierung von Farbprotokollen im Spring Boot
Wenn Sie die Spring -Boot -Anwendung in der Shell starten, werden Sie feststellen, dass der Ausgang des Loggers gefärbt ist, was sehr interessant ist.
Diese Einstellung kann ausgeschaltet werden:
spring.output.ansi.enabled = false
Das Prinzip besteht darin, diese Konfiguration über AnSioutputApplicationListener zu erhalten und dann den Logback für die Ausgabe einzustellen, einen ColorConverter hinzuzufügen und einige Felder über org.springframework.boot.Ansi.Ansioutput zu rendern.
Einige Code -Tipps
Unterstützen Sie bei der Implementierung des Klassenloaders das parallele Laden von JDK7
Sie können sich auf den LockProvider im LOADER von LOWNEDURLCLASS beziehen
Public Class LORTEDURLCLASSLOADER erweitert URLCASSLOADER {private static lockProvider lock_provider = setUplockProvider (); private static lockProvider setUplockProvider () {try {classloader.registerasparallelCapable (); Return New Java7LockProvider (); } catch (NoSuchMethoderror ex) {return New LockProvider (); }} @Override Protected Class <?> LoadClass (String -Name, boolean Resolve) löscht classNotFoundException {synchronized (startedurlclasloader.lock_provider.getLock (this, name)) {class <?> LoadedClass = FindoadedClass (Name); if (LoadedClass == null) {Handler.SetusefastConnectionExceptions (true); try {LoadedClass = doloadClass (Name); } endlich {handler.setusefastConnectionExceptions (false); }} if (Resolve) {resolVeclass (LoadedClass); } return LoadedClass; }} Überprüfen Sie, ob das JAR -Paket über den Agenten geladen wird
InputArgumentsJavaAgentDector, das Prinzip besteht darin, festzustellen, ob die URL des Glas das Präfix von "-Javaagent" hat: ".
private statische endgültige Zeichenfolge java_agent_prefix = "-javaagent:";
Holen Sie sich die PID des Prozesses
ApplicationPid, Sie können die PID erhalten.
private String getPid () {try {string jvmname = ManagementFactory.getRuntimemxbean (). getName (); return jvmname.split ("@") [0]; } catch (throwable ex) {return null; }} Verpackungsprotokollklasse
Spring Boot verfügt über eine Reihe von Loggers, die Java, Log4j, Log4J2, Logback unterstützen. Sie können sich darauf verweisen, wenn Sie Ihre Holzfäller in Zukunft selbst verpacken müssen.
Unter dem org.springframework.boot.logging -Paket.
Holen Sie sich die ursprüngliche Hauptfunktion gestartet
Beurteilen Sie durch die im Stapel erhaltene Methode die Hauptfunktion und finden Sie die ursprüngliche Hauptfunktion.
private class <?> deducemainApplicationClass () {try {stacktraceElement [] stacktrace = new RunTimeException (). getStacktrace (); für (stacktraceElement stacktraceElement: stacktrace) {if ("main" .equals (stacktraceElement.getMethodname ())) {return class.forname (stacktraceElement.getClassName ()); }}} catch (classNotFoundException ex) {// Swallow und Fortsetzung} return null;} Einige Nachteile des Spirng -Stiefels:
Wenn die Spring -Boot -Anwendung in einem fetten Glas ausgeführt wird, werden einige Probleme auftreten. Hier sind meine persönlichen Meinungen:
Zusammenfassen
Spring Boot erweitert das JAR -Protokoll, das Archivkonzept und das unterstützende Jarfile, die JarurlConnection und den Ladern von JarurlConnection und LOADER, wodurch die Entwicklungserfahrung aller in einer ohne Wahrnehmung der oberen Schichtanwendung realisiert wird. Obwohl ausführbarer Krieg kein von Spring vorgeschlagenes Konzept ist, ermöglicht Spring Stiefel vorwärts.
Spring Boot ist ein erstaunliches Projekt, von dem man bezeichnet werden kann, dass es sich um die zweite Frühlingsprotokolle handelt. Frühlingswolken-Konfiguration, Frühlingssitzung, Metriken, Remote-Shell usw. sind alle Projekte und Funktionen, die Entwickler lieben. Es ist fast sicher, dass der Designer eine umfassende Erfahrung in der Frontentwicklung hat und sich der Schmerzpunkte der Entwickler bewusst ist.
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.