Spring Boot運行原理

時間 2019-11-08

標籤 spring boot 運行原理欄目 Spring 简体版

原文原文鏈接

概述

　　　　本文主要寫了下Spring Boot運行原理，還有一個小例子。java

　　　　Spring4.x提供了基於條件來配置Bean的能力，而Spring Boot的實現也是基於這一原理的。web

　　　　Spring Boot關於自動配置的源碼在spring-boot-autoconfigure-1.3.0.x.jar內。若是想知道Spring Boot爲咱們作了哪些自動配置，能夠查看這裏的源碼。spring

　　　　能夠經過下面的幾種方式查看當前項目中已啓用可未啓用的自動配置的報告：安全

　　　　　　　　1：運行jar時添加--debug參數：java -jar xx.jar --debug。session

　　　　　　　　2：在application.properties中設置屬性：debug=true。app

　　　　　　　　3：也能夠在開發工具中配置運行時參數，此處就再也不截圖了。ide

Spring Boot運做原理

　　　　關於Spring Boot的運做原理，仍是要看@SpringBootApplication註解，這個註解是一個組合註解，它的核心功能是由@EnableAutoConfiguration註解提供的。spring-boot

　　　　@EnableAutoConfiguration註解的源碼以下：工具

 1 //
 2 // Source code recreated from a .class file by IntelliJ IDEA
 3 // (powered by Fernflower decompiler)
 4 //
 5 
 6 package org.springframework.boot.autoconfigure;
 7 
 8 import java.lang.annotation.Documented;
 9 import java.lang.annotation.ElementType;
10 import java.lang.annotation.Inherited;
11 import java.lang.annotation.Retention;
12 import java.lang.annotation.RetentionPolicy;
13 import java.lang.annotation.Target;
14 import org.springframework.boot.autoconfigure.AutoConfigurationPackages.Registrar;
15 import org.springframework.context.annotation.Import;
16 
17 @Target({ElementType.TYPE})
18 @Retention(RetentionPolicy.RUNTIME)
19 @Documented
20 @Inherited
21 @Import({EnableAutoConfigurationImportSelector.class, Registrar.class})
22 public @interface EnableAutoConfiguration {
23     Class<?>[] exclude() default {};
24 
25     String[] excludeName() default {};
26 }

　　　　這裏的關鍵功能是@Import註解導入的配置功能，EnableAutoConfigurationImportSelector使用SpringFactoriesLoador.loadFactoryNames方法來掃描具備META-INF/spring.factories文件的jar包。開發工具

　　　　spring.factories文件中聲名了一些自動配置，如：

　　　　打開上面任意一個類，通常都有下面的條件註解，在spring-boot-autoconfigure-1.3.0.x.jar的org.springframwork.boot.autoconfigure.condition包下，條件註解以下。

　　　　　　　　@ConditionalOnBean：當容器裏有指定的Bean的條件下。

　　　　　　　　@ConditionalOnClass：當類路徑下有指定的類的條件下。
　　　　　　　　@ConditionalOnExpression：基於SpEL表達式做爲判斷條件。
　　　　　　　　@ConditionalOnOnJava：基於JVM版本做爲判斷條件。
　　　　　　　　@ConditionalOnJndi：在JNDI存在的條件下查找指定的位置。
　　　　　　　　@ConditionalOnMissingBean：當容器裏沒有指定Bean的狀況下。
　　　　　　　　@ConditionalOnMissingClass：當類路徑下沒有指定的類的條件下。
　　　　　　　　@ConditionalOnNotWebApplication：當前項目不是Web項目的條件下。
　　　　　　　　@ConditionalOnProperty：指定的屬性是否有指定的值。
　　　　　　　　@ConditionalOnResource：類路徑是否有指定的值。
　　　　　　　　@ConditionalOnSingleCandidate：當·指定Bean在容器中只有一個，或者雖然有多個可是指定首選的Bean。
　　　　　　　　@ConditionalOnWenApplication：當前項目是Web項目的條件下。

