详解spring boot应用启动原理分析

git clone git@github.com:hengyunabc/spring-boot-demo.git
mvn spring-boot-demo
java -jar target/demo-0.0.1-snapshot.jar

demo-0.0.1-snapshot.jar
demo-0.0.1-snapshot.jar.original

├── meta-inf
│ ├── manifest.mf
├── application.properties
├── com
│ └── example
│  └── springbootdemoapplication.class
├── lib
│ ├── aopalliance-1.0.jar
│ ├── spring-beans-4.2.3.release.jar
│ ├── ...
└── org
 └── springframework
  └── boot
   └── loader
    ├── executablearchivelauncher.class
    ├── jarlauncher.class
    ├── javaagentdetector.class
    ├── launchedurlclassloader.class
    ├── launcher.class
    ├── mainmethodrunner.class
    ├── ...

manifest-version: 1.0
start-class: com.example.springbootdemoapplication
implementation-vendor-id: com.example
spring-boot-version: 1.3.0.release
created-by: apache maven 3.3.3
build-jdk: 1.8.0_60
implementation-vendor: pivotal software, inc.
main-class: org.springframework.boot.loader.jarlauncher

@springbootapplication
public class springbootdemoapplication {

 public static void main(string[] args) {
  springapplication.run(springbootdemoapplication.class, args);
 }
}

public abstract class archive {
 public abstract url geturl();
 public string getmainclass();
 public abstract collection<entry> getentries();
 public abstract list<archive> getnestedarchives(entryfilter filter);

jar:file:/tmp/target/demo-0.0.1-snapshot.jar!/

jar:file:/tmp/target/demo-0.0.1-snapshot.jar!/lib/aopalliance-1.0.jar
jar:file:/tmp/target/demo-0.0.1-snapshot.jar!/lib/spring-beans-4.2.3.release.jar

class jarlauncher extends executablearchivelauncher
class executablearchivelauncher extends launcher

protected final archive createarchive() throws exception {
 protectiondomain protectiondomain = getclass().getprotectiondomain();
 codesource codesource = protectiondomain.getcodesource();
 uri location = (codesource == null ? null : codesource.getlocation().touri());
 string path = (location == null ? null : location.getschemespecificpart());
 if (path == null) {
 throw new illegalstateexception("unable to determine code source archive");
 }
 file root = new file(path);
 if (!root.exists()) {
 throw new illegalstateexception(
 "unable to determine code source archive from " + root);
 }
 return (root.isdirectory() ? new explodedarchive(root)
 : new jarfilearchive(root));
}

/**
 * launch the application given the archive file and a fully configured classloader.
 */
protected void launch(string[] args, string mainclass, classloader classloader)
 throws exception {
 runnable runner = createmainmethodrunner(mainclass, args, classloader);
 thread runnerthread = new thread(runner);
 runnerthread.setcontextclassloader(classloader);
 runnerthread.setname(thread.currentthread().getname());
 runnerthread.start();
}

/**
 * create the {@code mainmethodrunner} used to launch the application.
 */
protected runnable createmainmethodrunner(string mainclass, string[] args,
 classloader classloader) throws exception {
 class<?> runnerclass = classloader.loadclass(runner_class);
 constructor<?> constructor = runnerclass.getconstructor(string.class,
 string[].class);
 return (runnable) constructor.newinstance(mainclass, args);
}

jar:file:/tmp/target/demo-0.0.1-snapshot.jar!/

public url(string protocol,
   string host,
   int port,
   string file,
   urlstreamhandler handler)
 throws malformedurlexception

//org.springframework.boot.loader.jar.handler
public class handler extends urlstreamhandler {
 private static final string separator = "!/";
 private static softreference<map<file, jarfile>> rootfilecache;
 @override
 protected urlconnection openconnection(url url) throws ioexception {
 if (this.jarfile != null) {
 return new jarurlconnection(url, this.jarfile);
 }
 try {
 return new jarurlconnection(url, getrootjarfilefromurl(url));
 }
 catch (exception ex) {
 return openfallbackconnection(url, ex);
 }
 }
 public jarfile getrootjarfilefromurl(url url) throws ioexception {
 string spec = url.getfile();
 int separatorindex = spec.indexof(separator);
 if (separatorindex == -1) {
 throw new malformedurlexception("jar url does not contain !/ separator");
 }
 string name = spec.substring(0, separatorindex);
 return getrootjarfile(name);
 }

public url findresource(string name)
public inputstream getresourceasstream(string name)

//org.springframework.boot.loader.jar.jarurlconnection
 @override
 public inputstream getinputstream() throws ioexception {
 connect();
 if (this.jarentryname.isempty()) {
 throw new ioexception("no entry name specified");
 }
 return this.jarentrydata.getinputstream();
 }

urlclasspath ucp = new urlclasspath(urls);

 resource getresource(final string name, boolean check) {
 final url url;
 try {
  url = new url(base, parseutil.encodepath(name, false));
 } catch (malformedurlexception e) {
  throw new illegalargumentexception("name");
 }
 final urlconnection uc;
 try {
  if (check) {
   urlclasspath.check(url);
  }
  uc = url.openconnection();
  inputstream in = uc.getinputstream();
  if (uc instanceof jarurlconnection) {
   /* need to remember the jar file so it can be closed
    * in a hurry.
    */
   jarurlconnection juc = (jarurlconnection)uc;
   jarfile = jarloader.checkjar(juc.getjarfile());
  }
 } catch (exception e) {
  return null;
 }
 return new resource() {
  public string getname() { return name; }
  public url geturl() { return url; }
  public url getcodesourceurl() { return base; }
  public inputstream getinputstream() throws ioexception {
   return uc.getinputstream();
  }
  public int getcontentlength() throws ioexception {
   return uc.getcontentlength();
  }
 };
}

@springbootapplication
public class springbootdemoapplication {

