當前位置：首頁 > 前端技术 > javascript >内容正文

javascript

2021 版 Spring Boot 基础知识复习手册（2w字，建议收藏）

發布時間：2025/3/20 javascript 15 豆豆

生活随笔收集整理的這篇文章主要介紹了 2021 版 Spring Boot 基础知识复习手册（2w字，建议收藏）小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

點擊上方?好好學java?，選擇?星標?公眾號重磅資訊，干貨，第一時間送達今日推薦：分享一套基于SpringBoot和Vue的企業級中后臺開源項目，這個項目有點哇塞！個人原創100W +訪問量博客：點擊前往，查看更多

本文是 Spring Boot 基礎知識復習手冊，總共 2w 字，可以先收藏、轉發。有需要的時候查閱，本文設計的知識包括：配置常用注解、Spring Boot 自動配置、配置原理、如何修改默認配置、靜態資源處理、Rest映射、Spring Boot 常用注解、文件上傳、攔截器、錯誤處理、數據層整合：MyBatis、JDBC、Druid、Redis等等。

配置注解

@Configuration & @Bean

Spring Boot不同于傳統的Spring，它不提倡使用配置文件，而是使用配置類來代替配置文件，所以該注解就是用于將一個類指定為配置類：

@Configuration public?class?MyConfig?{@Bean("user")public?User getUser(){return?new?User("張三",20);} }

在配置類中使用方法對組件進行注冊，它的效果等價于：

需要注意的是 Spring Boot 默認會以方法名作為組件的id，也可以在 @Bean() 中指定value值作為組件的id。

@Import

在Spring中，我們可以使用@Component、@Controller、@Service、@Repository注解進行組件的注冊，而對于一些第三方的類，我們無法在類上添加這些注解，為此，我們可以使用@Import注解將其注冊到容器中。

@Configuration(proxyBeanMethods = true) @Import(User.class) public class MyConfig { }

通過@Import注解注冊的組件，其id為全類名。

@Conditional

該注解為條件裝配注解，大量運用于SpringBoot底層，由該注解衍生出來的注解非常多：

這里以@ConditionalOnBean和@ConditionalOnMissingBean舉例。其中@ConditionalOnBean注解的作用是判斷當前容器中是否擁有指定的Bean，若有才生效，比如：

@Configuration public?class?MyConfig?{@Bean("dog")public?Dog getDog(){return?new?Dog();}@Bean("user")@ConditionalOnBean(name = "dog")public?User getUser(){return?new?User("張三",20);} }

若如此，則SpringBoot在注冊User對象之前，會先判斷容器中是否已經有id為 dog?的對象，若有才創建，否則不創建。@ConditionalOnBean注解共有三種方式判斷容器中是否已經存在指定的對象，除了可以判斷組件的id外，也能夠通過判斷組件的全類名：

@Bean("user") @ConditionalOnBean(type = "com.wwj.springboot.bean.Dog") public User getUser(){return?new?User("張三",20); }

還可以通過判斷組件的類型：

@Bean("user") @ConditionalOnBean(value = Dog.class) public User getUser(){return?new?User("張三",20); }

尤其需要注意的是，因為代碼是從上至下依次執行的，所以在注冊組件時的順序要特別注意，比如：

@Configuration public class MyConfig {@Bean("user")@ConditionalOnBean(value = Dog.class)public User getUser(){return?new?User("張三",20);}@Bean("dog")public?Dog?getDog(){return?new?Dog();} }

在這段程序中，SpringBoot會先注冊User對象，而此時Dog對象還沒有被注冊，所以會導致User對象無法注冊。

而@ConditionalOnMissingBean注解的作用與@ConditionalOnBean注解正好相反，它會判斷當前容器中是否不存在指定的Bean，若不存在則生效，否則不生效。

這些注解除了能夠標注在方法上，還能作用于類上，當被標注在類上時，若條件成立，則配置類的所有注冊方法生效；若條件不成立，則配置類的所有注冊方法均不成立。

@Configuration @ConditionalOnBean(value = Dog.class) public class MyConfig {@Bean("user")public User getUser(){return?new?User("張三",20);}@Bean("dog")public?Dog?getDog(){return?new?Dog();} }

