SpringBoot源碼筆記分析

1.基礎

1.配置SpringBoot熱部署

1.引入依賴

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId> </dependency>

2.配置IDEA

組合鍵 Ctrl+shift+alt+’/’ 彈出框

2.spring的配置文件

application.properties

application.yaml

2.1application.properties例子

server.port=8081 spring.datasource.driver-class-name=com.mysql.jdbc.Driver spring.config.additional-location= spring.config.location= spring.config.name=application @Component //將類作為Bean注入到Spring容器中 @ConfigurationProperties(prefix = "person") //將配置文件以person開頭的屬性注入到該類中 public class Person {private int id; private String name; private List hobby; }

2.2 application.yaml配置文件

person:id: 1name: lucyhobby: [吃飯，睡覺]family: [father,mother]map: {k1: v1,k2: v2}pet: {type: dog,name: 旺財}

2.3.配置文件屬性注入

@Component public class Student {@Value("${person.id}")private int id;@Value("${person.name}")private String name; } // @Component @ConfigurationProperties(prefix = "person") public class Person {private int id; public void setId(int id) {this.id = id;} }

2.源碼刨析

2.1 依賴管理

1.為什么導入依賴時不需要指定版本
在spring-boot-starter-parent中的

<relativePath>../../spring-boot-dependencies</relativePath>

使用 dependencyManagement 進行了版本管理

<dependencyManagement><dependencyManagement>

2.2 @SpringbootDemoApplication

@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 { }

2.2.1 @SpringBootConfiguration

@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented@Configuration //配置類 public @interface SpringBootConfiguration {}

2.2.2 @EnableAutoConfiguration

@AutoConfigurationPackage //自動配置包 @Import(AutoConfigurationImportSelector.class) public @interface EnableAutoConfiguration { }

(1)@AutoConfigurationPackage

將(@SpringBootApplication)所在的包及其子包里面的所有組件掃描到Spring容器中

//spring框架的底層注解，它的作用就是給容器中導入某個組件類， @Import(AutoConfigurationPackages.Registrar.class) // 默認將主配置類(@SpringBootApplication)所在的包及其子包里面的所有組件掃描到Spring容器中 public @interface AutoConfigurationPackage {} //==============Registrar方法========================static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {@Overridepublic void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {//取到了當前application啟動類所在的包名 com.youxiu.demoregister(registry, new PackageImport(metadata).getPackageName()); }}//============register============public static void register(BeanDefinitionRegistry registry, String... packageNames) {if (registry.containsBeanDefinition(BEAN)) {BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN);ConstructorArgumentValues constructorArguments = beanDefinition.getConstructorArgumentValues();constructorArguments.addIndexedArgumentValue(0, addBasePackages(constructorArguments, packageNames));}// 如果不存在該 BEAN ，則創建一個 Bean ，并進行注冊else {GenericBeanDefinition beanDefinition = new GenericBeanDefinition();beanDefinition.setBeanClass(BasePackages.class);beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0, packageNames);beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);// 注冊beanDefinitionregistry.registerBeanDefinition(BEAN, beanDefinition);}}//============registerBeanDefinition============public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {Map var4 = this.beanDefinitionMap;synchronized(this.beanDefinitionMap) {//加入this.beanDefinitionMap.put(beanName, beanDefinition);List<String> updatedDefinitions = new ArrayList(this.beanDefinitionNames.size() + 1);updatedDefinitions.addAll(this.beanDefinitionNames);updatedDefinitions.add(beanName);this.beanDefinitionNames = updatedDefinitions;this.removeManualSingletonName(beanName);}}

(2)@AutoConfigurationImportSelector.class

