Shulou(Shulou.com)06/02 Report--

This article mainly explains "how SpringBoot runs". Friends who are interested might as well take a look. The method introduced in this paper is simple, fast and practical. Now let the editor take you to learn how SpringBoot runs!

Hello World

First of all, let's take a look at the simple Hello World code of SpringBoot, just two files, HelloControll.java and Application.java, and run Application.java to run a simple RESTFul Web server.

/ / HelloController.java

Package hello

Import org.springframework.web.bind.annotation.RestController

Import org.springframework.web.bind.annotation.RequestMapping

@ RestController

Public class HelloController {

@ RequestMapping ("/")

Public String index () {

Return "Greetings from Spring Boot!"

}

}

/ / Application.java

Package hello

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)

}

}

When I opened my browser and saw that the server would normally render the output in the browser, I couldn't help shouting-SpringBoot is so fucking simple.

But the question is, I don't have a reference to the HelloController class anywhere in the main method of Application, so how does its code get called by the server? This requires digging into the SpringApplication.run () method to see what's going on. But even without looking at the code, it's easy to guess that SpringBoot must have scanned the current package somewhere, automatically registering classes with RestController annotations into Tomcat Server as Controller of the MVC layer.

Another annoying thing is that SpringBoot startup is so slow that it takes as long as 5 seconds for a simple Hello World to start. It's hard to imagine such a slow start speed for a more complex project.

Complaining again, although only one maven dependency is configured in the pom, this simple HelloWorld relies on a total of 36 jar packages, of which 15 are jar packages that start with spring. It is not too much to say that this is relying on hell.

That's enough criticism, so let's get to the point and see how SpringBoot's main method works.

Stack of SpringBoot

The easiest way to understand how SpringBoot is running is to look at its call stack. The following startup call stack is not too deep, and I have nothing to complain about.

Public class TomcatServer {

@ Override

Public void start () throws WebServerException {

...

}

}

Next, look at the runtime stack to see how deep the call stack of an HTTP request is. I was shocked when I looked at it and didn't know.

By making the IDE window full-screen and minimizing all the other console window source windows, I managed to fit the entire call stack on one screen.

On second thought, however, it's not SpringBoot's fault. Most of them are Tomcat's call stack, and there are only less than 10 layers related to SpringBoot.

Explore ClassLoader

Another feature of SpringBoot is that it uses FatJar technology to put all dependent jar packages together into the BOOT-INF/lib directory in the final jar package, and the class of the current project is uniformly placed in the BOOT-INF/classes directory.

Org.springframework.boot

Spring-boot-maven-plugin

This is different from the maven shade plug-in we often use, unpacking all the class files in the dependent jar package and then stuffing them into a unified jar package. Let's unpack the jar package packaged by springboot and take a look at its directory structure.

├── BOOT-INF

│ ├── classes

│ │ └── hello

│ └── lib

│ ├── classmate-1.3.4.jar

│ ├── hibernate-validator-6.0.12.Final.jar

│ ├── jackson-annotations-2.9.0.jar

│ ├── jackson-core-2.9.6.jar

│ ├── jackson-databind-2.9.6.jar

│ ├── jackson-datatype-jdk8-2.9.6.jar

│ ├── jackson-datatype-jsr310-2.9.6.jar

│ ├── jackson-module-parameter-names-2.9.6.jar

│ ├── javax.annotation-api-1.3.2.jar

│ ├── jboss-logging-3.3.2.Final.jar

│ ├── jul-to-slf4j-1.7.25.jar

│ ├── log4j-api-2.10.0.jar

│ ├── log4j-to-slf4j-2.10.0.jar

│ ├── logback-classic-1.2.3.jar

│ ├── logback-core-1.2.3.jar

│ ├── slf4j-api-1.7.25.jar

│ ├── snakeyaml-1.19.jar

│ ├── spring-aop-5.0.9.RELEASE.jar

│ ├── spring-beans-5.0.9.RELEASE.jar

│ ├── spring-boot-2.0.5.RELEASE.jar

│ ├── spring-boot-autoconfigure-2.0.5.RELEASE.jar

│ ├── spring-boot-starter-2.0.5.RELEASE.jar

│ ├── spring-boot-starter-json-2.0.5.RELEASE.jar

│ ├── spring-boot-starter-logging-2.0.5.RELEASE.jar

│ ├── spring-boot-starter-tomcat-2.0.5.RELEASE.jar

│ ├── spring-boot-starter-web-2.0.5.RELEASE.jar

│ ├── spring-context-5.0.9.RELEASE.jar