@ImportResource

該注解用于導入資源，比如現在有一個Spring的配置文件：

<?xml version="1.0"?encoding="UTF-8"?> <beans?xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><bean?id="ls"?class="com.wwj.springboot.bean.User"><property?name="name"?value="李四"/><property?name="age"?value="25"/></bean><bean?id="tom"?class="com.wwj.springboot.bean.Dog"><property?name="name"?value="tom"/><property?name="age"?value="3"/></bean> </beans>

若是想將其轉化為配置類，代碼少一點倒還好說，當配置文件中注冊的Bean非常多時，采用人工的方式顯然不是一個好的辦法，為此，SpringBoot提供了@ImportResource注解，該注解可以將Spring的配置文件直接導入到容器中，自動完成組件注冊。

@Configuration @ImportResource("classpath:bean.xml") public class MyConfig {@Bean("user")public User getUser(){return?new?User("張三",20);}@Bean("dog")public?Dog?getDog(){return?new?Dog();} }

@ConfigurationProperties

該注解用于配置綁定，也大量運用于SpringBoot底層。首先在配置文件中編寫兩個鍵值：

user.name=zhangsan user.age=30

然后使用該注解將其綁定到User類上：

@Component @ConfigurationProperties(prefix = "user") public?class?User?{private?String name;private?int?age;public?User()?{}@Overridepublic?String toString()?{return?"User{"?+"name='"?+ name + '\''?+", age="?+ age +'}';} }

但結果卻有些出乎意料：

User{name='Administrator', age=30}

這是因為我們將前綴 prefix?指定為了user，而user可能和我們的系統配置產生了重復，所以導致了這個問題，此時我們只需將前綴修改一下即可：

@Component @ConfigurationProperties(prefix = "users") public?class?User?{private?String name;private?int?age;public?User()?{}@Overridepublic?String toString()?{return?"User{"?+"name='"?+ name + '\''?+", age="?+ age +'}';} }

前綴修改了，配置文件的內容也需要做相應的修改：

users.name=zhangsan users.age=30

需要注意的是，若是想實現配置綁定，就必須要將這個待綁定的類注冊到容器中，比如使用@Component注解，當然，SpringBoot也提供了一個注解與其配套使用，它就是：@EnableConfigurationProperties 。

該注解必須標注在配置類上：

@Configuration @EnableConfigurationProperties(User.class) public class MyConfig { }

作用是開啟指定類的配置綁定功能，它的底層其實也是通過@Import注解實現的，此時User類就無需將其注冊到容器中：

@ConfigurationProperties(prefix = "users") public?class?User?{private?String name;private?int?age;public?User()?{}@Overridepublic?String toString()?{return?"User{"?+"name='"?+ name + '\''?+", age="?+ age +'}';} }

Spring Boot 會自動將屬性值綁定到 User 類，并將其注冊到容器中。Spring Boot 相關的技術文章我整理成了 PDF，關注微信公眾號「Java后端」回復「666」下載這一本技術棧手冊。

自動配置原理

有了前面的注解基礎之后，我們就能夠更深入地了解Spring Boot的自動配置原理，自動配置正是建立在這些強大的注解之上的。

我們首先觀察一下主啟動類上的注解：

@SpringBootApplication public?class?SpringbootApplication?{public?static?void?main(String[] args)?{SpringApplication.run(SpringbootApplication.class, args);} }

翻閱源碼可以得知，@SpringBootApplication注解其實是由三個注解組成的：

@SpringBootConfiguration @EnableAutoConfiguration @ComponentScan(excludeFilters = {@Filter(type = FilterType.CUSTOM,classes = {TypeExcludeFilter.class} ), @Filter(type = FilterType.CUSTOM,classes = {AutoConfigurationExcludeFilter.class} )} ) public @interface?SpringBootApplication { }

其中@SpringBootConfiguration底層是@Configuration注解，它表示主啟動類是一個配置類；而@ComponentScan是掃描注解，它默認掃描的是主啟動類當前包及其子包下的組件；最關鍵的就是@EnableAutoConfiguration注解了，該注解便實現了自動配置。