　　　　這些註解都是組合了@Conditional元註解，只是使用了不一樣的條件。

　　　　下面咱們來分析一下@ConditionalOnWebApplication註解。

 1 //
 2 // Source code recreated from a .class file by IntelliJ IDEA
 3 // (powered by Fernflower decompiler)
 4 //
 5 
 6 package org.springframework.boot.autoconfigure.condition;
 7 
 8 import java.lang.annotation.Documented;
 9 import java.lang.annotation.ElementType;
10 import java.lang.annotation.Retention;
11 import java.lang.annotation.RetentionPolicy;
12 import java.lang.annotation.Target;
13 import org.springframework.context.annotation.Conditional;
14 
15 @Target({ElementType.TYPE, ElementType.METHOD})
16 @Retention(RetentionPolicy.RUNTIME)
17 @Documented
18 @Conditional({OnWebApplicationCondition.class})
19 public @interface ConditionalOnWebApplication {
20 }

ConditionalOnWebApplication源碼

　　　　從源碼能夠看出，此註解使用的條件是OnWebApplicationCondition，下面咱們來看看這個條件是如何構造的：

 1 //
 2 // Source code recreated from a .class file by IntelliJ IDEA
 3 // (powered by Fernflower decompiler)
 4 //
 5 
 6 package org.springframework.boot.autoconfigure.condition;
 7 
 8 import org.springframework.context.annotation.ConditionContext;
 9 import org.springframework.core.annotation.Order;
10 import org.springframework.core.type.AnnotatedTypeMetadata;
11 import org.springframework.util.ClassUtils;
12 import org.springframework.util.ObjectUtils;
13 import org.springframework.web.context.WebApplicationContext;
14 import org.springframework.web.context.support.StandardServletEnvironment;
15 
16 @Order(-2147483628)
17 class OnWebApplicationCondition extends SpringBootCondition {
18     private static final String WEB_CONTEXT_CLASS = "org.springframework.web.context.support.GenericWebApplicationContext";
19 
20     OnWebApplicationCondition() {
21     }
22 
23     public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
24         boolean webApplicationRequired = metadata.isAnnotated(ConditionalOnWebApplication.class.getName());
25         ConditionOutcome webApplication = this.isWebApplication(context, metadata);
26         if (webApplicationRequired && !webApplication.isMatch()) {
27             return ConditionOutcome.noMatch(webApplication.getMessage());
28         } else {
29             return !webApplicationRequired && webApplication.isMatch() ? ConditionOutcome.noMatch(webApplication.getMessage()) : ConditionOutcome.match(webApplication.getMessage());
30         }
31     }
32 
33     private ConditionOutcome isWebApplication(ConditionContext context, AnnotatedTypeMetadata metadata) {
34         if (!ClassUtils.isPresent("org.springframework.web.context.support.GenericWebApplicationContext", context.getClassLoader())) {
35             return ConditionOutcome.noMatch("web application classes not found");
36         } else {
37             if (context.getBeanFactory() != null) {
38                 String[] scopes = context.getBeanFactory().getRegisteredScopeNames();
39                 if (ObjectUtils.containsElement(scopes, "session")) {
40                     return ConditionOutcome.match("found web application 'session' scope");
41                 }
42             }
43 
44             if (context.getEnvironment() instanceof StandardServletEnvironment) {
45                 return ConditionOutcome.match("found web application StandardServletEnvironment");
46             } else {
47                 return context.getResourceLoader() instanceof WebApplicationContext ? ConditionOutcome.match("found web application WebApplicationContext") : ConditionOutcome.noMatch("not a web application");
48             }
49         }
50     }
51 }

OnWebApplicationCondition源碼

　　　　從isWebApplication方法能夠看出，判斷條件是：

　　　　　　　　1：GenericWebApplicationContext是否在類路徑中；

　　　　　　　　2：容器裏是否有名爲session的scope；