│ ├── spring-core-5.0.9.RELEASE.jar

│ ├── spring-expression-5.0.9.RELEASE.jar

│ ├── spring-jcl-5.0.9.RELEASE.jar

│ ├── spring-web-5.0.9.RELEASE.jar

│ ├── spring-webmvc-5.0.9.RELEASE.jar

│ ├── tomcat-embed-core-8.5.34.jar

│ ├── tomcat-embed-el-8.5.34.jar

│ ├── tomcat-embed-websocket-8.5.34.jar

│ └── validation-api-2.0.1.Final.jar

├── META-INF

│ ├── MANIFEST.MF

│ └── maven

│ └── org.springframework

└── org

└── springframework

└── boot

The advantage of this packaging is that the structure of the final jar package is clear and all the dependencies are clear at a glance. If you use maven shade, you will pile up all the class files so that you can't see the dependencies. The resulting jar package is almost equal in volume.

In the running mechanism, using FatJar technology to run the program needs to modify the jar package, and it also needs to customize its own ClassLoader to load the classes in the jar package nested in the lib directory in the jar package. We can compare the MANIFEST files of the two and we can see the obvious difference.

/ / Generated by Maven Shade Plugin

Manifest-Version: 1.0

Implementation-Title: gs-spring-boot

Implementation-Version: 0.1.0

Built-By: qianwp

Implementation-Vendor-Id: org.springframework

Created-By: Apache Maven 3.5.4

Build-Jdk: 1.8.0_191

Implementation-URL: https://projects.spring.io/spring-boot/#/spring-bo

Ot-starter-parent/gs-spring-boot

Main-Class: hello.Application

/ / Generated by SpringBootLoader Plugin

Manifest-Version: 1.0

Implementation-Title: gs-spring-boot

Implementation-Version: 0.1.0

Built-By: qianwp

Implementation-Vendor-Id: org.springframework

Spring-Boot-Version: 2.0.5.RELEASE

Main-Class: org.springframework.boot.loader.JarLauncher

Start-Class: hello.Application

Spring-Boot-Classes: BOOT-INF/classes/

Spring-Boot-Lib: BOOT-INF/lib/

Created-By: Apache Maven 3.5.4

Build-Jdk: 1.8.0_191

Implementation-URL: https://projects.spring.io/spring-boot/#/spring-bo

Ot-starter-parent/gs-spring-boot

SpringBoot replaces the Main-Class in the jar package with JarLauncher. A Start-Class parameter has also been added, and the class corresponding to this parameter is the real business main method entry. Let's take a look at what this JarLaucher did.

Public class JarLauncher {

...

Static void main (String [] args) {

New JarLauncher () launch (args)

}

Protected void launch (String [] args) {

Try {

JarFile.registerUrlProtocolHandler ()

ClassLoader cl = createClassLoader (getClassPathArchives ())

Launch (args, getMainClass (), cl)

}

Catch (Exception ex) {

Ex.printStackTrace ()

System.exit (1)

}

}

Protected void launch (String [] args, String mcls, ClassLoader cl) {

Runnable runner = createMainMethodRunner (mcls, args, cl)

Thread runnerThread = new Thread (runner)

RunnerThread.setContextClassLoader (classLoader)

RunnerThread.setName (Thread.currentThread () .getName ())

RunnerThread.start ()

}

}

Class MainMethodRunner {

@ Override

Public void run () {

Try {

Thread th = Thread.currentThread ()

ClassLoader cl = th.getContextClassLoader ()

Class mc = cl.loadClass (this.mainClassName)

Method mm = mc.getDeclaredMethod ("main", String [] .class)

If (mm = = null) {

Throw new IllegalStateException (this.mainClassName

+ "does not have a main method")

}

Mm.invoke (null, new Object [] {this.args})

} catch (Exception ex) {

Ex.printStackTrace ()

System.exit (1)

}

}

}

You can see from the source code that JarLaucher creates a special ClassLoader, and then this ClassLoader starts a separate thread to load the MainClass and run it.

Another problem arises, when JVM encounters a class that you don't know, and there are so many jar packages in the BOOT-INF/lib directory, how does it know which jar package to load? Let's continue to look at the source code of this particular ClassLoader.

Class LaunchedURLClassLoader extends URLClassLoader {

...

Private Class doLoadClass (String name) {

If (this.rootClassLoader! = null) {

Return this.rootClassLoader.loadClass (name)

}

FindPackage (name)

Class cls = findClass (name)

Return cls

}

}

The rootClassLoader here is the ExtensionClassLoader in the parent delegation model, which is preferentially used by the JVM built-in classes to load. If it's not built-in, look for the corresponding Package for this class.