查看@EnableAutoConfiguration注解的源碼，又會發現它是由兩個注解組合而成的：

@AutoConfigurationPackage @Import({AutoConfigurationImportSelector.class}) public @interface?EnableAutoConfiguration { }

我們繼續查看@AutoConfigurationPackage注解的源碼：

@Import({Registrar.class}) public @interface?AutoConfigurationPackage { }

@Import注解我們非常熟悉，它是用來導入一個組件的，然而它比較特殊：

static?class?Registrar?implements?ImportBeanDefinitionRegistrar, DeterminableImports?{Registrar() {}public?void?registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry)?{AutoConfigurationPackages.register(registry, (String[])(new?AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new?String[0]));}public?Set<Object> determineImports(AnnotationMetadata metadata)?{return?Collections.singleton(new?AutoConfigurationPackages.PackageImports(metadata));} }

這里的 Registrar 組件中有兩個方法，它是用來導入一系列組件的，而該注解又被間接標注在了啟動類上，所以它會將主啟動類所在包及其子包下的所有組件均注冊到容器中。

接下來我們繼續看@EnableAutoConfiguration的第二個合成注解：@Import({AutoConfigurationImportSelector.class}) 該注解也向容器中注冊了一個組件，翻閱該組件的源碼：

public?class?AutoConfigurationImportSelector?implements?DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered?{public?String[] selectImports(AnnotationMetadata annotationMetadata) {if?(!this.isEnabled(annotationMetadata)) {return?NO_IMPORTS;} else?{AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);return?StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());}} }

這個方法是用來選擇導入哪些組件的，該方法又調用了getAutoConfigurationEntry()方法得到需要導入的組件，所以我們查看該方法：

protected?AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {if?(!this.isEnabled(annotationMetadata)) {return?EMPTY_ENTRY;} else?{AnnotationAttributes attributes = this.getAttributes(annotationMetadata);List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);configurations = this.removeDuplicates(configurations);Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);this.checkExcludedClasses(configurations, exclusions);configurations.removeAll(exclusions);configurations = this.getConfigurationClassFilter().filter(configurations);this.fireAutoConfigurationImportEvents(configurations, exclusions);return?new?AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);} }

在getCandidateConfigurations()方法處打一個斷點，通過debug運行后我們可以發現，configurations集合中就已經得到了127個自動配置類：

那么這些類究竟從何而來呢？我們需要探究一下getCandidateConfigurations()方法做了什么操作，它其實是調用了loadFactoryNames()方法：

List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());

最終調用的是loadSpringFactories()方法來得到一個Map集合：