　　　　　　　　3：當前容器的Enviroment是否爲StandardServletEnvironment；

　　　　　　　　4：當前的ResourceLoader是否爲WebApplicationContext(ResourceLoador是ApplicationContext的頂級接口之一)；

　　　　　　　　5：咱們須要構造ConditionOutcome類的對象來幫助咱們，最終經過ContitionOutcome.isMatch方法來返回布爾值來肯定條件；

實例分析

　　　　經過上面寫的，咱們初步瞭解了Spring Boot的運做原理和主要的條件註解，下面來分析一個簡單的Spring Boot內置的自動配置功能：http的編碼配置。

　　　　在常規項目中，http編碼通常是在web.xml中配置一個filter，以下：

 1 <filter>
 2     <filter-name>encodingFilter</filter-name>
 3     <filter-class>
 4         org.springframework.web.filter.CharacterEncodingFilter
 5     </filter-class>
 6     <init-param>
 7         <param-name>encoding</param-name>
 8         <param-value>UTF-8</param-value>
 9     </init-param>
10     <init-param>
11         <param-name>forceEncoding</param-name>
12         <param-value>true</param-value>
13     </init-param>
14 </filter>

　　　　由上可見，自動配置要知足兩個條件：

　　　　　　　　1：能配置CharacterEncodingFilter這個Bean；

　　　　　　　　2：能配置encoding和forceEncoding這兩個參數；

　　　　配置參數：

　　　　　　　　Spring Boot的自動配置是基於類型安全的配置，關於http編碼的配置在HttpEncodingProperties類中，源碼以下：

 1 //
 2 // Source code recreated from a .class file by IntelliJ IDEA
 3 // (powered by Fernflower decompiler)
 4 //
 5 
 6 package org.springframework.boot.autoconfigure.web;
 7 
 8 import java.nio.charset.Charset;
 9 import org.springframework.boot.context.properties.ConfigurationProperties;
10 
11 @ConfigurationProperties(
12         prefix = "spring.http.encoding"//在application.properties配置的時候前綴是spring.http.encoding。
13 )
14 public class HttpEncodingProperties {
15     public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");//默認編碼方式UTF-8，若是要修改可使用：spring.http.encoding.charset=編碼。
16     private Charset charset;
17     private boolean force;
18 
19     public HttpEncodingProperties() {
20         this.charset = DEFAULT_CHARSET;
21         this.force = true;//設置forceEncoding，默認爲true，若果要修改可使用spring.http.encoding.force=false。
22     }
23 
24     public Charset getCharset() {
25         return this.charset;
26     }
27 
28     public void setCharset(Charset charset) {
29         this.charset = charset;
30     }
31 
32     public boolean isForce() {
33         return this.force;
34     }
35 
36     public void setForce(boolean force) {
37         this.force = force;
38     }
39 }

HttpEncodingProperties源碼

　　　　配置Bean：

　　　　　　　　經過調用上面的配置，並根據條件配置CharacterEncodingFilter的Bean，源碼以下：

 1 //
 2 // Source code recreated from a .class file by IntelliJ IDEA
 3 // (powered by Fernflower decompiler)
 4 //
 5 
 6 package org.springframework.boot.autoconfigure.web;
 7 
 8 import org.springframework.beans.factory.annotation.Autowired;
 9 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