Private void findPackage (final String name) {

Int lastDot = name.lastIndexOf ('.')

If (lastDot! =-1) {

String packageName = name.substring (0, lastDot)

If (getPackage (packageName) = = null) {

Try {

DefinePackage (name, packageName)

} catch (Exception ex) {

/ / Swallow and continue

}

}

}

}

Private final HashMap packages = new HashMap ()

Protected Package getPackage (String name) {

Package pkg

Synchronized (packages) {

Pkg = packages.get (name)

}

If (pkg = = null) {

If (parent! = null) {

Pkg = parent.getPackage (name)

} else {

Pkg = Package.getSystemPackage (name)

}

If (pkg! = null) {

Synchronized (packages) {

Package pkg2 = packages.get (name)

If (pkg2 = = null) {

Packages.put (name, pkg)

} else {

Pkg = pkg2

}

}

}

}

Return pkg

}

Private void definePackage (String name, String packageName) {

String path = name.replace ('.','/') .concat (".class")

For (URL url: getURLs ()) {

Try {

If (url.getContent () instanceof JarFile) {

JarFile jf= (JarFile) url.getContent ()

If (jf.getJarEntryData (path)! = null & & jf.getManifest ()! = null) {

DefinePackage (packageName, jf.getManifest (), url)

Return null

}

}

} catch (IOException ex) {

/ / Ignore

}

}

Return null

}

ClassLoader will cache the mapping relationship between the package name and the jar package path locally. If the corresponding package name cannot be found in the cache, it will have to go through the jar package one by one, which is relatively slow. However, the same package name will only be searched once, and next time the corresponding embedded jar package path can be obtained directly from the cache.

The deep jar package's embedded class URL path is as long as this, using an exclamation point! Split up

JarVera filebank use workspaceplicSpringbootlydemodemoqqtargetUniverse application.jarmarketBOOTWhen INFActionlibWithsnakeyamlly1.19.jarCubplication1.19.jarlUnixplicationworkspaceUniplicationSpringbootlydemodemographyaml.com Yaml.class

However, this custom ClassLoader will only be used to package the runtime, and the main method will be loaded and run directly using the system class loader in the IDE development environment.

I have to say that the design of SpringbootLoader is very interesting, it is very lightweight, the code logic is very independent and has no other dependencies, and it is also one of the points that SpringBoot deserves to appreciate.

HelloController automatic registration

The last question left is that HelloController is not referenced by the code. How does it register with the Tomcat service? It relies on the annotation delivery mechanism.

SpringBoot relies heavily on annotations for automatic assembly of configurations. It has invented dozens of annotations of its own, which really adds to the mental burden of developers. You need to read the documentation carefully to know what it is for. The form and function of Java annotations are separated, and the decorator which is different from Python is functional. Java annotations are like code comments, which have only attributes but no logic. The corresponding functions of annotations are completed by the code scattered elsewhere. It is necessary to analyze the annotated class structure in order to get the corresponding annotated attributes.

So how are the comments delivered?

@ SpringBootApplication

Public class Application {

Public static void main (String [] args) {

SpringApplication.run (Application.class, args)

}

}

@ ComponentScan

Public @ interface SpringBootApplication {

...

}

Public @ interface ComponentScan {

String [] basePackages () default {}

}

The first annotation that can be seen by the main method is SpringBootApplication, which is defined by the ComponentScan annotation. The ComponentScan annotation defines a scanned package name, which is the current package path if no definition is displayed. When SpringBoot encounters ComponentScan comments, it scans all Class under the corresponding package path and continues subsequent processing based on other annotations marked on these Class. When it scans to the HelloController class, it finds that it is annotated with RestController annotations.

@ RestController

Public class HelloController {

...

}

@ Controller

Public @ interface RestController {

}

RestController annotations are annotated with Controller annotations. SpringBoot has special treatment for Controller annotations, registering the classes annotated by Controller as URL handlers in Servlet's request handler, and passing the request handler in when the Tomcat Server is created. This is how HelloController is automatically assembled into Tomcat.

Scanning annotations is a very tedious and dirty task, especially this advanced method of using annotations to annotate (around mouth), which should be used with less caution. There is a lot of annotated code in SpringBoot. Trying to understand this code is boring and unnecessary, it will only confuse your otherwise sober head. SpringBoot is very convenient for students who are used to it, but its internal implementation code should not be easily imitated, it is definitely not a model Java code.

At this point, I believe you have a deeper understanding of "how SpringBoot runs". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.