SpringBoot——學習筆記
- 2020 年 3 月 16 日
- 筆記
關於微服務和SOA
這，僅是我學習過程中記錄的筆記。確定了一個待研究的主題，對這個主題進行全方面的剖析。筆記是用來方便我回顧與學習的，歡迎大家與我進行交流溝通，共同成長。不止是技術。
官網教程學習https://www.martinfowler.com/microservices/
關於微服務的認識
馬丁福樂的論文學習
DDD 領域驅動設計
component 組件
微服務數據治理與去中心化
任何的服務調用都會出現失敗的情況
熔斷器
微服務的優點和缺點
測試和向後兼容會變的更加的複雜
微服務與傳統單體應用項目的區別
微服務宏觀把控與深度剖析
ESB（企業服務匯流排）
SOA（面向服務架構）主要針對於企業級，單用ESB，需要序列化和反序列化，採用XML格式傳輸。
微服務架構主要用於互聯網公司。可以獨立運行。HTTP+REST+JSON
單體架構存在的缺點：
複雜性高，無法按需伸縮，阻礙技術創新，部署速度逐漸編碼，技術債務逐漸上升。
什麼是微服務？
簡而言之，微服務架構風格這種開發方法，是以開發一組小型服務的方式來開發一個獨立的應用系統。其中每個小型服務都運行在自己的進程中，並經常採用HTTP資源API這種輕量的機制來相互通訊。這些服務為夭折業務功能進行構建通過全自動的部署機制來進行獨立部署。這些服務可以用不同的語言來編寫，並且可以使用不同的數據存數技術。
微服務是一種架構風格
微服務的優點與挑戰
微服務具備的特性和設計原則
SOA理論和概念
SOA： Service oriented architecture 面向服務架構風格
SOA和微服務的差別
SOA原則：
SOA的設計模式：
實現方法：
SOA帶來的好處：
SOA的缺點：
SOA中微服務的介紹總結：
微服務的缺點介紹：
SOA與微服務的差別
SOA 著眼於企業，應用與應用。最大化的應用服務的可重用性，力度更大，
微服務 著眼於單個的應用,注重於解耦。力度更小。
SOA和微服務的區別、
結論：
SpringBoot
SpringBoot應用起步與配置
創建第一個可以運行的springboot項目
約定大於配置
在官網使用Spring initializr創建一個gradle的springboot項目使用vscode啟動。
遇到了問題，連不上vpn 依賴下載不動。經過不懈的努力。啟動成功。
Apollo（阿波羅）是攜程框架部門研發的分散式配置中心，能夠集中化管理應用不同環境、不同集群的配置，配置修改後能夠實時推送到應用端，並且具備規範的許可權、流程治理等特性，適用於微服務配置管理場景。服務端基於Spring Boot和Spring Cloud開發，打包後可以直接運行，不需要額外安裝Tomcat等應用容器。
springBoot 提供了兩種配置的文件形式：
-
Properties 文件形式： server.port=9090
-
yml文件形式 server:
prot:9090
springboot打包文件內容與結構分析
bootJar : 將項目打成了一個jar包 ， 可以直接運行的jar包
jar 命令： 查看當前的jar命令操作。
unzip : 解壓縮到一個目錄里，如圖
打成的jar包的目錄：
├── BOOT-INF
│ ├── classes
│ │ ├── application.properties
│ │ ├── com
│ │ │ └── test
│ │ │ └── demo
│ │ │ └── DemoApplication.class
│ │ ├── static
│ │ └── templates
│ └── lib
│ ├── classmate-1.5.1.jar
│ ├── hibernate-validator-6.0.18.Final.jar
│ ├── jackson-annotations-2.10.2.jar
│ ├── jackson-core-2.10.2.jar
│ ├── jackson-databind-2.10.2.jar
│ ├── jackson-datatype-jdk8-2.10.2.jar
│ ├── jackson-datatype-jsr310-2.10.2.jar
│ ├── jackson-module-parameter-names-2.10.2.jar
│ ├── jakarta.annotation-api-1.3.5.jar
│ ├── jakarta.validation-api-2.0.2.jar
│ ├── jboss-logging-3.4.1.Final.jar
│ ├── jul-to-slf4j-1.7.30.jar
│ ├── log4j-api-2.12.1.jar
│ ├── log4j-to-slf4j-2.12.1.jar
│ ├── logback-classic-1.2.3.jar
│ ├── logback-core-1.2.3.jar
│ ├── slf4j-api-1.7.30.jar
│ ├── snakeyaml-1.25.jar
│ ├── spring-aop-5.2.3.RELEASE.jar
│ ├── spring-beans-5.2.3.RELEASE.jar
│ ├── spring-boot-2.2.4.RELEASE.jar
│ ├── spring-boot-autoconfigure-2.2.4.RELEASE.jar
│ ├── spring-boot-starter-2.2.4.RELEASE.jar
│ ├── spring-boot-starter-json-2.2.4.RELEASE.jar
│ ├── spring-boot-starter-logging-2.2.4.RELEASE.jar
│ ├── spring-boot-starter-tomcat-2.2.4.RELEASE.jar
│ ├── spring-boot-starter-validation-2.2.4.RELEASE.jar
│ ├── spring-boot-starter-web-2.2.4.RELEASE.jar
│ ├── spring-context-5.2.3.RELEASE.jar
│ ├── spring-core-5.2.3.RELEASE.jar
│ ├── spring-expression-5.2.3.RELEASE.jar
│ ├── spring-jcl-5.2.3.RELEASE.jar
│ ├── spring-web-5.2.3.RELEASE.jar
│ ├── spring-webmvc-5.2.3.RELEASE.jar
│ ├── tomcat-embed-core-9.0.30.jar
│ ├── tomcat-embed-el-9.0.30.jar
│ └── tomcat-embed-websocket-9.0.30.jar
├── META-INF
│ └── MANIFEST.MF — 清單文件
└── org
└── springframework
└── boot
└── loader
├── ExecutableArchiveLauncher.class
├── archive
│ ├── Archive$Entry.class
│ └── JarFileArchive.class
├── data
│ ├── RandomAccessData.class
│ ├── RandomAccessDataFile$1.class
│ ├── RandomAccessDataFile$DataInputStream.class
│ ├── RandomAccessDataFile$FileAccess.class
│ └── RandomAccessDataFile.class
├── jar
│ ├── AsciiBytes.class ├── JarLauncher.class
META-INF中的MANIFEST.MF 清單文件
➜ META-INF cat MANIFEST.MF
Manifest-Version: 1.0
Start-Class: com.test.demo.DemoApplication
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Spring-Boot-Version: 2.2.4.RELEASE
Main-Class: org.springframework.boot.loader.JarLauncher
使用gradle搭建springboot第二個項目
build.gradle
這個地方遇到了一個小插曲。沒有網，gradle構建失敗，跟著影片上敲的springboot版本找不到。然後直接使用idea構建了一個springboot的項目。build.gradle內容如下：
plugins { id 'org.springframework.boot' version '2.2.4.RELEASE' id 'io.spring.dependency-management' version '1.0.9.RELEASE' id 'java' } group = 'com.erwa' version = '0.0.1-SNAPSHOT' sourceCompatibility = '1.8' repositories { mavenCentral() } dependencies { implementation 'org.springframework.boot:spring-boot-starter-web' testImplementation('org.springframework.boot:spring-boot-starter-test') { exclude group: 'org.junit.vintage', module: 'junit-vintage-engine' } } test { useJUnitPlatform() } springboot項目的執行方式有三種：
- 直接運行啟動類main方法
- 通過gradle, bootRun 啟動
- 通過命令行的方式
小插曲，在這裡，配置了一下Mac環境下的gradle的環境變數
springboot參數自動裝配練習與loader機制
MyConfig: erwaage: 20 erwaname: erwa@Value("${MyConfig.erwaname}") private String erwaname ; @Value("${MyConfig.erwaage}") private String erwaage;@AutoWired @configration @Bean
@Configuration public class MyConfig { @Bean public MyConfig myConfig(){ return new MyConfig(); } } @Autowired private MyConfig myConfig;java -jar xxx.jar 直接運行jar包
打包後的jar包中的org目錄來自於 spring-boot-loader包
spring_boot_Loader源碼分析及自定義類載入器的作用
gradle bootJar : 將項目打成jar包
java -jar xxx.jar : 運行jar包
能使用命令盡量使用命令。不然浪費了Mac
JarLauncher類
ClassLoader 類載入器，JVM課程中深入理解。
應用類載入器載入jar包中org中的jar文件。自定義類載入器載入BOOT-INF包中的jar文件
launchedURLClassLoader（）
自己跟程式碼
為什麼啟動類要用main方法？舉例拿程式碼來說明一下。
用別的方法其實也可以。是因為要在ide中支援直接運行啟動方法。換成別的名字的話就不能直接通過IDE啟動了。
package com.erwa.boot.testMain; public class MyMain { public static void main1(String[] args) { System.out.println("hello 你好"); } }package com.erwa.boot.testMain; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class MyMain2 { public static void main(String[] args) throws Exception{ Class<?> myMainClass = MyMain.class; Method main = myMainClass.getDeclaredMethod("main1", String[].class); main.invoke(null,new Object[]{null}); } } 通過反射的方式運行第一個main1方法。通過不同方式啟動，使用的類載入器是否一樣的呢？不一樣的，結果如下
public static void main(String[] args) { System.out.println(BootApplication.class.getClassLoader()+"123"); SpringApplication.run(BootApplication.class, args); }main方法啟動的類載入器：
sun.misc.Launcher$AppClassLoader@18b4aac2123
通過jar包的方式啟動的類載入器：
org.springframework.boot.loder.launchedURLClassLoader@659e0bfd123
JDWP：遠程調試詳解
不通過IDE進行debug調試的方法。通過遠程進行調試。
JDWP： Java Debug wire Protocol， Java調試協議。
~ java -agentlib:jdwp=help Java Debugger JDWP Agent Library -------------------------------- (see http://java.sun.com/products/jpda for more information) jdwp usage: java -agentlib:jdwp=[help]|[<option>=<value>, ...] Option Name and Value Description Default --------------------- ----------- ------- suspend=y|n wait on startup? y transport=<name> transport spec none address=<listen/attach address> transport spec "" server=y|n listen for debugger? n launch=<command line> run debugger on event none onthrow=<exception name> debug on throw none onuncaught=y|n debug on any uncaught? n timeout=<timeout value> for listen/attach in milliseconds n mutf8=y|n output modified utf-8 n quiet=y|n control over terminal messages n Obsolete Options 廢棄的屬性： ---------------- strict=y|n stdalloc=y|n Examples 舉例： -------- - Using sockets connect to a debugger at a specific address: java -agentlib:jdwp=transport=dt_socket,address=localhost:8000 ... - Using sockets listen for a debugger to attach: java -agentlib:jdwp=transport=dt_socket,server=y,suspend=y ... Notes ----- - A timeout value of 0 (the default) is no timeout. Warnings -------- - The older -Xrunjdwp interface can still be used, but will be removed in a future release, for example: java -Xdebug -Xrunjdwp:[help]|[<option>=<value>, ...]啟動jar包時進入debug狀態：
java -agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5050 -jar xxx.jaridea中集成的遠程debug的方式：
調試spring-boot-loader的啟動與載入的流程
spring-boot-loader通過非常巧妙的方式完成了類的載入。
@SpringBootApplication相關註解
你以為點下springboot運行，就這麼簡單嗎？
註解扮演著舉足輕重的角色。項目啟動時，通過掃描註解的機制載入各種配置。
@SpringBootApplication註解
小技巧： Mac中查看方法的文檔的快捷鍵： ⌃ + J
@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) }) public @interface SpringBootApplication { } SpringBootApplication註解的作用 ： Indicates a configuration class that declares one or more @Bean methods and also triggers auto-configuration and component scanning. This is a convenience annotation that is equivalent to declaring @Configuration, @EnableAutoConfiguration and @ComponentScan.@SpringBootConfiguration 註解
@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Configuration public interface SpringBootConfiguration extends annotation.Annotation Indicates that a class provides Spring Boot application @Configuration. Can be used as an alternative to the Springs standard @Configuration annotation so that configuration can be found automatically (for example in tests).@Configuration 註解 -詳解
@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Component public interface Configuration extends annotation.Annotation Indicates that a class declares one or more @Bean methods and may be processed by the Spring container to generate bean definitions and service requests for those beans at runtime, for example: @Configuration public class AppConfig { @Bean public MyBean myBean() { // instantiate, configure and return bean ... } } Bootstrapping @Configuration classes "Configuration註解的實現原理： Via AnnotationConfigApplicationContext @Configuration classes are typically bootstrapped using either AnnotationConfigApplicationContext or its web-capable variant, AnnotationConfigWebApplicationContext. A simple example with the former follows: AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(); ctx.register(AppConfig.class); ctx.refresh(); MyBean myBean = ctx.getBean(MyBean.class); // use myBean ... 詳細的文檔自行打開源碼查看。 composing @Configuration classes : "可以組合多個configuration； 使用@Import() @Configuration classes may be composed using the @Import annotation, similar to the way that <import> works in Spring XML. Because @Configuration objects are managed as Spring beans within the container, imported configurations may be injected — for example, via constructor injection: @Configuration public class DatabaseConfig { @Bean public DataSource dataSource() { // instantiate, configure and return DataSource } } @Configuration @Import(DatabaseConfig.class) public class AppConfig { private final DatabaseConfig dataConfig; public AppConfig(DatabaseConfig dataConfig) { this.dataConfig = dataConfig; } @Bean public MyBean myBean() { // reference the dataSource() bean method return new MyBean(dataConfig.dataSource()); } } Now both AppConfig and the imported DatabaseConfig can be bootstrapped by registering only AppConfig against the Spring context: new AnnotationConfigApplicationContext(AppConfig.class); With the @Profile annotation : "Profile註解和Configuration註解的搭配使用： @Configuration classes may be marked with the @Profile annotation to indicate they should be processed only if a given profile or profiles are active: @Profile("development") @Configuration public class EmbeddedDatabaseConfig { @Bean public DataSource dataSource() { // instantiate, configure and return embedded DataSource } } @Profile("production") @Configuration public class ProductionDatabaseConfig { @Bean public DataSource dataSource() { // instantiate, configure and return production DataSource } } Alternatively, you may also declare profile conditions at the @Bean method level — for example, for alternative bean variants within the same configuration class: @Configuration public class ProfileDatabaseConfig { @Bean("dataSource") @Profile("development") public DataSource embeddedDatabase() { ... } @Bean("dataSource") @Profile("production") public DataSource productionDatabase() { ... } } With nested @Configuration classes ： "Configuration註解的嵌套使用 @Configuration classes may be nested within one another as follows: @Configuration public class AppConfig { @Inject DataSource dataSource; @Bean public MyBean myBean() { return new MyBean(dataSource); } @Configuration static class DatabaseConfig { @Bean DataSource dataSource() { return new EmbeddedDatabaseBuilder().build(); } } } When bootstrapping such an arrangement, only AppConfig need be registered against the application context. By virtue of being a nested @Configuration class, DatabaseConfig will be registered automatically. This avoids the need to use an @Import annotation when the relationship between AppConfig and DatabaseConfig is already implicitly clear. Note also that nested @Configuration classes can be used to good effect with the @Profile annotation to provide two options of the same bean to the enclosing @Configuration class. @EnableAutoConfiguration 註解
"自動配置註解"： 進行自動的查找和類型匹配。 Enable auto-configuration of the Spring Application Context, attempting to guess and configure beans that you are likely to need. Auto-configuration classes are usually applied based on your classpath and what beans you have defined. For example, if you have tomcat-embedded.jar on your classpath you are likely to want a TomcatServletWebServerFactory (unless you have defined your own ServletWebServerFactory bean). When using @SpringBootApplication, the auto-configuration of the context is automatically enabled and adding this annotation has therefore no additional effect. Auto-configuration tries to be as intelligent as possible and will back-away as you define more of your own configuration. You can always manually exclude() any configuration that you never want to apply (use excludeName() if you don『t have access to them). You can also exclude them via the spring.autoconfigure.exclude property. Auto-configuration is always applied after user-defined beans have been registered. The package of the class that is annotated with @EnableAutoConfiguration, usually via @SpringBootApplication, has specific significance and is often used as a 'default'. For example, it will be used when scanning for @Entity classes. It is generally recommended that you place @EnableAutoConfiguration (if you』re not using @SpringBootApplication) in a root package so that all sub-packages and classes can be searched. Auto-configuration classes are regular Spring @Configuration beans. They are located using the SpringFactoriesLoader mechanism (keyed against this class). Generally auto-configuration beans are @Conditional beans (most often using @ConditionalOnClass and @ConditionalOnMissingBean annotations).@ComponentScan 組件掃描註解
Configures component scanning directives for use with @Configuration classes. Provides support parallel with Spring XML's <context:component-scan> element. Either basePackageClasses or basePackages (or its alias value) may be specified to define specific packages to scan. If specific packages are not defined, scanning will occur from the package of the class that declares this annotation.Springboot項目啟動
SpringApplication 啟動類的介紹
org.springframework.boot public class SpringApplication extends Object Class that can be used to bootstrap and launch a Spring application from a Java main method. By default class will perform the following steps to bootstrap your application: - Create an appropriate ApplicationContext instance (depending on your classpath) - Register a CommandLinePropertySource to expose command line arguments as Spring properties - Refresh the application context, loading all singleton beans - Trigger any CommandLineRunner beans In most circumstances the static run(Class, String[]) method can be called directly from your main method to bootstrap your application: @Configuration @EnableAutoConfiguration public class MyApplication { // ... Bean definitions public static void main(String[] args) { SpringApplication.run(MyApplication.class, args); } } For more advanced configuration a SpringApplication instance can be created and customized before being run: public static void main(String[] args) { SpringApplication application = new SpringApplication(MyApplication.class); // ... customize application settings here application.run(args) } SpringApplications can read beans from a variety of different sources. It is generally recommended that a single @Configuration class is used to bootstrap your application, however, you may also set sources from: - The fully qualified class name to be loaded by AnnotatedBeanDefinitionReader - The location of an XML resource to be loaded by XmlBeanDefinitionReader, or a groovy script to be loaded by GroovyBeanDefinitionReader - The name of a package to be scanned by ClassPathBeanDefinitionScanner ""Configuration properties are also bound to the SpringApplication. This makes it possible to set SpringApplication properties dynamically, like additional sources ("spring.main.sources" - a CSV list) the flag to indicate a web environment ("spring.main.web-application-type=none") or the flag to switch off the banner ("spring.main.banner-mode=off").springBoot啟動流程介紹
啟動時，調用springApplication類中的run方法： SpringApplication.run(BootApplication.class, args);工廠載入機制詳解和工廠快取源碼分析
默認的類載入器是應用類載入器
SpringFactoriesLoader類
org.springframework.core.io.support public final class SpringFactoriesLoader extends Object General purpose factory loading mechanism for internal use within the framework. SpringFactoriesLoader loads and instantiates factories of a given type from "META-INF/spring.factories" files which may be present in multiple JAR files in the classpath. The spring.factories file must be in Properties format, where the key is the fully qualified name of the interface or abstract class, and the value is a comma-separated list of implementation class names. For example: example.MyService=example.MyServiceImpl1,example.MyServiceImpl2 where example.MyService is the name of the interface, and MyServiceImpl1 and MyServiceImpl2 are two implementations. spring工廠Bean載入過程
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) { MultiValueMap<String, String> result = cache.get(classLoader); if (result != null) { return result; } try { Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION)); result = new LinkedMultiValueMap<>(); while (urls.hasMoreElements()) { URL url = urls.nextElement(); UrlResource resource = new UrlResource(url); Properties properties = PropertiesLoaderUtils.loadProperties(resource); for (Map.Entry<?, ?> entry : properties.entrySet()) { String factoryTypeName = ((String) entry.getKey()).trim(); for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) { result.add(factoryTypeName, factoryImplementationName.trim()); } } } cache.put(classLoader, result); return result; } catch (IOException ex) { throw new IllegalArgumentException("Unable to load factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex); } } 載入bean的過程，會載入三個包里的spring.factories文件 ， 包分別是 spring-boot-autoconfigure ，spring-boot，Spring-beans， 最終返回一個結果集。沒有所謂的自動一說，都是底層設計好的，幫你把事情給準備好了。SpringApplication構造過程
SpringApplication的構造方法： public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) { "設定一個資源載入器" this.resourceLoader = resourceLoader; "給啟動源賦值" Assert.notNull(primarySources, "PrimarySources must not be null"); this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources)); this.webApplicationType = WebApplicationType.deduceFromClasspath(); "初始化器" setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class)); "監聽器" setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class)); "" this.mainApplicationClass = deduceMainApplicationClass(); }創建實例：初始化器獲取到了工廠的名字後，進行下一步操作,生成實例返回。 private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, ClassLoader classLoader, Object[] args, Set<String> names) { List<T> instances = new ArrayList<>(names.size()); for (String name : names) { try { Class<?> instanceClass = ClassUtils.forName(name, classLoader); Assert.isAssignable(type, instanceClass); Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes); T instance = (T) BeanUtils.instantiateClass(constructor, args); instances.add(instance); } catch (Throwable ex) { throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex); } } return instances; }電腦領域的兩大難題： 變數命名和快取一致性
springApplication構造過程使用了觀察者模式的監聽機制。
使用運行時異常，獲取到堆棧資訊，然後獲取對象。妙啊。 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; }SpringApplication.run() 方法介紹
/** 運行這個spring應用，創建並且刷新ApplicationContext（整個spring中核心的介面） * Run the Spring application, creating and refreshing a new * {@link ApplicationContext}. * @param args the application arguments (usually passed from a Java main method) * @return a running {@link ApplicationContext} */ public ConfigurableApplicationContext run(String... args) { //秒錶計時器「統計應用的啟動時間 StopWatch stopWatch = new StopWatch(); stopWatch.start(); //ConfigurableApplicationContext：可配置的應用上下文對象 ConfigurableApplicationContext context = null; // springBoot異常報告器 Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>(); configureHeadlessProperty(); // SpringApplicationRunListeners 針對於run方法的運行監聽器 SpringApplicationRunListeners listeners = getRunListeners(args); //獲取鑒定器的實例 // run方法首次啟動，啟動所有的監聽器 listeners.starting(); // 涉及到 觀察者模式的經典應用 // try 中完成了 應用啟動之前的所有啟動準備工作。 try { // 構建一個應用參數對象 ApplicationArguments applicationArguments = new DefaultApplicationArguments(args); // 配置環境準備 ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments); // 配置忽略的bean資訊 configureIgnoreBeanInfo(environment); // Banner資訊列印 Banner printedBanner = printBanner(environment); // 給context對象賦值 context = createApplicationContext(); //獲取spring工廠實例 exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[] { 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 new IllegalStateException(ex); } try { listeners.running(context); } catch (Throwable ex) { handleRunFailure(context, ex, exceptionReporters, null); throw new IllegalStateException(ex); } return context; }ApplicationContext 介面的作用介紹
為spring提供所有的配置資訊。所擁有的能力
org.springframework.context public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver Central interface to provide configuration for an application. This is read-only while the application is running, but may be reloaded if the implementation supports this. An ApplicationContext provides: - Bean factory methods for accessing application components. Inherited from ListableBeanFactory. //用於訪問公共組件的bean工廠的方法 - The ability to load file resources in a generic fashion. Inherited from the org.springframework.core.io.ResourceLoader interface. //載入資源的能力 - The ability to publish events to registered listeners. Inherited from the ApplicationEventPublisher interface. //向註冊的監聽器發送消息 - The ability to resolve messages, supporting internationalization. Inherited from the MessageSource interface. //解析消息的能力 - Inheritance from a parent context. Definitions in a descendant context will always take priority. This means, for example, that a single parent context can be used by an entire web application, while each servlet has its own child context that is independent of that of any other servlet. //從父的上下文中繼承消息的能力 In addition to standard org.springframework.beans.factory.BeanFactory lifecycle capabilities, ApplicationContext implementations detect and invoke ApplicationContextAware beans as well as ResourceLoaderAware, ApplicationEventPublisherAware and MessageSourceAware beans.SpringApplication.Run的運行生命周期
讀源碼的時候，多問幾個為什麼
- 不同的生命周期對應著應用不同的事件
Listener for the SpringApplication run method. SpringApplicationRunListeners are loaded via the SpringFactoriesLoader and should declare a public constructor that accepts a SpringApplication instance and a String[] of arguments. A new SpringApplicationRunListener instance will be created for each run. public interface SpringApplicationRunListener { /** * Called immediately when the run method has first started. Can be used for very * early initialization. */ default void starting() { } /** * Called once the environment has been prepared, but before the * {@link ApplicationContext} has been created. * @param environment the environment */ default void environmentPrepared(ConfigurableEnvironment environment) { } /** * Called once the {@link ApplicationContext} has been created and prepared, but * before sources have been loaded. * @param context the application context */ default void contextPrepared(ConfigurableApplicationContext context) { } /** * Called once the application context has been loaded but before it has been * refreshed. * @param context the application context */ default void contextLoaded(ConfigurableApplicationContext context) { } /** * The context has been refreshed and the application has started but * {@link CommandLineRunner CommandLineRunners} and {@link ApplicationRunner * ApplicationRunners} have not been called. * @param context the application context. * @since 2.0.0 */ default void started(ConfigurableApplicationContext context) { } /** * Called immediately before the run method finishes, when the application context has * been refreshed and all {@link CommandLineRunner CommandLineRunners} and * {@link ApplicationRunner ApplicationRunners} have been called. * @param context the application context. * @since 2.0.0 */ default void running(ConfigurableApplicationContext context) { } /** * Called when a failure occurs when running the application. * @param context the application context or {@code null} if a failure occurred before * the context was created * @param exception the failure * @since 2.0.0 */ default void failed(ConfigurableApplicationContext context, Throwable exception) { } }SimpleApplicationEventMulticaster 簡單的應用事件廣播器 — 觀察者模式的經典應用
觀察者模式： 廣播器廣播，訂閱了事件的監聽器監聽，決定事件是否執行操作。
應用定義了很多事件。來自於SpringApplicationEvent org.springframework.context.event public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster Simple implementation of the ApplicationEventMulticaster interface. Multicasts all events to all registered listeners, leaving it up to the listeners to ignore events that they are not interested in. Listeners will usually perform corresponding instanceof checks on the passed-in event object. By default, all listeners are invoked in the calling thread. This allows the danger of a rogue listener blocking the entire application, but adds minimal overhead. Specify an alternative task executor to have listeners executed in different threads, for example from a thread pool.Environment 環境 組件
代表當前應用的環境
ConfigurabeEnvironment 配置環境組件的doc
#### Banner資訊輸出與訂製的原理
Banner printedBanner = printBanner(environment); private Banner printBanner(ConfigurableEnvironment environment) { if (this.bannerMode == Banner.Mode.OFF) { return null; } ResourceLoader resourceLoader = (this.resourceLoader != null) ? this.resourceLoader : new DefaultResourceLoader(getClassLoader()); SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter(resourceLoader, this.banner); if (this.bannerMode == Mode.LOG) { return bannerPrinter.print(environment, this.mainApplicationClass, logger); } return bannerPrinter.print(environment, this.mainApplicationClass, System.out); }SpringBoot啟動流程結束
SpringBoot Modules
springboot的重要模組。
There are a number of modules in Spring Boot, here is a quick overview:
spring-boot
The main library providing features that support the other parts of Spring Boot, these include:
- The
SpringApplicationclass, providing static convenience methods that make it easy to write a stand-alone Spring Application. Its sole job is to create and refresh an appropriate SpringApplicationContext - Embedded web applications with a choice of container (Tomcat, Jetty or Undertow)
- First class externalized configuration support
- Convenience
ApplicationContextinitializers, including support for sensible logging defaults
spring-boot-autoconfigure
Spring Boot can configure large parts of common applications based on the content of their classpath. A single @EnableAutoConfiguration annotation triggers auto-configuration of the Spring context.
Auto-configuration attempts to deduce which beans a user might need. For example, if HSQLDB is on the classpath, and the user has not configured any database connections, then they probably want an in-memory database to be defined. Auto-configuration will always back away as the user starts to define their own beans.
spring-boot-starters
Starters are a set of convenient dependency descriptors that you can include in your application. You get a one-stop-shop for all the Spring and related technology that you need without having to hunt through sample code and copy paste loads of dependency descriptors. For example, if you want to get started using Spring and JPA for database access just include the spring-boot-starter-data-jpa dependency in your project, and you are good to go.
spring-boot-cli
命令行應用
The Spring command line application compiles and runs Groovy source, making it super easy to write the absolute minimum of code to get an application running. Spring CLI can also watch files, automatically recompiling and restarting when they change.
spring-boot-actuator
Actuator endpoints let you monitor and interact with your application. Spring Boot Actuator provides the infrastructure required for actuator endpoints. It contains annotation support for actuator endpoints. Out of the box, this module provides a number of endpoints including the HealthEndpoint, EnvironmentEndpoint, BeansEndpoint and many more.
spring-boot-actuator-autoconfigure
This provides auto-configuration for actuator endpoints based on the content of the classpath and a set of properties. For instance, if Micrometer is on the classpath, it will auto-configure the MetricsEndpoint. It contains configuration to expose endpoints over HTTP or JMX. Just like Spring Boot AutoConfigure, this will back away as the user starts to define their own beans.
spring-boot-test
This module contains core items and annotations that can be helpful when testing your application.
spring-boot-test-autoconfigure
Like other Spring Boot auto-configuration modules, spring-boot-test-autoconfigure, provides auto-configuration for tests based on the classpath. It includes a number of annotations that can be used to automatically configure a slice of your application that needs to be tested.
spring-boot-loader
Spring Boot Loader provides the secret sauce that allows you to build a single jar file that can be launched using java -jar. Generally you will not need to use spring-boot-loader directly, but instead work with the Gradle or Maven plugin.
spring-boot-devtools
提供了額外的開發工具。
The spring-boot-devtools module provides additional development-time features such as automatic restarts, for a smoother application development experience. Developer tools are automatically disabled when running a fully packaged application.
springboot整合組件
springboot日誌處理
springboot中logback日誌的使用
@PostConstruct
在yml中 ： logging.level.root : debug 設置日誌級別
日誌級別： Trance , debug , info,warn ,error
springboot整合JSP
Springboot 項目 推薦使用模板引擎Thymeleaf
注意事項：使用JSP的時候，需要先引入jsp的依賴, 使用普通的@controller 註解
javax.servlet:jstl org.apache.tomcat.embed:tomcat-embed-jasperspringboot整合webSocket
需要添加依賴：
org.springframework.boot:spring-boot-starter-websocket
org.springframework.boot:spring-boot-starter-json
需要添加註解：
@EnableWebSocket
靜態資源的存放位置：
resource/static/xxx.html
以前沒有接觸過 websocket開發，聽的時候有點蒙蔽，不知道在說的是什麼。
但是舉的例子讓我有了一點兒大概的認識。根據TCP協議來進行客戶端和伺服器端的通訊。
設計模式：適配器模式
每次引用新的依賴時，需要在啟動類上添加相應的註解來引用。
springboot使用開發者工具和單元測試
spring-boot-devtools
The spring-boot-devtools module provides additional development-time features such as automatic restarts, for a smoother application development experience. Developer tools are automatically disabled when running a fully packaged application.
需要先添加依賴：
org.springframework.boot:spring-boot-devtools
提供了熱部署的功能。IDEA要配合修改一下IDE的配置才能使用熱部署的功能。
模組小還好，都一樣。模組大的話，特別的浪費開發時間。
自動重啟和手動重啟的區別： 使用的類載入器不一樣。自動重啟重新載入的類會少很多，自己手動重啟時會重新載入所有的類，所以自動重啟的速度會快一點。
test 單元測試
需要引入依賴：
org.springframework.boot:spring-boot-starter-test
使用到的註解：
@RunWith(SpringRunner.class)
@SpringBootTest
public class MyControllerTest{
@Before
@Test
}