private?static?Map<String, List<String>> loadSpringFactories(@Nullable?ClassLoader classLoader) {MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);if?(result != null) {return?result;} else?{try?{Enumeration<URL> urls = classLoader != null?? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");LinkedMultiValueMap result = new?LinkedMultiValueMap();}} }

可以看到，它其實是從 META-INF/spring.factories 文件中獲取的組件，我們可以看看導入的依賴中：

在spring-boot-autoconfigure-2.3.7.RELEASE.jar的META-INF目錄下就有一個spring.factories文件，打開看看文件內容：

#?Initializers org.springframework.context.ApplicationContextInitializer=\ org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\ org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener#?Application Listeners org.springframework.context.ApplicationListener=\ org.springframework.boot.autoconfigure.BackgroundPreinitializer#?Auto Configuration Import Listeners org.springframework.boot.autoconfigure.AutoConfigurationImportListener=\ org.springframework.boot.autoconfigure.condition.ConditionEvaluationReportAutoConfigurationImportListener#?Auto Configuration Import Filters org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\ org.springframework.boot.autoconfigure.condition.OnBeanCondition,\ org.springframework.boot.autoconfigure.condition.OnClassCondition,\ org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition#?Auto Configure org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\ org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\ org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\ org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\ ......

文件里的內容其實就是在最開始需要注冊的組件，這些組件都是一些配置類，只要項目一啟動，Spring Boot就會將這些配置類全部注冊到容器中。

按需開啟自動配置

雖然配置類會被 Spring Boot 自動注冊到容器中，但并不是每個配置類都會默認生效，SpringBoot會根據當前的場景按需開啟自動配置。比如Thymeleaf模板引擎的自動配置類：

@ConditionalOnClass注解的作用是檢查當前項目是否有指定的.class文件，若有則生效；否則不生效。因為我們并未引入Thymeleaf的依賴，導致TemplateMode.class和SpringTemplatengine.class都是不存在的，所以ThymeleafAutoCinfiguration并不會生效。

修改默認配置

既然SpringBoot幫助我們進行了大量的自動配置，那么對于特殊的一些應用場景，我們該如何修改它的默認配置呢？如果你不了解SpringBoot的配置原理，那么當你需要修改默認配置時，你肯定是束手無策的。我們可以找到SpringMVC的默認配置，看看SpringBoot是如何幫我們進行配置的：

@EnableConfigurationPropertie(WebMvcProperties.class)注解在之前也有介紹，它是用來開啟指定類的配置綁定的，所以我們來看看WebMvcProperties類：

@ConfigurationProperties(prefix = "spring.mvc") public?class?WebMvcProperties?{ }

配置綁定的前綴時spring.mvc，所以我們若是想修改SpringBoot的默認配置，則必須要將前綴寫為spring.mvc，至于我們可以修改哪些配置，只需要查看該類中有哪些成員變量即可，比如：

public?static?class?View {private?String?prefix;private?String?suffix;public?String?getPrefix() {return?this.prefix;}public?void?setPrefix(String?prefix) {this.prefix = prefix;}public?String?getSuffix() {return?this.suffix;}public?void?setSuffix(String?suffix) {this.suffix = suffix;}}

在WebMvcProperties類中有這樣一個內部類，內部類中有prefix和suffix兩個成員變量，它們是分別用來設置視圖的前綴和后綴的，所以我們若想進行配置，則需要在配置文件中這樣編寫：

spring.mvc.view.prefix=/views/ spring.mvc.view.suffix=.html

傳統的Spring開發Web需要編寫大量的配置，而使用SpringBoot將免去編寫配置的操作，直接面向業務邏輯開發，一起來看看該如何使用SpringBoot進行Web開發吧！

Web開發

靜態資源處理

Spring Boot默認設置了幾個靜態資源目錄：

/static
/public
/resources
/META-INF/resources

這幾個目錄需要建立在類路徑下，若如此做，則放置在這些目錄下的靜態資源可以被直接訪問到。

也可以通過配置來設置資源的訪問前綴：

spring.mvc.static-path-pattern=/res

此時若想訪問靜態資源，就必須添加res前綴才行。

我們還可以修改Spring Boot的默認資源路徑，只需添加配置：

spring.web.resources.static-locations=classpath:/myImg

若如此做，則我們只能將靜態資源放在myImg目錄下，之前的所有靜態資源目錄都將失效。

歡迎頁

Spring Boot提供了兩種方式來實現歡迎頁，第一種便是在資源目錄放置歡迎頁：

<!DOCTYPE html> <html?lang="en"> <head><meta?charset="UTF-8"><title>Title</title> </head> <body><h1>SpringBoot Index!</h1> </body> </html>

訪問結果：

第二種方式是通過Controller處理/index請求：

@Controller public?class?HelloController?{@RequestMapping("/")public?String toIndex(){return?"hello";} }

Favicon

Spring Boot也提供了自動設置網站圖標的方式，只需要將名為 favicon.ico?的圖片放在靜態資源目錄下即可：

Rest映射

在Spring Boot中，默認已經注冊了HiddenHttpMethodFilter，所以可以直接編寫Rest風格的url，只需在表單中添加一個_method屬性的請求域即可：

<!DOCTYPE html> <html?lang="en"> <head><meta?charset="UTF-8"><title>Title</title> </head> <body><form?action="/user"?method="get"><input?value="Get提交"?type="submit"></form><form?action="/user"?method="post"><input?value="Post提交"?type="submit"></form><form?action="/user"?method="post"><input?type="hidden"?name="_method"?value="DELETE"><input?value="Delete提交"?type="submit"></form><form?action="/user"?method="post"><input?type="hidden"?name="_method"?value="PUT"><input?value="Put提交"?type="submit"></form> </body> </html>

編寫Controller處理請求：

@RestController public?class?HelloController?{@GetMapping("/user")public?String getUser(){return?"Get";}@PostMapping("/user")public?String postUser(){return?"Post";}@DeleteMapping("/user")public?String deleteUser(){return?"Delete";}@PutMapping("/user")public?String putUser(){return?"Put";} }

最后需要在配置文件中開啟對Rest的支持：

spring.mvc.hiddenmethod.filter.enabled=true

常用參數及注解

下面介紹Web開發中的一些常用參數和注解。

@PathVariable

該注解用于獲取路徑變量，比如：

@GetMapping("/user/{id}") public?String?getUser(@PathVariable("id") Integer id){return?id + ""; }

此時若請求url為http://localhost:8080/user/2，則獲取到id值為2。

@RequestHeader

該注解用于獲取請求頭，比如：

@GetMapping("/header") public String getHeader(@RequestHeader("User-Agent") String userAgent){return?userAgent; }

它還能夠通過一個Map集合獲取所有的請求頭信息：

@GetMapping("/header") public Map<String, String> getHeader(@RequestHeader?Map<String,String> headers){return?headers; }

@RequestParam

該注解用于獲取請求參數，比如：

@GetMapping("/param") public?String?getParam(@RequestParam("name") String?name,@RequestParam("age") Integer age){return?name + ":"?+ age; }

此時若請求url為http://localhost:8080/param?name=zhangsan&age=20，則得到值 zhangsan:20?。

@CookieValue

該注解用于獲取Cookie值，比如：

@GetMapping("/cookie") public String getCookie(@CookieValue("Idea-8296e76f") String cookie) {return?cookie; }

它還可以通過Cookie鍵名獲取一個Cookie對象：

@GetMapping("/cookie") public String getCookie(@CookieValue("Idea-8296e76f") Cookie cookie) {return?cookie.getName(); }

@RequestBody

該注解用于獲取獲取請求體的值，比如：

@PostMapping("/body") public String getBody(@RequestBody?String content) {return?content; }

既然是獲取請求體的值，那么只有Post請求才有請求體，所以編寫一個表單：

<!DOCTYPE html> <html?lang="en"> <head><meta?charset="UTF-8"><title>Title</title> </head> <body><form?action="/body"?method="post">賬號:<input?type="text"?name="username"><br>密碼:<input?type="text"?name="password"><br><input?type="submit"?value="提交"></form> </body> </html>

通過該表單提交數據后，得到 username=admin&password=123?。

@RequestAttribute

該注解用于獲取request域的數據，比如：

@GetMapping("/success") public String success(@RequestAttribute("msg") String msg){return?msg; }

通過鍵名即可獲取request域中的數據。

@MatrixVariable

該注解用于獲取矩陣變量，比如：

@GetMapping("/matrix/{path}") public?String?getMatrix(@MatrixVariable("name") String?name,@MatrixVariable("age") Integer age,@PathVariable("path") String?path) {return?path + "---"?+ name + ":"?+ age;

對于該注解的使用，需要注意幾點，首先矩陣變量是綁定在路徑中的，所以請求映射中一定要攜帶一個${path}；其次在SpringBoot中默認禁用掉了矩陣變量的功能，所以我們還需要手動去開啟該功能：

@Configuration public?class?MyConfig?{@Beanpublic?WebMvcConfigurer webMvcConfigurer(){return?new?WebMvcConfigurer() {@Overridepublic?void?configurePathMatch(PathMatchConfigurer configurer)?{UrlPathHelper urlPathHelper = new?UrlPathHelper();urlPathHelper.setRemoveSemicolonContent(false);configurer.setUrlPathHelper(urlPathHelper);}};} }

此時訪問請求url：http://localhost:8080/matrix/test;name=zhangsan;age=20，得到結果：test---zhangsan:20?。

攔截器

一個完善的Web應用一定要考慮安全問題，比如，只有登錄上系統的用戶才能查看系統內的資源，或者只有具備相關權限，才能訪問對應的資源，為此，我們需要學習一下攔截器，通過攔截器我們就能夠實現這些安全認證。

這里以登錄檢查為例：

public?class?LoginInterceptor?implements?HandlerInterceptor?{@Overridepublic?boolean?preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)?throws?Exception {HttpSession session = request.getSession();Object user = session.getAttribute("user");if(user != null){return?true;}response.sendRedirect("/toLogin");return?false;}@Overridepublic?void?postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)?throws?Exception {}@Overridepublic?void?afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)?throws?Exception {} }

