Spring Boot 2.0 Source Analysis (iii)

Through the source analysis in the previous chapter, we know what the listeners is in spring boot (meta-inf/ Spring.factories defines an instance of the resource), and it is created and started, today we continue in-depth analysis of the other contents of the run function in the Springapplication instance variable. Let's put the code for the run function first:

    /*** Run The Spring application, creating and refreshing a new     * {@link ApplicationContext}.     * @param argsThe application arguments (usually passed from a Java Main method)     * @returna running{@link ApplicationContext}     */     PublicConfigurableapplicationcontextRun(String... args) {StopWatch StopWatch =New StopWatch(); StopWatch.Start(); Configurableapplicationcontext context =NULL; Collection<springbootexceptionreporter> exceptionreporters =NewArraylist<> ();Configureheadlessproperty(); Springapplicationrunlisteners listeners =getrunlisteners(args); Listeners.starting();Try{Applicationarguments applicationarguments =New defaultapplicationarguments(args); Configurableenvironment environment =prepareenvironment(listeners, applicationarguments);Configureignorebeaninfo(environment); Banner Printedbanner =Printbanner(environment); Context =CreateApplicationContext(); Exceptionreporters =getspringfactoriesinstances(Springbootexceptionreporter.class,NewClass[] {configurableapplicationcontext.class}, context);Preparecontext(context, environment, listeners, applicationarguments, Printedbanner);Refreshcontext(context);AfterRefresh(context, applicationarguments); StopWatch.Stop();if( This.Logstartupinfo) {New Startupinfologger( This.Mainapplicationclass)                        .logstarted(Getapplicationlog(), StopWatch); } listeners.started(context);callrunners(context, applicationarguments); }Catch(Throwable ex) {handlerunfailure(Context, ex, exceptionreporters, listeners);Throw NewIllegalStateException (ex); }Try{listeners.Running(context); }Catch(Throwable ex) {handlerunfailure(Context, ex, Exceptionreporters,NULL);Throw NewIllegalStateException (ex); }returnContext }