 public static void main(string[] args) {
  springapplication.run(springbootdemoapplication.class, args);
 }
}

java org.springframework.boot.loader.jarlauncher

private static final string[] web_environment_classes = { "javax.servlet.servlet",
 "org.springframework.web.context.configurablewebapplicationcontext" };

private boolean deducewebenvironment() {
 for (string classname : web_environment_classes) {
  if (!classutils.ispresent(classname, null)) {
   return false;
  }
 }
 return true;
}

//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) {
 throw new illegalstateexception(
  "unable create a default applicationcontext, "
  + "please specify an applicationcontextclass",
  ex);
 }
 }
 return (configurableapplicationcontext) beanutils.instantiate(contextclass);
 }

//tomcatembeddedservletcontainerfactory
@override
public embeddedservletcontainer getembeddedservletcontainer(
  servletcontextinitializer... initializers) {
 tomcat tomcat = new tomcat();
 file basedir = (this.basedirectory != null ? this.basedirectory
   : createtempdir("tomcat"));
 tomcat.setbasedir(basedir.getabsolutepath());
 connector connector = new connector(this.protocol);
 tomcat.getservice().addconnector(connector);
 customizeconnector(connector);
 tomcat.setconnector(connector);
 tomcat.gethost().setautodeploy(false);
 tomcat.getengine().setbackgroundprocessordelay(-1);
 for (connector additionalconnector : this.additionaltomcatconnectors) {
  tomcat.getservice().addconnector(additionalconnector);
 }
 preparecontext(tomcat.gethost(), initializers);
 return gettomcatembeddedservletcontainer(tomcat);
}

private void adddefaultservlet(context context) {
 wrapper defaultservlet = context.createwrapper();
 defaultservlet.setname("default");
 defaultservlet.setservletclass("org.apache.catalina.servlets.defaultservlet");
 defaultservlet.addinitparameter("debug", "0");
 defaultservlet.addinitparameter("listings", "false");
 defaultservlet.setloadonstartup(1);
 // otherwise the default location of a spring dispatcherservlet cannot be set
 defaultservlet.setoverridable(true);
 context.addchild(defaultservlet);
 context.addservletmapping("/", "default");
}

private void addjspservlet(context context) {
 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");
}

//resourceproperties
public class resourceproperties implements resourceloaderaware {

 private static final string[] servlet_resource_locations = { "/" };

 private static final string[] classpath_resource_locations = {
 "classpath:/meta-inf/resources/", "classpath:/resources/",
 "classpath:/static/", "classpath:/public/" };
 

//webmvcautoconfigurationadapter
 @override
 public void addviewcontrollers(viewcontrollerregistry registry) {
 resource page = this.resourceproperties.getwelcomepage();
 if (page != null) {
 logger.info("adding welcome page: " + page);
 registry.addviewcontroller("/").setviewname("forward:");
 }
 }

public static final string default_prefix = "classpath:/templates/";

spring.view.prefix: /web-inf/jsp/

@controller
@requestmapping("${server.error.path:${error.path:/error}}")
public class basicerrorcontroller extends abstracterrorcontroller

@configuration
@conditionalonproperty(prefix = "server.error.whitelabel", name = "enabled", matchifmissing = true)
@conditional(errortemplatemissingcondition.class)
protected static class whitelabelerrorviewconfiguration {

 private final spelview defaulterrorview = new spelview(
 "<html><body><h1>whitelabel error page</h1>"
  + "<p>this application has no explicit mapping for /error, so you are seeing this as a fallback.</p>"
  + "<div id='created'>${timestamp}</div>"
  + "<div>there was an unexpected error (type=${error}, status=${status}).</div>"
  + "<div>${message}</div></body></html>");

 @bean(name = "error")
 @conditionalonmissingbean(name = "error")
 public view defaulterrorview() {
 return this.defaulterrorview;
 }

spring.output.ansi.enabled=false

public class launchedurlclassloader extends urlclassloader {

 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)
 throws classnotfoundexception {
 synchronized (launchedurlclassloader.lock_provider.getlock(this, name)) {
 class<?> loadedclass = findloadedclass(name);
 if (loadedclass == null) {
 handler.setusefastconnectionexceptions(true);
 try {
  loadedclass = doloadclass(name);
 }
 finally {
  handler.setusefastconnectionexceptions(false);
 }
 }
 if (resolve) {
 resolveclass(loadedclass);
 }
 return loadedclass;
 }
 }

private static final string java_agent_prefix = "-javaagent:";

 private string getpid() {
 try {
 string jvmname = managementfactory.getruntimemxbean().getname();
 return jvmname.split("@")[0];
 }
 catch (throwable ex) {
 return null;
 }
}

 private class<?> deducemainapplicationclass() {
 try {
  stacktraceelement[] stacktrace = new runtimeexception().getstacktrace();
  for (stacktraceelement stacktraceelement : stacktrace) {
   if ("main".equals(stacktraceelement.getmethodname())) {
    return class.forname(stacktraceelement.getclassname());
   }
  }
 }
 catch (classnotfoundexception ex) {
  // swallow and continue
 }
 return null;
}