編寫好攔截器后需要將其配置到容器中：

@Configuration public?class?MyWebMvcConfig?implements?WebMvcConfigurer?{@Overridepublic?void?addInterceptors(InterceptorRegistry registry)?{registry.addInterceptor(new?LoginInterceptor()).addPathPatterns("/**") .excludePathPatterns("toLogin", "/css/**", "/js/**", "/fonts/**", "/images/**"); } }

需要指定該攔截器需要攔截哪些資源，需要放行哪些資源，這樣一個簡單的登錄校驗就完成了。

文件上傳

Spring Boot中該如何實現文件上傳呢？現有如下的一個表單：

<!DOCTYPE html> <html?xmlns:th="http://www.thymeleaf.org"> <head><meta?charset="UTF-8"><title>Title</title> </head> <body><form?action="/upload"?method="post"?enctype="multipart/form-data"><input?type="file"?name="f"><input?type="submit"?value="上傳"></form> </body> </html>編寫控制方法： @RestController public?class?FileController {@PostMapping("/upload")public?String?upload(@RequestPart("f") MultipartFile file){String?name = file.getOriginalFilename();long size = file.getSize();return?name + ":"?+ size;} }

通過@RequestPart注解即可將上傳的文件封裝到MultipartFile中，通過該對象便可以獲取到文件的所有信息。輸出結果：