10 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
11 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
12 import org.springframework.boot.context.properties.EnableConfigurationProperties;
13 import org.springframework.boot.context.web.OrderedCharacterEncodingFilter;
14 import org.springframework.context.annotation.Bean;
15 import org.springframework.context.annotation.Configuration;
16 import org.springframework.web.filter.CharacterEncodingFilter;
17 
18 @Configuration
19 @EnableConfigurationProperties({HttpEncodingProperties.class})//開啓屬性注入，經過@EnableConfigurationProperties聲明，使用@Autowired注入。
20 @ConditionalOnClass({CharacterEncodingFilter.class})//當CharacterEncodingFilter在類路徑的條件下
21 @ConditionalOnProperty(
22         prefix = "spring.http.encoding",
23         value = {"enabled"},//當設置spring.http.encoding=enabled的狀況下
24         matchIfMissing = true//若是沒有設置，則默認爲true，即條件符合。
25 )
26 public class HttpEncodingAutoConfiguration {
27     @Autowired
28     private HttpEncodingProperties httpEncodingProperties;
29 
30     public HttpEncodingAutoConfiguration() {
31     }
32 
33     @Bean//使用Java配置的方式配置CharacterEncodingFilter這個bean。
34     @ConditionalOnMissingBean({CharacterEncodingFilter.class})//若是容器中沒有這個bean的時候新建bean。
35     public CharacterEncodingFilter characterEncodingFilter() {
36         CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
37         filter.setEncoding(this.httpEncodingProperties.getCharset().name());
38         filter.setForceEncoding(this.httpEncodingProperties.isForce());
39         return filter;
40     }
41 }

HttpEncodingAutoConfiguration源碼

本身寫一個starter pom

　　　　咱們也能夠仿照上面http編碼配置的例子本身寫一個自動配置。代碼以下：

 1 package com.wisely.spring_boot_starter_hello;
 2 
 3 import org.springframework.boot.context.properties.ConfigurationProperties;
 4 
 5 /**
 6  * 屬性配置
 7  */
 8 @ConfigurationProperties(prefix = "hello")
 9 public class HelloServiceProperties {
10 
11     private static final String MSG = "world";
12     
13     private String msg = MSG;
14 
15     public String getMsg() {
16         return msg;
17     }
18 
19     public void setMsg(String msg) {
20         this.msg = msg;
21     }
22 }

屬性配置

 1 package com.wisely.spring_boot_starter_hello;
 2 
 3 /**
 4  * 判斷依據類
 5  */
 6 public class HelloService {
 7     private String msg;
 8 
 9     public String sayHello() {
10         return "Hello" + msg;
11     }
12 
13     public String getMsg() {
14         return msg;
15     }
16 
17     public void setMsg(String msg) {
18         this.msg = msg;
19     }
20 }

判斷依據類

 1 package com.wisely.spring_boot_starter_hello;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 5 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 6 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 7 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 8 import org.springframework.context.annotation.Bean;
 9 import org.springframework.context.annotation.Configuration;
10 
11 /**
12  * 自動配置類
13  */
14 @Configuration
15 @EnableConfigurationProperties(HelloServiceProperties.class)
16 @ConditionalOnClass(HelloService.class)
17 @ConditionalOnProperty(prefix = "hello", value = "enabled", matchIfMissing = true)
18 public class HelloServiceAutoConfiguration {
19 
20     @Autowired
21     private HelloServiceProperties helloServiceProperties;
22 
23     @Bean
24     @ConditionalOnMissingBean(HelloService.class)
25     public HelloService helloService() {
26         HelloService helloService = new HelloService();
27         helloService.setMsg(helloServiceProperties.getMsg());
28         return helloService;
29     }
30 }

自動配置類

　　　　在src/main/resources下新建META-INF/spring.factories，並添加代碼：

　　　　而後新建一個項目，在pom.xml添加依賴

　　　　最後運行看效果。

 1 package com.wisely.ch6_5;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.boot.SpringApplication;
 5 import org.springframework.boot.autoconfigure.SpringBootApplication;
 6 import org.springframework.web.bind.annotation.RequestMapping;
 7 import org.springframework.web.bind.annotation.RestController;
 8 
 9 import com.wisely.spring_boot_starter_hello.HelloService;
10 @RestController
11 @SpringBootApplication
12 public class Ch65Application {
13     
14     @Autowired
15     HelloService helloService;
16     
17     @RequestMapping("/")
18     public String index(){
19         return helloService.sayHello();
20     }
21 
22     public static void main(String[] args) {
23         SpringApplication.run(Ch65Application.class, args);
24     }
25 }

運行

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。