IOC控制反轉
如A類中依賴了B類，傳統生成例項的過程是需要先例項化B，在例項化A時傳入B；控制反轉實現了先例項化A，掃描到需要使用B時再例項化B
實現了例項化過程的解耦，A、B可以單獨例項化，再實現依賴關係
Spring容器管理時的迴圈依賴問題
三級快取解決迴圈依賴
三級快取實際對應的是三次例項化過程，如A與B產生迴圈依賴
第一次：例項化A，放入一級快取
第二次：例項化A是發現依賴了B，會將A的例項化放到二級快取，然後開始B的例項化
第三次：例項化B時發現依賴了A，此時A已存在在二級快取中，會將A放入三級快取-B的例項化工廠，例項化工廠會將A注入到B，最後Spring容器再將B注入到A中。
Spring Bean的作用域
- singleton : IoC 容器中只有唯一的 bean 例項。Spring 中的 bean 預設都是單例的，是對單例設計模式的應用。
- prototype : 每次獲取都會建立一個新的 bean 例項。也就是說，連續 getBean() 兩次，得到的是不同的 Bean 例項。
可作為DTO使用，使用方式：@Component @Scope("prototype") public class MyBean { // ... } - request （僅 Web 應用可用）: 每一次 HTTP 請求都會產生一個新的 bean（請求 bean），該 bean 僅在當前 HTTP request 內有效。
- session （僅 Web 應用可用） : 每一次來自新 session 的 HTTP 請求都會產生一個新的 bean（會話 bean），該 bean 僅在當前 HTTP session 內有效。
- application/global-session （僅 Web 應用可用）：每個 Web 應用在啟動時建立一個 Bean（應用 Bean），該 bean 僅在當前應用啟動時間內有效。
- websocket （僅 Web 應用可用）：每一次 WebSocket 會話產生一個新的 bean。
Spring Bean的執行緒安全問題
Bean的線層安全取決於作用域和資料狀態；理論上論，大部分業務程式碼中都是使用的單例作用域，所以非執行緒安全，但是我們定義的Bean一般都無資料狀態，比如service、mapper，只做資料處理和傳遞，也不存線上程安全問題。
Spring Bean的生命週期
- 載入
- Bean 容器找到配置檔案中 Spring Bean 的定義。
- Bean 容器利用 Java Reflection API 建立一個 Bean 的例項。
- 初始化（包含Bean自身資料狀態和物件頭部資訊）
- 如果涉及到一些屬性值 利用 set()方法設定一些屬性值。
- 如果 Bean 實現了 BeanNameAware 介面，呼叫 setBeanName()方法，傳入 Bean 的名字。
- 如果 Bean 實現了 BeanClassLoaderAware 介面，呼叫 setBeanClassLoader()方法，傳入 ClassLoader物件的例項。
- 如果 Bean 實現了 BeanFactoryAware 介面，呼叫 setBeanFactory()方法，傳入 BeanFactory物件的例項。
- 與上面的類似，如果實現了其他 *.Aware介面，就呼叫相應的方法。
- 回撥操作
- 如果有和載入這個 Bean 的 Spring 容器相關的 BeanPostProcessor 物件，執行postProcessBeforeInitialization() 方法。
- 如果 Bean 實現了InitializingBean介面，執行afterPropertiesSet()方法。
- 如果 Bean 在配置檔案中的定義包含 init-method 屬性，執行指定的方法。
- 如果有和載入這個 Bean 的 Spring 容器相關的 BeanPostProcessor 物件，執行postProcessAfterInitialization() 方法
- 銷燬
- 當要銷燬 Bean 的時候，如果 Bean 實現了 DisposableBean 介面，執行 destroy() 方法。
- 當要銷燬 Bean 的時候，如果 Bean 在配置檔案中的定義包含 destroy-method 屬性，執行指定的方法。
@Component 和 @Bean 的區別
@Bean用於配置檔案中，作用於方法，透過自定義的方式生成例項託管到Spring容器中。
@Component通常是透過類路徑掃描來自動偵測以及自動裝配到 Spring 容器中，利用的Spring的自動裝配機制來載入。
Spring中的事務管理
事務管理方式
- 自定義事務管理器
可在Mybatise的配置檔案中制定自定義事務管理器，核心要點是解決事務開啟、提交、回滾過程
@Bean
public DataSourceTransactionManager dataSourceTransactionManager() {
DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
dataSourceTransactionManager.setDataSource(dataSource());
return dataSourceTransactionManager;
}
- 業務程式碼中透過使用@Transactional註解開啟事務
事務的傳播行為
常用的事務傳播行為：
- TransactionDefinition.PROPAGATION_REQUIRED
使用的最多的一個事務傳播行為，我們平時經常使用的@Transactional註解預設使用就是這個事務傳播行為。如果當前存在事務，則加入該事務；如果當前沒有事務，則建立一個新的事務。 - TransactionDefinition.PROPAGATION_REQUIRES_NEW
建立一個新的事務，如果當前存在事務，則把當前事務掛起。也就是說不管外部方法是否開啟事務，Propagation.REQUIRES_NEW修飾的內部方法會新開啟自己的事務，且開啟的事務相互獨立，互不干擾。 - TransactionDefinition.PROPAGATION_NESTED
如果當前存在事務，則建立一個事務作為當前事務的巢狀事務來執行；如果當前沒有事務，則該取值等價於TransactionDefinition.PROPAGATION_REQUIRED。類似於分散式事務，將一個大事務拆分成多個小事務，任一小事務回滾會導致大事務回滾。事務的拆分可以提高執行效率。 - TransactionDefinition.PROPAGATION_MANDATORY如果當前存在事務，則加入該事務；如果當前沒有事務，則丟擲異常。（mandatory：強制性）
事務失效的場景
- 開啟事務錯誤
沒使用@Transactional註解或錯誤使用了Propagation.NOT_SUPPORTED傳播行為 - 呼叫方式錯誤
沒用透過Spring容器管理的Bean物件呼叫事務方法，導致AOP失效 - 業務程式碼異常沒被捕獲
業務程式碼自己處理的異常，但是沒有丟擲，導致事務沒法回滾 - 事務註解的方法不支援AOP
final和static修飾的方法由於無法被AOP託管，導致事務失效 - 宣告的事務捕獲異常型別不匹配
如指定事務捕獲的異常型別為@Transactional(rollbackFor = RuntimeException.class)，但實際丟擲的是Exception.class異常 - 使用的資料庫不支援事務
如Mysql的資料表使用了MyISAM儲存引擎
Spring Security
利用shrio管理使用者、角色、許可權
AOP-面向切面程式設計
生成切面，利用切面的切點動態程式碼業務程式碼中的方法，在方法執行時新增前置操作或後置操作；
傳統的動態代理需要先實現InvocationHandler去完成代理過程中需要執行的前置操作與後置操作，再透過InvocationHandler實現類的invoke方法完成代理過程，如下：
public class VectorProxy implements InvocationHandler {
private Object subject = null;
public VectorProxy(Object subject) {
this.subject = subject;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
preRequset(method);
if (args != null){
for (int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
}
Object result = method.invoke(subject, args);
afterRequset(method);
return result;
}
private void preRequset(Method method){
System.out.println("before calling "+method);
}
private void afterRequset(Method method){
System.out.println("after calling "+method);
}
}
AOP實現切面入駐時無法獲取到InvocationHandler實現類，因此無法採用傳統方式，而是使用了動態生成位元組碼（Cglib）的方式直接生成了被代理類的子類，透過子類完成代理過程，如下：
// 新增註解標記為切面
@Aspect
@Component
public class AspectLearn {
Logger logger = LoggerFactory.getLogger(AspectLearn.class);
// 指定切點，AOP採用Cglib根據切點生成子類
@Pointcut("execution(* com.zwj.test.commonlearn.controller.UserInfoController.*(..))")
private void controllerPointcut() {}
// 切點環繞操作
@Around("controllerPointcut()")
private void controllerLog(ProceedingJoinPoint joinPoint) throws Throwable {
logger.info("第一次執行around");
String method = joinPoint.getSignature().getName();
logger.info("呼叫{}請求引數：" + Arrays.asList(joinPoint.getArgs()), method);
Object result = joinPoint.proceed();
logger.info("呼叫{}返回結果：{}", result);
logger.info("第二次執行around");
}
// 切點前置操作
@Before("controllerPointcut()")
private void controllerBefore(JoinPoint joinPoint) {
logger.info("執行before");
}
// 切點後置操作
@After("controllerPointcut()")
private void controllerAfter(JoinPoint joinPoint) {
logger.info("執行after");
}
}
Spring boot
spring-boot啟動過程
由SpringApplication.run()執行開始，執行過程分兩個步驟，完成SpringApplication的初始建立，再執行run方法
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
return (new SpringApplication(primarySources)).run(args);
}
SpringApplication建立
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
this.sources = new LinkedHashSet();
this.bannerMode = Mode.CONSOLE;
this.logStartupInfo = true;
this.addCommandLineProperties = true;
this.addConversionService = true;
this.headless = true;
this.registerShutdownHook = true;
this.additionalProfiles = Collections.emptySet();
this.isCustomEnvironment = false;
this.lazyInitialization = false;
this.applicationContextFactory = ApplicationContextFactory.DEFAULT;
this.applicationStartup = ApplicationStartup.DEFAULT;
this.resourceLoader = resourceLoader;
Assert.notNull(primarySources, "PrimarySources must not be null");
this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
this.webApplicationType = WebApplicationType.deduceFromClasspath();
this.bootstrapRegistryInitializers = new ArrayList(this.getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
// ApplicationContext上下文構造器構建
this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
// 監聽器建立
this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
this.mainApplicationClass = this.deduceMainApplicationClass();
}
run方法執行
public ConfigurableApplicationContext run(String... args) {
// 開始時鐘，記錄啟動過程總耗時
long startTime = System.nanoTime();
DefaultBootstrapContext bootstrapContext = this.createBootstrapContext();
ConfigurableApplicationContext context = null;
// 載入java.awt.headless相關配置
this.configureHeadlessProperty();
SpringApplicationRunListeners listeners = this.getRunListeners(args);
// 觸發監聽器的starting動作
listeners.starting(bootstrapContext, this.mainApplicationClass);
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
// 觸發監聽器的environmentPrepared動作，並完成環境變數的準備工作
ConfigurableEnvironment environment = this.prepareEnvironment(listeners, bootstrapContext, applicationArguments);
this.configureIgnoreBeanInfo(environment);
// 列印Banner
Banner printedBanner = this.printBanner(environment);
context = this.createApplicationContext();
context.setApplicationStartup(this.applicationStartup);
// 觸發監聽器的contextPrepared動作，完成初始ApplicationContext上下文
this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
// 重新整理上下文，將所有的Bean載入到上下文中
this.refreshContext(context);
this.afterRefresh(context, applicationArguments);
Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
if (this.logStartupInfo) {
(new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), timeTakenToStartup);
}
// 觸發監聽器的started動作
listeners.started(context, timeTakenToStartup);
// 執行啟動命令列的回撥，透過回撥去執行啟動配置的命令引數，也可再該回撥中完成資料預熱的操作
this.callRunners(context, applicationArguments);
} catch (Throwable var12) {
this.handleRunFailure(context, var12, listeners);
throw new IllegalStateException(var12);
}
try {
Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
// 觸發監聽器的ready動作
listeners.ready(context, timeTakenToReady);
return context;
} catch (Throwable var11) {
this.handleRunFailure(context, var11, (SpringApplicationRunListeners)null);
throw new IllegalStateException(var11);
}
}
歸納可得出如下核心步驟：
- 建立SpringApplication應用物件，該過程中完成了ApplicationContext上下文構造器的建立，同時完成了監聽器的建立
- 開始run方法的執行，開始時鐘，記錄啟動過程總耗時
- 完成環境變數的準備工作
- 完成建立初始ApplicationContext上下文
- 重新整理上下文，將所有的Bean載入到上下文中
- 執行啟動命令列的回撥，透過回撥去執行啟動配置的命令引數，也可再該回撥中完成資料預熱的操作
監聽器
SpringBoot提供了監聽器機制，用於在SpringBoot的各宣告週期階段完成自定義操作，主要分類如下：
- SpringApplicationRunListener：
用於監聽SpringBoot的整個生命週期；實現SpringApplicationRunListener，並在spring.factories中配置後可生效
/**
* SpringBoot啟動生命週期監聽器，可以監聽啟動過程的每一個階段
*/
public class MySpringApplicationRunListener implements SpringApplicationRunListener {
private final SpringApplication application;
private final String[] args;
public MySpringApplicationRunListener(SpringApplication application, String[] args) {
this.application = application;
this.args = args;
}
@Override
public void starting(ConfigurableBootstrapContext bootstrapContext) {
System.out.println("【starting】專案開始啟動......");
}
@Override
public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
System.out.println("【environmentPrepared】專案環境配置資料開始準備......");
}
@Override
public void contextPrepared(ConfigurableApplicationContext context) {
System.out.println("【contextPrepared】專案執行上下文物件開始準備......");
}
@Override
public void contextLoaded(ConfigurableApplicationContext context) {
System.out.println("【contextLoaded】專案執行上下文物件開始載入......");
}
@Override
public void started(ConfigurableApplicationContext context, Duration timeTaken) {
System.out.println("【started】專案啟動成功.....耗時：" + timeTaken.getSeconds() + "秒");
}
@Override
public void ready(ConfigurableApplicationContext context, Duration timeTaken) {
System.out.println("【ready】專案正在執行，準備接收客戶端執行指令.....");
}
@Override
public void failed(ConfigurableApplicationContext context, Throwable exception) {
System.out.println("【failed】專案啟動失敗.....");
}
}
//spring.factorise檔案配置
org.springframework.boot.SpringApplicationRunListener=\
com.zwj.test.commonlearn.springBoot.life.MySpringApplicationRunListener
- ApplicationContextInitializer：
ApplicationContext上下文初始前執行，此時已經完成了環境變數的載入工作，因此可利用該監聽器完成環境變數的檢查與修改；ApplicationContextInitializer，並在spring.factories中配置後可生效。
/**
* 當環境變數載入完成，開始初始化Application上下文時呼叫，可用用於檢查修改環境變數
*/
public class MyApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
@Override
public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
System.out.println("MyApplicationContextInitializer執行.......");
}
}
//spring.factorise檔案配置
org.springframework.context.ApplicationContextInitializer=\
com.zwj.test.commonlearn.springBoot.life.MyApplicationContextInitializer
- CommandLineRunner：
啟動命令列回撥執行器，SpringBoot啟動完成後執行，透過該監聽器可以執行啟動過程中配置的啟動引數，也可做快取預熱使用。實現CommandLineRunner介面，並透過@Component注入到Spring容器中可生效（此時SpringBoot已經完成了啟動過程，所以可使用註解注入）
/**
* 啟動命令列引數回撥，當應用啟動完成後執行，引數為啟動時配置的命令
* 可做快取預熱
*/
@Component
public class MyCommandLineRunner implements CommandLineRunner {
@Override
public void run(String... args) throws Exception {
System.out.println("CommandLineRunner執行...... 引數: " + Arrays.toString(args));
}
}
- ApplicationRunner：
啟動命令列回撥執行器，SpringBoot啟動完成後執行，功能和用法與CommandLineRunner類似，區別在於ApplicationRunner提供的命令列引數是複雜型別，可以做更多的擴充套件功能。
/**
* 啟動命令列引數回撥，當應用啟動完成後執行，引數為啟動時配置的命令
* 效果與CommandLineRunner一致，區別在於ApplicationRunner中的引數時ApplicationArguments，可以擴充套件命令的執行方式
* 可做快取預熱
*/
@Component
public class MyApplicationRunner implements ApplicationRunner {
@Override
public void run(ApplicationArguments args) throws Exception {
System.out.println("ApplicationRunner正在執行......");
}
}
Spring boot的自動裝配
自動裝配作用
Spring Boot應用專案在構建過程中會大量使用外部元件，如Mybatis、Redis等等，傳統的Spring方式需要我們自己在xml檔案中定義各種元件相關的Bean，透過IOC注入到Spring容器。Spring Boot的自動裝配提供了元件自動將自己相關的Bean注入到Spring容器的功能，不需要Spring Boot應用專案再單獨注入相關Bean。
自動裝配依賴技術
自動裝載的核心是@Import和@Conditional相關注解，並透過@Enable相關注解作為統一啟用註解
- @Import註解
用於將指定的類注入到Spring容器中，指定類的型別包含：單獨的Bean、配置類、依賴於DeferredImportSelector的Bean選擇器以及依賴於ImportBeanDefinitionRegistrar的Bean註冊器- 單獨的Bean：直接將制定的Bean例項化，注入到IOC中
- 配置類：匯入的配置類裡面所有的Bean都會被注入到Spring容器
- Bean選擇器：透過實現DeferredImportSelector介面的selectImports方法，透過自定義的方式提供要注入的Bean的全路徑陣列
- Bean注入器：透過實現ImportBeanDefinitionRegistrar介面的registerBeanDefinitions方法，透過自定義的方式直接生成Bean定義，並註冊Bean定義
@Import註解使用示例：
/**
* 建立Enable註解，當spring-boot應用找那個需要使用此模組功能時，
* 可新增改註解，注入當前starter模組的所有Bean
*/
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({
// 匯入配置類OtherStarterConfig，透過配置類批次注入Ban
OtherStarterConfig.class,
// 匯入OtherStarterImportSelector選擇器，透過選擇器自定義掃描Bean過程
OtherStarterImportSelector.class,
// 匯入OtherImportBeanDefinitionRegistrar註冊器，透過選擇器自定義掃描Bean過程
OtherImportBeanDefinitionRegistrar.class})
// 直接匯入Bean
public @interface EnableOtherStarter {
}
- @Conditional相關注解
用於過濾不需要注入的Bean；針對於Spring Boot的自動裝配功能，如果外部元件的所有Bean都預設自動注入，會極大的影響系統的啟動速度，因此提供了@Conditional註解，給Bean定義新增一些注入條件，當符合條件時才注入相關元件的Bean;如Redis元件相關Bean的自動裝配前提是需要在application.yml中配置Redis資料來源。常用的@Conditional如下：- @ConditionalOnBean: 根據Spring容器是否已經注入了指定Bean為條件
- @ConditionalOnProperty：根據配置檔案中的屬性配置為條件
- @ConditionalOnClass：根據是否載入了指定了Class為條件
如SpringBoot的web執行容器便是透過@ConditionalOnClass實現，預設狀態下spring-boot-starter-web依賴了tomcat容器相關jar，因此專案啟動時可以載入tomcat相關的class從而預設使用tomcat容器；若需要切換容易，只需要排除tomcat依賴，新增其它容器依賴即可，示例：
implementation('org.springframework.boot:spring-boot-starter-web') {
exclude group: 'org.springframework.boot',module: 'spring-boot-starter-tomcat'
}
// 替換內建的web容器，遮蔽tomcat後引入jetty
implementation('org.springframework.boot:spring-boot-starter-jetty')
- @Enable相關注解
一般用作某個外部外掛的啟用註解，即僅當Spring Boot應用專案中使用了外部元件的@Enable註解，元件才會開始自動裝配；如EurekaServer服務註冊中心，近當新增了@EnableEurekaServer註解後才會開啟相關功能。
其實現原理是@Enable註解透過@Import對元件相關的各種Bean注入渠道做了整合，當@Enable被使用時，所有被整合的注入渠道都會開始自動注入。
針對上述示例中EnableOtherStarter註解的使用如下：
//該外部外掛@Enable註解依次匯入配置類、Bean選擇器、Bean註冊器
@EnableOtherStarter
// 直接匯入外部外掛配置類，將配置類裡面的Bean統一IOC到Spring容器
@Import(OtherExecuteStarterConfig.class)
@SpringBootApplication
public class CommonLearnApplication {
public static void main(String[] args) {
SpringApplication.run(CommonLearnApplication.class, args);
}
}
自動裝配實現原理
總體來說Spring Boot的自動裝配使用了@Import(Bean選擇器)的方式。
透過原始碼可以看出Spring Boot的啟動類使用了@SpringBootApplication註解。
@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}
)}
)
而@SpringBootApplication繼承了@EnableAutoConfiguration，@EnableAutoConfiguration便是開啟自動裝配元件的開關注解。
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
Class<?>[] exclude() default {};
String[] excludeName() default {};
}
@EnableAutoConfiguration透過@Import({AutoConfigurationImportSelector.class})指定了Bean選擇器，自動裝配的核心程式碼便是在Bean選擇器中實現。
透過AutoConfigurationImportSelector原始碼可以看出Spring Boot掃描了所有spring.factories檔案中的org.springframework.boot.autoconfigure.EnableAutoConfiguration對應的配置類列表，然後以迴圈新增@AutoConfiguration註解的方式逐個注入配置檔案中的Bean。
spring.factories示例：
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.zwj.learn.springcloud.common.mvc.config.MvcConfigs,\
com.zwj.learn.springcloud.common.shrio.config.ShiroConfig
專案中有些配置類沒在spring.factories檔案中制定，但是仍然可以載入，是因為引入了自動掃描的功能，譬如Mybtise元件。