若是上傳多個文件，則先修改表單信息：

在文件框位置添加multiple屬性即可支持多文件上傳，然后修改控制器代碼：

@PostMapping("/upload") public?String?upload(@RequestPart("f") MultipartFile[] file){return?file.length + ""; }

若是需要將上傳的文件保存到服務器，則可以如此做：

@PostMapping("/upload") public?String?upload(@RequestPart("f") MultipartFile[] file) throws IOException {for?(MultipartFile multipartFile : file) {if(!multipartFile.isEmpty()){String?filename = multipartFile.getOriginalFilename();multipartFile.transferTo(new?File("E:\\"?+ filename));}}return?"success"; }

因為Spring Boot默認的文件上傳大小限制為1MB，所以只要文件稍微大了一點就會上傳失敗，為此，可以修改SpringBoot的默認配置：

spring.servlet.multipart.max-file-size=30MB # 配置單個文件上傳大小限制 spring.servlet.multipart.max-request-size=100MB # 配置總文件上傳大小限制

錯誤處理

默認情況下，SpringBoot應用出現了異常或錯誤會自動跳轉至/error頁面，也就是這個熟悉的頁面：

然而一般情況下，我們都不會選擇出異常時顯示這個頁面，而是想要顯示我們自己定制的頁面，為此，我們可以在/static或/templates目錄下新建一個error目錄，并在/error目錄下放置命名為4xx、5xx的頁面，SpringBoot會自動幫助我們解析。?

此時當出現5xx的異常時，SpringBoot會自動跳轉至5xx.html頁面，當然你也可以對每個狀態碼都做一個頁面進行對應，比如放置500.html、501.html、502.html文件，當服務器出現對應的異常時，就會跳轉至對應的頁面。

數據層

下面，我們將探究SpringBoot與數據訪問層框架的整合與使用。Spring Boot 與其他第三方中間件整合的技術文章也發布過，我整理成了 PDF，關注微信公眾號「Java后端」回復「666」下載這一本技術棧手冊。

JDBC