幫助SpringBoot容器將所有符合條件的額Configuation配置都加載到Ioc(ApplicationContext)中

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {//選擇導入public String[] selectImports(AnnotationMetadata annotationMetadata) {if (!isEnabled(annotationMetadata)) {return NO_IMPORTS;}//加載 META-INF/spring-autoconfigure-metadata.properties 的配置文件//1. 加載配置文件META-INF/spring-autoconfigure-metadata.properties，從中獲取所有支持自動配置類的條件//作用：SpringBoot使用一個Annotation的處理器來收集一些自動裝配的條件，那么這些條件可以在META-INF/spring-autoconfigure-metadata.properties進行配置。// SpringBoot會將收集好的@Configuration進行一次過濾進而剔除不滿足條件的配置類// 自動配置的類全名.條件=值 下方第二張圖AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,annotationMetadata);return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());} }

自動配置的類全名.條件=值

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,AnnotationMetadata annotationMetadata) {// 1. 判斷是否開啟注解。如未開啟，返回空串if (!isEnabled(annotationMetadata)) {return EMPTY_ENTRY;}// 2. 獲得注解的屬性AnnotationAttributes attributes = getAttributes(annotationMetadata);// 3. getCandidateConfigurations()用來獲取默認支持的自動配置類名列表// spring Boot在啟動的時候，使用內部工具類SpringFactoriesLoader，查找classpath上所有jar包中的META-INF/spring.factories，// 找出其中key為org.springframework.boot.autoconfigure.EnableAutoConfiguration的屬性定義的工廠類名稱，// 將這些值作為自動配置類導入到容器中，自動配置類就生效了List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);// 3.1 //去除重復的配置類，若我們自己寫的starter 可能存在重復的configurations = removeDuplicates(configurations);Set<String> exclusions = getExclusions(annotationMetadata, attributes);// 4.1 校驗排除類（exclusions指定的類必須是自動配置類，否則拋出異常）checkExcludedClasses(configurations, exclusions);configurations.removeAll(exclusions);// 5. 對所有候選的自動配置類進行篩選，根據項目pom.xml文件中加入的依賴文件篩選出最終符合當前項目運行環境對應的自動配置類//@ConditionalOnClass ： 某個class位于類路徑上，才會實例化這個Bean。//@ConditionalOnMissingClass ： classpath中不存在該類時起效//@ConditionalOnBean ： DI容器中存在該類型Bean時起效//@ConditionalOnMissingBean ： DI容器中不存在該類型Bean時起效//@ConditionalOnSingleCandidate ： DI容器中該類型Bean只有一個或@Primary的只有一個時起效//@ConditionalOnExpression ： SpEL表達式結果為true時//@ConditionalOnProperty ： 參數設置或者值一致時起效//@ConditionalOnResource ： 指定的文件存在時起效//@ConditionalOnJndi ： 指定的JNDI存在時起效//@ConditionalOnJava ： 指定的Java版本存在時起效//@ConditionalOnWebApplication ： Web應用環境下起效//@ConditionalOnNotWebApplication ： 非Web應用環境下起效//總結一下判斷是否要加載某個類的兩種方式：//根據spring-autoconfigure-metadata.properties進行判斷。//要判斷@Conditional是否滿足// 如@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })表示需要在類路徑中存在SqlSessionFactory.class、SqlSessionFactoryBean.class這兩個類才能完成自動注冊。configurations = filter(configurations, autoConfigurationMetadata);// 6. 將自動配置導入事件通知監聽器//當AutoConfigurationImportSelector過濾完成后會自動加載類路徑下Jar包中META-INF/spring.factories文件中 AutoConfigurationImportListener的實現類，// 并觸發fireAutoConfigurationImportEvents事件。fireAutoConfigurationImportEvents(configurations, exclusions);// 7. 創建 AutoConfigurationEntry 對象return new AutoConfigurationEntry(configurations, exclusions);}

2.3. run方法

由SpringApplication對象與 Run兩部分組成

SpringApplication.run(DemoApplication.class, args);public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {return new SpringApplication(primarySources).run(args); }

2.3.1 SpringApplication()

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {this.resourceLoader = resourceLoader;//斷言判空Assert.notNull(primarySources, "PrimarySources must not be null");//項目啟動類 SpringbootDemoApplication.class設置為屬性存儲起來this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));this.webApplicationType = WebApplicationType.deduceFromClasspath();//設置初始器 //所謂的初始化器就是org.springframework.context.ApplicationContextInitializer的實現類,在Spring上下文被刷新之前進行初始化的操作setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));// 設置監聽器(Listener)setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));// 初始化 mainApplicationClass 屬性:用于推斷并設置項目main()方法啟動的主程序啟動類this.mainApplicationClass = deduceMainApplicationClass();}

2.3.1.1setInitializers初始化

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {ClassLoader classLoader = getClassLoader();// Use names and ensure unique to protect against duplicates// 加載指定類型對應的，在 `META-INF/spring.factories` 里的類名的數組Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));//創建spring工廠實例List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);AnnotationAwareOrderComparator.sort(instances);return instances;}@SuppressWarnings("unchecked")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;} // Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader)); //SpringFactoriesLoader.loadFactoryNames(type, classLoader) private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {MultiValueMap<String, String> result = cache.get(classLoader);if (result != null) {return result;}//1.獲取項目springFactory配置文件路徑 // jar:file:/D:/Java_code/apache-maven-3.5.2/resp/org/springframework/spring-beans/5.2.2.RELEASE/spring-beans-5.2.2.RELEASE.jar!/META-INF/spring.factories//jar:file:/D:/Java_code/apache-maven-3.5.2/resp/org/springframework/boot/spring-boot-devtools/2.2.2.RELEASE/spring-boot-devtools-2.2.2.RELEASE.jar!/META-INF/spring.factories//2.urls 轉換成 resource//3.遍歷resource key value封裝到了 MultiValueMap<String, String>try {Enumeration<URL> urls = (classLoader != null ?//加載META-INF/spring.factories//org.springframework.beans.BeanInfoFactory=org.springframework.beans.ExtendedBeanInfoFactoryclassLoader.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);}}

2.3.2Run()

public ConfigurableApplicationContext run(String... args) {// 創建 StopWatch 對象，并啟動。StopWatch 主要用于簡單統計 run 啟動過程的時長。StopWatch stopWatch = new StopWatch();stopWatch.start();ConfigurableApplicationContext context = null;//異常管理Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();configureHeadlessProperty();// （1）獲取并啟動監聽器SpringApplicationRunListeners listeners = getRunListeners(args);listeners.starting();try {// 創建 ApplicationArguments 對象 初始化默認應用參數類// args是啟動Spring應用的命令行參數，該參數可以在Spring應用中被訪問。如：--server.port=9000ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);//（2）項目運行環境Environment的預配置ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);configureIgnoreBeanInfo(environment);// 準備Banner打印器 - 就是啟動Spring Boot的時候打印在console上的ASCII藝術字體Banner printedBanner = printBanner(environment);// （3）創建Spring容器context = createApplicationContext();exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,new Class[] { ConfigurableApplicationContext.class }, context);// （4）Spring容器前置處理//這一步主要是在容器刷新之前的準備動作。包含一個非常關鍵的操作：將啟動類注入容器，為后續開啟自動化配置奠定基礎。prepareContext(context, environment, listeners, applicationArguments, printedBanner);// （5）：刷新容器refreshContext(context);// （6）：Spring容器后置處理afterRefresh(context, applicationArguments);stopWatch.stop();if (this.logStartupInfo) {new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);}// （7）發出結束執行的事件通知listeners.started(context);// （8）：執行RunnerscallRunners(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;}

1.createApplicationContext

protected ConfigurableApplicationContext createApplicationContext() {Class<?> contextClass = this.applicationContextClass;if (contextClass == null) {try {switch (this.webApplicationType) {// 該類型為SERVLET類型，所以會通過反射裝載對應的字節碼，case SERVLET:contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);break;case REACTIVE:contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);break;default:contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);}}catch (ClassNotFoundException ex) {throw new IllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", ex);}}// 創建 ApplicationContext 對象return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);}

2.prepareContext

private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {//設置容器環境，包括各種變量context.setEnvironment(environment);//設置上下文的 bean 生成器和資源加載器postProcessApplicationContext(context);//執行容器中的ApplicationContextInitializerapplyInitializers(context);listeners.contextPrepared(context);if (this.logStartupInfo) {logStartupInfo(context.getParent() == null);logStartupProfileInfo(context);}// Add boot specific singleton beans//注冊啟動參數bean，這里將容器指定的參數封裝成bean，注入容器ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();beanFactory.registerSingleton("springApplicationArguments", applicationArguments);if (printedBanner != null) {beanFactory.registerSingleton("springBootBanner", printedBanner);}if (beanFactory instanceof DefaultListableBeanFactory) {((DefaultListableBeanFactory) beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);}if (this.lazyInitialization) {context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());}// Load the sourcesSet<Object> sources = getAllSources();Assert.notEmpty(sources, "Sources must not be empty");load(context, sources.toArray(new Object[0]));listeners.contextLoaded(context);}

3.refreshContext

protected void refresh(ApplicationContext applicationContext) {// 斷言，判斷 applicationContext 是 AbstractApplicationContext 的子類Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);// 啟動（刷新） AbstractApplicationContext((AbstractApplicationContext) applicationContext).refresh();}

3.自定義Starter

SpringBoot starter機制
SpringBoot 是由眾多starter組成（一系列的自動化配置的start插件）
starter是SpringBoot中重要的一部分，理解為可插拔的插件

1.框架段

1.導入依賴

<dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-autoconfigure</artifactId><version>2.2.2.RELEASE</version></dependency> </dependencies>

2.自定義一個Bean

@EnableConfigurationProperties(SimpleBean.class) @ConfigurationProperties(prefix = "simplebean") public class SimpleBean {private int id;private String name;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "SimpleBean{" +"id=" + id +", name='" + name + '\'' +'}';} }

3.自定義自動配置接口

//@ConditionalOnClass ： 某個class位于類路徑上，才會實例化這個Bean。//@ConditionalOnMissingClass ： classpath中不存在該類時起效//@ConditionalOnBean ： DI容器中存在該類型Bean時起效//@ConditionalOnMissingBean ： DI容器中不存在該類型Bean時起效//@ConditionalOnSingleCandidate ： DI容器中該類型Bean只有一個或@Primary的只有一個時起效//@ConditionalOnExpression ： SpEL表達式結果為true時//@ConditionalOnProperty ： 參數設置或者值一致時起效//@ConditionalOnResource ： 指定的文件存在時起效//@ConditionalOnJndi ： 指定的JNDI存在時起效//@ConditionalOnJava ： 指定的Java版本存在時起效//@ConditionalOnWebApplication ： Web應用環境下起效//@ConditionalOnNotWebApplication ： 非Web應用環境下起效 @Configuration @ConditionalOnClass public class MyAutoConfiguration {static {System.out.println("MyAutoConfiguration init....");}@Beanpublic SimpleBean simpleBean() {return new SimpleBean();}}

4.配置接口路徑

在resources目錄下新建 \META-INF\spring.factories

// 自動配置的類全名.條件=值 org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ com.youxiu.config.MyAutoConfiguration

2.使用端

@RunWith(SpringRunner.class) //測試啟動器，并加載spring boot測試注解 @SpringBootTest class DemoApplicationTests {@Autowiredprivate SimpleBean simpleBean;@Testpublic void test(){System.out.println(simpleBean);} }

4.國際化配置

實現了 LocaleResolver 接口，重寫 resolveLocale()方法。覆蓋掉spring組件的LocaleResolver

@Configuration public class MyLocaleResovle implements LocaleResolver {// 自定義 區域解析方式@Overridepublic Locale resolveLocale(HttpServletRequest httpServletRequest) {// 獲取頁面手動傳遞的語言參數值l : zh_CN en_US ''String l = httpServletRequest.getParameter("l");Locale locale = null;if(!StringUtils.isEmpty(l)){// 如果參數不為空，就根據參數值進行手動語言切換String[] s = l.split("_");locale = new Locale(s[0],s[1]);}else {//Accept-Language: zh-CN ,zh;q=0.9String header = httpServletRequest.getHeader("Accept-Language");String[] split = header.split(",");String[] split1 = split[0].split("-");locale = new Locale(split1[0],split1[1]);}return locale;}@Overridepublic void setLocale(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Locale locale) {}// 將自定義的MyLocaleResovle重新注冊成一個類型為LocaleResolver的bean組件@Beanpublic LocaleResolver localeResolver(){return new MyLocaleResovle();} } <a class="btn btn-sm" th:href="@{/toLoginPage(l='zh_CN')}">中文</a><a class="btn btn-sm" th:href="@{/toLoginPage(l='en_US')}">English</a> login.tip=please sign in login.username=username login.password=password login.rememberme=remember me login.button=login

5.springBoot的默認緩存

5.1代碼

@EnableCaching 全局注解

@EnableCaching // 開啟緩存 @SpringBootApplication public class Springboot04CacheApplication {public static void main(String[] args) {SpringApplication.run(Springboot04CacheApplication.class, args);} }

給方法添加

//@Cacheable: 將該方法查詢結果comment存放在springboot默認緩存中//cacheNames: 起一個緩存命名空間 對應緩存唯一標識// value: 緩存結果 key:默認在只有一個參數的情況下，key值默認就是方法參數值 如果沒有參數或者多個參數的情況：simpleKeyGenerate// 查詢方法 //指定在 unless 指定在符合某個情況下不進行緩存@Cacheable(cacheNames = "comment",unless = "#result==null")public Comment findCommentById(Integer id){Optional<Comment> byId = commentRepository.findById(id);if(byId.isPresent()){Comment comment = byId.get();return comment;}return null;}

5.2源碼分析

SprignBoot默認裝配的是SimpleCacheConfiguration .使用CacheManager是ConcurrentMapCacheManager,底層是 ConcurrentMap

@Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented public @interface Cacheable {@AliasFor("cacheNames") //指定緩存的名稱 二選一String[] value() default {}; //指定緩存的名稱二選一@AliasFor("value")String[] cacheNames() default {}; //緩存數據的keyString key() default ""; //指定緩存數據的key的生成器String keyGenerator() default ""; //緩存管理器String cacheManager() default ""; //指定緩存解析器String cacheResolver() default ""; //指定在符合某條件下，進行數據緩存String condition() default ""; //符合條件下，不進行數據緩存String unless() default ""; // sync 是否使用異步緩存，默認falseboolean sync() default false; } public class ConcurrentMapCacheManager implements CacheManager, BeanClassLoaderAware {private final ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap(16);}

5.3redis緩存

配置文件

#Redis服務連接配置 #Redis服務地址 spring.redis.host=127.0.0.1 #Redis服務器連接端口 spring.redis.port=6379 #Redis服務器連接密碼 spring.redis.password=# 對基于注解的Redis緩存數據統一設置有效期為1分鐘，單位毫秒 spring.cache.redis.time-to-live=60000 @Autowiredprivate RedisTemplate redisTemplate; // 使用API方式進行緩存：先去緩存中查找，緩存中有，直接返回，沒有，查詢數據庫public Comment findCommentById(Integer id){Object o = redisTemplate.opsForValue().get("comment_" + id);if(o!=null){//查詢到了數據，直接返回return (Comment) o;}else {//緩存中沒有，從數據庫查詢Optional<Comment> byId = commentRepository.findById(id);if(byId.isPresent()){Comment comment = byId.get();//將查詢結果存到緩存中，同時還可以設置有效期為1天redisTemplate.opsForValue().set("comment_" + id,comment,1, TimeUnit.DAYS);return comment;}}return null;}

5.3自定義redis緩存序列化

package com.lagou.config;@Configuration public class RedisConfig {// 自定義一個RedisTemplate//基于 自定義一個RedisTemplate形式@Beanpublic RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {RedisTemplate<Object, Object> template = new RedisTemplate<>();template.setConnectionFactory(redisConnectionFactory);// 創建JSON格式序列化對象，對緩存數據的key和value進行轉換Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);// 解決查詢緩存轉換異常的問題ObjectMapper om = new ObjectMapper();om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);jackson2JsonRedisSerializer.setObjectMapper(om);//設置redisTemplate模板API的序列化方式為jsontemplate.setDefaultSerializer(jackson2JsonRedisSerializer);return template;}//基于注解形式@Beanpublic RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {// 分別創建String和JSON格式序列化對象，對緩存數據key和value進行轉換RedisSerializer<String> strSerializer = new StringRedisSerializer();Jackson2JsonRedisSerializer jacksonSeial =new Jackson2JsonRedisSerializer(Object.class);// 解決查詢緩存轉換異常的問題ObjectMapper om = new ObjectMapper();om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);jacksonSeial.setObjectMapper(om);// 定制緩存數據序列化方式及時效RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofDays(1)).serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(strSerializer)).serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jacksonSeial)).disableCachingNullValues();RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(config).build();return cacheManager;} }

附錄

1.Assert:斷言機制:

測試代碼或者調試程序時，總會做出一些假設，斷言就是用于在代碼中捕捉這些假設。當要判斷一個方法傳入的參數時，我們就可以使用斷言。

public void isTest(){Assert.notNull(cart);Assert.notEmpty(cart.getCartItems());Assert.notNull(receiver);Assert.notNull(paymentMethod);Assert.notNull(shippingMethod);}

單詞

evaluate 評估
Definition定義
Enabled啟動
Candidate候選人 ==》getCandidateConfigurations
Duplicate輔助 ==》removeDuplicates

deduce 推斷-==》deduceFromClasspath

primary主要，基本–》primarySources

Environment==》configureEnvironment

總結

以上是生活随笔為你收集整理的SpringBoot源码笔记分析的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。