After listeners started, let's take a look at applicationarguments applicationarguments
= new Defaultapplicationarguments (args); In Defaultapplicationarguments's constructor, we trace the Simplecommandlineargsparser.parse function that found its final call in the past:

 PublicCommandLineArgsParse(String... args) {CommandLineArgs CommandLineArgs =New CommandLineArgs(); string[] Var3 = args;intVAR4 = args.length; for(intVAR5 =0; Var5 < VAR4; ++VAR5) {String arg = VAR3[VAR5];if(Arg.StartsWith("--") {String Optiontext = arg.substring(2, Arg.length()); String OptionValue =NULL; String Optionname;if(Optiontext.contains("=") {Optionname = Optiontext.substring(0, Optiontext.indexOf( A)); OptionValue = Optiontext.substring(Optiontext.indexOf( A) +1, Optiontext.length()); }Else{optionname = Optiontext; }if(Optionname.IsEmpty() || OptionValue! =NULL&& OptionValue.IsEmpty()) {Throw NewIllegalArgumentException ("Invalid argument syntax:"+ arg); } CommandLineArgs.Addoptionarg(Optionname, OptionValue); }Else{CommandLineArgs.Addnonoptionarg(ARG); }        }returnCommandLineArgs; }

From this code we see that defaultapplicationarguments is actually reading the command line arguments.

Small discovery: By analyzing the definition of this function, do you think of the scenario of customizing the port number with command line parameters when spring boot starts?
Java-jar Myspringboot.jar--server.port=8000

Then look down: configurableenvironment environment = this.prepareenvironment (listeners, ex);
With this line of code we can see that spring boot passes the previously created listeners and command-line arguments to the Prepareenvironment function to prepare the running environment. Look at the true colors of the Prepareenvironment function:

    PrivateConfigurableenvironmentprepareenvironment(Springapplicationrunlisteners listeners, applicationarguments applicationarguments) {//Create and configure the environmentConfigurableenvironment environment =getorcreateenvironment();configureenvironment(Environment, Applicationarguments.Getsourceargs()); Listeners.environmentprepared(environment);bindtospringapplication(environment);if( This.Webapplicationtype= = Webapplicationtype.NONE) {environment =New Environmentconverter(getClassLoader())                    .converttostandardenvironmentifnecessary(environment); } configurationpropertysources.Attach(environment);returnenvironment; }

Here we see the environment is created through the getorcreateenvironment, and then dig deep getorcreateenvironment Source:

    privategetOrCreateEnvironment() {        if (this.environmentnull) {            returnthis.environment;        }        if (this.webApplicationType == WebApplicationType.SERVLET) {            returnnewStandardServletEnvironment();        }        returnnewStandardEnvironment();    }

Through this code we see that if environment already exists, it will return directly to the current environment.

Little thought: Under what circumstances will there be a situation where environment already exists? Tip: As we said earlier, you can initialize springapplication and then call the run function, what can happen between initializing Springapplication and calling the Run function?

The following code determines whether Webapplicationtype is a servlet, or, if it is, creates a servlet environment, or creates a basic environment. Let's dig a dig. Where is the Webapplicationtype initialized:

    Private Static FinalString Reactive_web_environment_class ="Org.springframework."+"Web.reactive.DispatcherHandler";Private Static FinalString Mvc_web_environment_class ="Org.springframework."+"Web.servlet.DispatcherServlet";/*** Create a new{@link Springapplication}instance. The application context would load* Beans from the specified primary sources ( see{@link springapplication class-level}* documentation for details. The instance can customized before calling     * {@link #run (String ...)}.     * @param resourceloaderThe resource loader to use     * @param primarysourcesThe primary bean sources     * @see #run (Class, string[])     * @see #setSources (Set)     */    @SuppressWarnings({"Unchecked","Rawtypes"}) Public springapplication(Resourceloader Resourceloader, class<?>... Primarysources) { This.Resourceloader= Resourceloader; Assert.Notnull(Primarysources,"primarysources must not being null"); This.primarysources=NewLinkedhashset<> (Arrays.aslist(primarysources)); This.Webapplicationtype=Deducewebapplicationtype();setinitializers((Collection)getspringfactoriesinstances(Applicationcontextinitializer.class));setlisteners((Collection)getspringfactoriesinstances(Applicationlistener.class)); This.Mainapplicationclass=Deducemainapplicationclass(); }PrivateWebapplicationtypeDeducewebapplicationtype() {if(Classutils.isPresent(Reactive_web_environment_class,NULL) &&! Classutils.isPresent(Mvc_web_environment_class,NULL)) {returnWebapplicationtype.Reactive; } for(String classname:web_environment_classes) {if(! Classutils.isPresent(ClassName,NULL)) {returnWebapplicationtype.NONE; }        }returnWebapplicationtype.SERVLET; }

Through this code, we discovered that the original spring boot was checked by checking for the presence of
in the current environment The Org.springframework.web.servlet.DispatcherServlet class to determine whether it is currently a web environment.
then look down and get the configurableenvironment environment to "fine-tune" The environment through the code that follows.
via This.configureignorebeaninfo (Environment); If the Spring.beaninfo.ignore property in system is empty, the properties in the current environment are overwritten:

 private   void  configureignorebeaninfo  (configurableenvironment environment) {if  (System. ( "Spring.beaninfo.ignore" ) = = null ) {Boolean Ignore = (Boolean) environment. getproperty  ( "Spring.beaninfo.ignore" , Boolean.) class , Boolean.            true ); System. setproperty  ( "Spring.beaninfo.ignore" , ignore. tostring         ()); }    }

by banner Printedbanner = This.printbanner (Environment), this line of code prints out Spring boot banner. Do you remember the picture that was displayed on the console when spring boot was started? Do not delve into this, continue to look down:
context = This.createapplicationcontext (); The application context was created:

     Public Static FinalString Default_context_class ="Org.springframework.context."+"annotation. Annotationconfigapplicationcontext "; Public Static FinalString Default_web_context_class ="Org.springframework.boot."+"Web.servlet.context.AnnotationConfigServletWebServerApplicationContext"; Public Static FinalString Default_reactive_web_context_class ="Org.springframework."+"Boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext";protectedConfigurableapplicationcontextCreateApplicationContext() {class<?> Contextclass = This.Applicationcontextclass;if(Contextclass = =NULL) {Try{Switch( This.Webapplicationtype) { CaseServlet:contextclass = Class.forname(Default_web_context_class); Break; CaseReactive:contextclass = Class.forname(Default_reactive_web_context_class); Break;default: Contextclass = Class.forname(Default_context_class); }            }Catch(ClassNotFoundException ex) {Throw NewIllegalStateException ("Unable create a default ApplicationContext,"+"Specify an Applicationcontextclass", ex); }        }return(Configurableapplicationcontext) Beanutils.Instantiateclass(Contextclass); }

Here we see that spring boot is based on different webapplicationtype types to create different applicationcontext.

Summary: Through the various deep digs above, we know how the environment in Spring Boot 2.0 distinguishes between a common environment and a web environment, and how to prepare the runtime environment and application context. Time is not early, today to share with you here, the next article will continue to share with you the Spring Boot 2.0 source code implementation.

Spring Boot 2.0 Source Analysis (iii)