若想使用原生的JDBC進行開發，SpringBoot已經為我們配置好了JDBC的相關信息，只需要引入依賴：

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jdbc</artifactId> </dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.49</version> </dependency>

Spring Boot 底層自動配置了HikariDataSource數據源，所以我們只需指定數據源的地址、用戶名和密碼即可：

spring.datasource.url=jdbc:mysql: spring.datasource.username=root spring.datasource.password=123456 spring.datasource.driver-class-name=com.mysql.jdbc.Driver

因為SpringBoot已經自動配置好了JdbcTemplate，所以我們直接使用就可以了：

@SpringBootTest class?SpringbootApplicationTests {@Autowiredprivate?JdbcTemplate jdbcTemplate;@Testvoid?contextLoads() {List<String> names = jdbcTemplate.queryForList("select name from student",String.class);for?(String?name : names) {System.out.println(name);}} }

Druid

若是不想使用Spring Boot底層的數據源，我們也可以修改默認配置，以Druid數據源為例，首先引入依賴：

<dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-starter</artifactId><version>1.1.10</version> </dependency>

并對Druid進行配置：

#?開啟Druid的監控頁功能 spring.datasource.druid.stat-view-servlet.enabled=true #?開啟防火墻功能 spring.datasource.druid.filter-class-names=stat,wall #?配置監控頁的用戶名和密碼 spring.datasource.druid.stat-view-servlet.login-username=admin spring.datasource.druid.stat-view-servlet.login-password=123 #?開啟Druid的Web監控功能 spring.datasource.druid.web-stat-filter.enabled=true #?配置監控哪些請求 spring.datasource.druid.web-stat-filter.url-pattern=...

此時訪問http://localhost:8080/druid，將會來到Druid的監控頁：

MyBatis

接下來我們將整合MyBatis框架，并介紹它的簡單使用。首先引入依賴：

<dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.1.4</version> </dependency>

然后編寫Mapper接口：

@Mapper public?interface?StudentMapper?{Student getStu(Integer id); }

編寫Mappe配置文件：

<?xml version="1.0"?encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper?namespace="com.wwj.springboot.dao.StudentMapper"><select?id="getStu"?resultType="com.wwj.springboot.bean.Student">select * from student where id = #{id}</select> </mapper>

最后配置一下MyBatis：

#?配置Mapper配置文件的位置 mybatis.mapper-locations=classpath:mappers

這樣就可以使用MyBatis了：

@SpringBootTest class?SpringbootApplicationTests?{@Autowiredprivate?StudentMapper studentMapper;@Testvoid?contextLoads()?{Student stu = studentMapper.getStu(1);System.out.println(stu);} }

Redis

若是想要整合Redis，也非常地簡單，首先引入依賴：

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId> </dependency>

然后進行配置：

#?主機地址 spring.redis.host=172.16.136.196

只需要配置Redis的主機地址就可以操作Redis了，操作步驟如下：

@SpringBootTest class?SpringbootApplicationTests {@Autowiredprivate?StringRedisTemplate redisTemplate;@Testvoid?contextLoads() {ValueOperations<String, String> operations = redisTemplate.opsForValue();operations.set("name","zhangsan");String?name = operations.get("name");System.out.println(name);} }

若是想使用Jedis操作Redis，則需要導入Jedis的依賴：

<dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId> </dependency>

并配置：

spring.redis.client-type=jedis最后，再給大家分享一份很好的算法刷題指南，我們都知道面試的不可避免的就是手撕代碼，而且一般都是很難掌握的，我在前面面試中就是每天刷題，很費時間，也是很辛苦的，今天給大家推薦份來自字節跳動大佬的算法手冊，我看過，感覺很不錯，大家可以先看一下下面的內容：點擊關注下方公眾號，回復「算法」獲取

總結

以上是生活随笔為你收集整理的2021 版 Spring Boot 基础知识复习手册（2w字，建议收藏）的全部內容，希望文章能夠幫你解決所遇到的問題。

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

上一篇： SpringBoot接口幂等性实现的4种
下一篇：昨天还在for循环里写加号拼接字符串的那