程序員如何快速配置spring
A. 北大青鳥java培訓：學習Spring的學習路線
對於java編程開發程序員來說，掌握新的編程技術能力能夠讓自己的職業發展更加順利，下面IT培訓http://www.kmbdqn.cn/就一起來了解一下，java程序員學習學習Spring的基礎要求。
Spring官網頁是這么介紹自己的——「Spring:thesourceformodernJava」，這也暗示著Spring與Java有著密切的關系，雖然Spring現在也支持其他語言，比如Groovy和Kotlin，但還是建議在學習Spring之前先儲備一些基本的Java知識，如果能具備以下基礎，則是更好不過了。
Spring學習路徑1.SpringFramework大家通常提到的Spring其實是指SpringFramework，它是一個開源的Java企業級應用開發框架，提供了一套完整的編程與配置模型，降低了應用的開發復雜度，讓開發者能夠更加專注於應用真正的業務邏輯。
2.SpringBoot隨著Spring的發展，它早已從一個輕量級開發框架演變為一個「龐然大物」，從頭開始搭建一個新應用的成本越來越高，充斥著大量的重復工作，有大量新的佳實踐需要總結並落地。
因此，SpringBoot應運而生，它能幫助開發者輕松地創建出具備生產能力的獨立應用，只需很少的配置就能讓大部分功能運作起來。
毫不誇張地說，只要能用好SpringBoot，一定能夠極大程度地提升開發效率。
3.SpringCloud在雲計算日益普及的今天，微服務架構、雲原生應用等概念也逐步被大家所接受，大家對大規模分布式系統早已司空見慣，這也對開發者提出了更高的要求。
SpringCloud在SpringFramework與SpringBoot的基礎之上，為分布式系統的開發提供了一套經過實踐驗證的常見模式，比如服務的發現與注冊、服務的熔斷與限流、服務配置、服務鏈路追蹤等等。
基於SpringCloud，開發者能夠很快開發出一套分布式系統，以此滿足不斷變化的業務需要。
4.其他Spring項目除了上面提到的項目，Spring的大家族中還有很多成員，它們也在各自的領域中不斷為提升開發者的工作效率默默努力著。
B. 如何在Maven中配置Spring依賴
在Maven中Spring的基礎配置
Spring是高度模塊化的，可以單獨使用Spring的某個庫而不需要依賴Spring的其他庫。比如，使用Spring Context庫不需要依賴Spring Persistence或者Spring MVC庫。
讓我們先從最簡單開始，在Maven中配置spring-context依賴：
<properties>
<org.springframework.version>3.2.8.RELEASE</org.springframework.version>
<!-- <org.springframework.version>4.0.2.RELEASE</org.springframework.version> -->
</properties>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${org.springframework.version}</version>
<scope>runtime</scope>
</dependency>
上例定義的對spring-context的依賴，spring-context實現了Spring注入容器並且依賴：spring-core,spring-expression,spring-aop以及spring-beans。這些依賴包使容器可以支持Spring的一些核心技術：Spring核心組件,Spring EL表達式 (SpEL), 面向切面編程,JavaBean機制。
注意，在runtime范圍定義這個依賴，因此需求確定在編譯期間不需要依賴相關Spring特定的API。在一些高級應用場景下，一些Spring依賴項可以不用配置runtime范圍，但是在目前比較簡單的項目場景下，不需要針對Spring編譯項目去獲得整個框架的全部功能。
同樣要注意的是，從Spring 3.2開始不需要定義CGLIB依賴（目前的版本是CGLIB 3.0）。現在使用內嵌在spring-core JAR（更多詳細信息可以查看相關[JIRA]https://jira.springsource.org/browse/SPR-9669("JIRA")中的cglib包（net.sf.cglib現在使用org.springframework.cglib替代）。
在Maven配置Spring持久化框架
現在來看看Spring持久化框架的配置（主要是spring-orm）
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${org.springframework.version}</version>
</dependency>
上面的配置增加了Hibernate和JPA功能支持，比如HibernateTemplate和JpaTemplate以及一些額外的持久化相關的依賴：spring-jdbc和spring-tx
在JDBC數據訪問庫定義Spring JDBC支持以及JdbcTemplate，Spring-tx提供了非常靈活的事務管理抽象。
在Maven配置Spring MVC
要增加Spring Web和Servlet支持，需要在上面已配置的pom文件中額外增加兩個依賴：
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${org.springframework.version}</version>
</dependency>
spring-web包包含Servlet和Portlet所需要通用組件，spring-webmvc則在Servlet環境中啟用MVC支持。
由於spring-webmvc依賴於spring-web，所以定義了spring-webmvc依賴後，可以不用顯示的在pom定義spring-web。
在Maven中配置Spring Test
可以通過下面的依賴配置將Spring Test引入項目
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
<scope>test</scope>
</dependency>
從Spring 3.2開始，Spring MVC Test項目已經被包含到核心的Spring Test框架中（原來是一個獨立項目，項目託管在GitHub）。所以，從Spring 3.2開始，僅需要在依賴配置中配置spring-test依賴即可。
注意：對於使用Spring 3.1及以下版本的應用來說，獨立的spring-mvc-test依賴還是可以使用的，可以參考這里進行配置。但是，這個依賴已經不再Maven的中央庫中，所以如果需要增加依賴需要配置自定義Maven容器。
7. 使用Milestones（里程碑）版本
Spring的最新穩定版本保存在Maven的中央庫，如果項目需要使用Spring的里程碑版本，需要在pom中配置自定義容器：
<repositories>
<repository>
<id>repository.springframework.maven.milestone</id>
<name>Spring Framework Maven Milestone Repository</name>
<url>http://repo.spring.io/milestone/</url>
</repository>
</repositories>
當容器配置完成後，項目就可以像下面示例一樣定義依賴了：
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>3.2.0.RC2</version>
</dependency>
8. 使用Snapshots（快照）版本
與里程碑版本一樣，快照版本也需要配置自定義容器位置：
<repositories>
<repository>
<id>repository.springframework.maven.snapshot</id>
<name>Spring Framework Maven Snapshot Repository</name>
<url>http://repo.spring.io/snapshot/</url>
</repository>
</repositories>
當快照容器位置配置完成後，下面的依賴配置就可以使用了：
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>3.3.0.BUILD-SNAPSHOT</version>
</dependency>
對於4.x版本也是一樣的：
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.0.3.BUILD-SNAPSHOT</version>
</dependency>
C. 如何用Java類配置Spring MVC
1.方法一：在初始化時保存ApplicationContext對象
代碼：
ApplicationContext ac = new ("applicationContext.xml");
ac.getBean("beanId");
說明：這種方式適用於採用Spring框架的獨立應用程序，需要程序通過配置文件手工初始化Spring的情況。
2.方法二：通過Spring提供的工具類獲取ApplicationContext對象
代碼：
import org.springframework.web.context.support.WebApplicationContextUtils;
ApplicationContext ac1 = WebApplicationContextUtils.(ServletContext sc);
ApplicationContext ac2 = WebApplicationContextUtils.getWebApplicationContext(ServletContext sc);
ac1.getBean("beanId");
ac2.getBean("beanId");
說明：
這種方式適合於採用Spring框架的B/S系統，通過ServletContext對象獲取ApplicationContext對象，然後在通過它獲取需要的類實例。
上面兩個工具方式的區別是，前者在獲取失敗時拋出異常，後者返回null。
其中 servletContext sc 可以具體 換成 servlet.getServletContext()或者 this.getServletContext() 或者 request.getSession().getServletContext(); 另外，由於spring是注入的對象放在ServletContext中的，所以可以直接在ServletContext取出 WebApplicationContext 對象： WebApplicationContext webApplicationContext = (WebApplicationContext) servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
3.方法三：繼承自抽象類ApplicationObjectSupport
說明：抽象類ApplicationObjectSupport提供getApplicationContext()方法，可以方便的獲取到ApplicationContext。
Spring初始化時，會通過該抽象類的setApplicationContext(ApplicationContext context)方法將ApplicationContext 對象注入。
4.方法四：繼承自抽象類WebApplicationObjectSupport
說明：類似上面方法，調用getWebApplicationContext()獲取WebApplicationContext
5.方法五：實現介面ApplicationContextAware
說明：實現該介面的setApplicationContext(ApplicationContext context)方法，並保存ApplicationContext 對象。
Spring初始化時，會通過該方法將ApplicationContext對象注入。
D. Spring IOC核心功能快速入門
IOC： 控制反轉，是一種理論，概念，思想。把對象的創建，賦值，管理工作交給代碼之外的容器實現，也就是對象的創建是由其他的外部資源完成。
Spring 容器是 Spring 框架的核心。容器將創建對象，把它們連接在一起，配置它們，並管理他們的整個生命周期從創建到銷毀。Spring 容器使用依賴注入（DI）來管理組成一個應用程序的組件，這些對象被稱為 Spring Beans。
通過閱讀配置元數據提供的指令，容器知道對哪些對象進行實例化，配置和組裝。配置元數據可以通過 XML，Java 注釋或 Java 代碼來表示。 Spring IoC 容器利用 Java 的 POJO 類和配置元數據來生成完全配置和可執行的系統或應用程序。
IOC 容器具有依賴注入功能的容器，它可以創建對象，IOC 容器負責實例化、定位、配置應用程序中的對象及建立這些對象間的依賴。通常new一個實例，控制權由程序員控制，而"控制反轉"是指new實例工作不由程序員來做而是交給Spring容器來做。在Spring中BeanFactory是IOC容器的實際代表者。
使用IoC的目的：減少對代碼的改動，也能實現不同功能。實現解耦合。
第一步：創建一個Maven工程
導入Spring和junit依賴到pom.xml中：
第二步：創建一個介面
第三步：創建介面實現類
第四步：在resource資源文件目錄下創建application.xml文件
第五步：創建測試類
Spring框架的核心功能之一就是通過依賴注入的方式來管理Bean之間的依賴關系。在spring的XML配置文件中，給java對象的屬性賦值。DI注入：創建對象，給屬性賦值。
當容器調用一個無參的構造函數或一個無參的靜態 factory 方法來初始化你的 bean 後，通過容器在你的 bean 上調用設值函數，基於設值函數的 DI 就完成了。
第一步：創建一個實體類
第二步：在resource目錄下編寫application.xml文件
第三步：編寫測試類
構造注入：
當容器調用帶有一組參數的類構造函數時，基於構造函數的 DI 就完成了，其中每個參數代表一個對其他類的依賴。
第一步：創建實體類
第二步：在resource目錄下編寫application.xml文件
第三步：編寫測試類
注入內部 Beans：
Java 內部類是在其他類的范圍內被定義的，同理，inner beans 是在其他 bean 的范圍內定義的 bean。因此 或 元素中的 元素稱為內部bean。
內部 Bean 的定義不需要指定 id 和 name 。如果指定了，容器也不會將其作為區分 Bean 的標識符，反而會無視內部 Bean 的 scope 屬性。所以內部 Bean 總是匿名的，而且總是隨著外部 Bean 創建。
第一步：創建實體類
第二步：在resource目錄下編寫application.xml文件
第三步：編寫測試類
第一步：創建實體類
第二步：在resource目錄下編寫application.xml文件
第三步：創建測試類
注入Bean引用：
注入 null 和空字元串的值：
自動裝配就是指 Spring 容器在不使用 和 標簽的情況下，可以自動裝配（autowire）相互協作的 Bean 之間的關聯關系，將一個 Bean 注入其他 Bean 的 Property 中。
下列自動裝配模式，它們可用於指示 Spring 容器為來使用自動裝配進行依賴注入。你可以使用 元素的 autowire 屬性為一個 bean 定義指定自動裝配模式。
當自動裝配始終在同一個項目中使用時，它的效果最好。如果通常不使用自動裝配，它可能會使開發人員混淆的使用它來連接只有一個或兩個 bean 定義。不過，自動裝配可以顯著減少需要指定的屬性或構造器參數，但你應該在使用它們之前考慮到自動裝配的局限性和缺點。
第一步：創建實體類
第二步：在resource目錄下編寫application.xml文件
第三步：創建測試類
ByType：
這種模式由屬性類型指定自動裝配。Spring 容器看作 beans，在 XML 配置文件中 beans 的 autowire 屬性設置為 byType。然後，如果它的 type 恰好與配置文件中 beans 名稱中的一個相匹配，它將嘗試匹配和連接它的屬性。如果找到匹配項，它將注入這些 beans，否則，它將拋出異常。
第一步：創建實體類
第二步：在resource目錄下編寫application.xml文件
第三步：創建測試類
由構造函數自動裝配
這種模式與 byType 非常相似，但它應用於構造器參數。Spring 容器看作 beans，在 XML 配置文件中 beans 的 autowire 屬性設置為 constructor。然後，它嘗試把它的構造函數的參數與配置文件中 beans 名稱中的一個進行匹配和連線。如果找到匹配項，它會注入這些 bean，否則，它會拋出異常。
通過spring的註解完成Java對象的創建，屬性的賦值。代替xml文件
在 XML 注入之前進行註解注入，因此後者的配置將通過兩種方式的屬性連線被前者重寫。
註解連線在默認情況下在 Spring 容器中不打開。因此，在可以使用基於註解的連線之前，我們將需要在我們的 Spring 配置文件中啟用它。所以如果你想在 Spring 應用程序中使用的任何註解，可以考慮到下面的配置文件。
1）@Component
可以使用此註解描述 Spring 中的 Bean，但它是一個泛化的概念，僅僅表示一個組件（Bean），並且可以作用在任何層次。使用時只需將該註解標注在相應類上即可。
2）@Repository
用於將數據訪問層（DAO層）的類標識為 Spring 中的 Bean，其功能與 @Component 相同。
3）@Service
通常作用在業務層（Service 層），用於將業務層的類標識為 Spring 中的 Bean，其功能與 @Component 相同。
4）@Controller
通常作用在控制層（如 Struts2 的 Action、SpringMVC 的 Controller），用於將控制層的類標識為 Spring 中的 Bean，其功能與 @Component 相同。
5）@Autowired
可以應用到 Bean 的屬性變數、屬性的 setter 方法、非 setter 方法及構造函數等，配合對應的註解處理器完成 Bean 的自動配置工作。默認按照 Bean 的類型進行裝配。
6）@Resource
作用與 Autowired 相同，區別在於 @Autowired 默認按照 Bean 類型裝配，而 @Resource 默認按照 Bean 實例名稱進行裝配。
@Resource 中有兩個重要屬性：name 和 type。
Spring 將 name 屬性解析為 Bean 的實例名稱，type 屬性解析為 Bean 的實例類型。如果指定 name 屬性，則按實例名稱進行裝配；如果指定 type 屬性，則按 Bean 類型進行裝配。如果都不指定，則先按 Bean 實例名稱裝配，如果不能匹配，則再按照 Bean 類型進行裝配；如果都無法匹配，則拋出 NoSuchBeanDefinitionException 異常。
7）@Qualifier
與 @Autowired 註解配合使用，會將默認的按 Bean 類型裝配修改為按 Bean 的實例名稱裝配，Bean 的實例名稱由 @Qualifier 註解的參數指定。
第一步：創建實體類
第二步：在resource目錄下編寫application.xml文件
第三步：創建測試類
掃描多個包：
第一步：創建實體類
第二步：xml配置文件
properties配置文件
第三步：編寫測試類
原文鏈接：https://blog.csdn.net/weixin_52058417/article/details/119277429
E. 在idea中怎麼快速配置spring
在web.xml中配置SpringMVC攔截路徑並指定SpringMVC.xml的位置 不指定的話默認為：servlet.xml
在applicationContext.xml中加入引用
在SpringMVC.xml中加入相同的引用 加入Spring註解驅動 加入Controller的包
指定SpringMVC.xml的視圖解析器 返回前綴 後綴
F. Spring框架入門
Spring是 分層 的JavaSE/EE ( 一站式 ) 輕量級 開源的 容器框架 ，以 IOC （Inverse of Control 控制反轉：對象之間的關系由容器創建，降低了程序之間的依賴性）和 AOP （Aspect Oriented Programming 面向切面編程）為內核的容器框架
一站式、分層：
JavaEE的有三層結構:web層、業務層、數據訪問層（持久層，集成層），而Spring框架有對三層的每層解決方案:
web層:Spring MVC
持久層:JDBC Template （applicationContext.xml）
業務層:Spring的Bean管理（Bean:是spring根據用戶提供相應的需求創建的對象，由IOC管理）(service)
spring官網：https://spring.io/
Spring的英文翻譯為春天，可以說是給Java程序員帶來了春天，因為它 極大地簡化了開發，有效的解決了當時軟體開發比較復雜的問題 （當時採用EJB開發JAVA EE應用，但EJB存在著學習成本太高，開發效率比較低，資源消耗很高的問題）。Spring使用基本的JavaBean來完成以前只可能由EJB完成的事情。然而，Spring的用途不僅限於伺服器端的開發。從簡單性、可測試性和松耦合的角度而言，任何Java應用都可以從Spring中受益。可以說Spring是一個提供了更完善開發環境的一個框架，可以為POJO(Plain Ordinary Java Object)對象提供企業級的服務。
Spring的優秀之處：
1、最完善的輕量級核心框架。
2、簡化了開發，方便解耦
4、集成了Toplink, Hibernate, JDO, and iBATIS SQL Maps等優秀框架。
5、強大的AOP功能：Spring提供面向切面編程，可以方便的實現對程序進行許可權攔截、運行監控等功能。
6、 方便程序的測試：Spring對Junit4支持，可以通過註解方便的測試Spring程序
這是Spring框架最基礎的部分，所有的Spring模塊都是在核心容器之上構建的。它提供了依賴注入（DependencyInjection）特徵來實現容器對Bean的管理。這里最基本的概念是BeanFactory，它是任何Spring應用的核心。BeanFactory是工廠模式的一個實現，它使用IOC（控制反轉）將應用配置和依賴說明從實際的應用代碼中分離出來。
核心模塊的BeanFactory使Spring成為一個容器，而上下文模塊使它成為一個框架。這個模塊擴展了BeanFactory的概念，增加了對國際化（I18N）消息、事件傳播以及驗證的支持（Spring 上下文是一個配置文件，向 Spring 框架提供上下文信息）。
另外，這個模塊提供了許多企業服務，例如電子郵件、JNDI訪問、EJB集成、遠程以及時序調度（scheling）服務。也包括了對模版框架例如Velocity和FreeMarker集成的支持。
Spring在它的AOP模塊中提供了對面向切面編程的豐富支持。這個模塊是在Spring應用中實現切面編程的基礎。為了確保Spring與其它AOP框架的互用性，Spring的AOP支持基於AOP聯盟定義的API。AOP聯盟是一個開源項目，它的目標是通過定義一組共同的介面和組件來促進AOP的使用以及不同的AOP實現之間的互用性。通過訪問他們的站點，你可以找到關於AOP聯盟的更多內容。
Spring的AOP模塊也將元數據編程引入了Spring。使用Spring的元數據支持，你可以為你的源代碼增加註釋，指示Spring在何處以及如何應用切面函數。
使用JDBC經常導致大量的重復代碼，取得連接、創建語句、處理結果集，然後關閉連接。Spring的JDBC和DAO模塊抽取了這些重復代碼，因此你可以保持你的資料庫訪問代碼干凈簡潔，並且可以防止因關閉資料庫資源失敗而引起的問題。
這個模塊還在幾種資料庫伺服器給出的錯誤消息之上建立了一個有意義的異常層。使你不用再試圖破譯神秘的私有的SQL錯誤消息！
另外，這個模塊還使用了Spring的AOP模塊為Spring應用中的對象提供了事務管理服務。
對那些更喜歡使用對象/關系映射工具而不是直接使用JDBC的人，Spring提供了ORM模塊。Spring並不試圖實現它自己的ORM解決方案，而是為幾種流行的ORM框架提供了集成方案，包括Hibernate、JDO和iBATIS SQL映射。Spring的事務管理支持這些ORM框架中的每一個也包括JDBC。
Web上下文模塊建立於應用上下文模塊之上，提供了一個適合於Web應用的上下文。另外，這個模塊還提供了一些面向服務支持。例如：實現文件上傳的multipart請求，它也提供了Spring和其它Web框架的集成，比如Struts、WebWork。
Spring為構建Web應用提供了一個功能全面的MVC框架。雖然Spring可以很容易地與其它MVC框架集成，例如Struts，但Spring的MVC框架使用IoC對控制邏輯和業務對象提供了完全的分離。
UserService的介面
UserService的實現類
G. 二、springboot配置文件
1. 配置文件
Spring Boot使用一個全局的配置文件
application.properties
application.yml
配置文件的作用：修改Spring Boot自動配置的默認值，SpringBoot在底層都給我們自動
配置好。有什麼配置項，可以移步官方文檔
配置文件一般放在src/main/resources目錄或者類路徑/confifig下，當然還有很多位置可
以放，它們會有不同優先順序，後面會講到。
YAML （YAML Ain't Markup Language）
簡單介紹
<!--綁定配置文件處理器，配置文件進行綁定的時候就會有提示-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<!-- 將應用打包成一個可執行Jar包，直接使用java -jar xxxx的命令來執行 -->
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>以前的配置文件：大多是xml
.yml是YAML語言的文件，以數據為中 心，比json、xml等更適合做配置文件
全局配置文件的可以對一些默認配置值進行修改
配置實例
xml：
yml:
2. YAML語法
基本語法
K:(空格)V 標識一對鍵值對
以空格的縮進來控制層級關系
只要是左對齊的一列數據，都是同一層級的
屬性和值也是大小寫敏感
實例：
值的寫法
普通的值
k: v 字面量直接來寫，字元串默認不用添加單引號
" " 雙引號 不會轉義字元串裡面的特殊字元；
<server>
<port>8081</port>
</server>
server:
port: 8081
server:
port: 8081
path: /hello // 冒號後面的空格不要拉下' ' 單引號 會轉義字元，特殊字元最終是一個普通的字元串
對象
普通寫法：
行內寫法
frends:{ lastName: zhang,age: 18 }
Map
示例：
maps: {k1: v1,k2: v2}
數組
普通寫法：
pets: // var onj = {pets: ['cat','pig','dog']}
- cat
- pig
- dog
行內寫法
pets:[cat, pig, dog]
配置文件獲取
將配置文件中的每一個值映射到此組件中
1. Persion
name: "wang \n qian" // 輸出：wang 換行 qian
frends:
lastName: zhang
age: 20package com.wrq.boot.bean;
@Component
@ConfigurationProperties(prefix = "persion")
public class Persion {
private String name;
private int age;
private double weight;
private boolean boss;
private Date birth;
private Map<String,Object> maps;
private List<Object> list;
private Dog dog;
此處，這個bean的getter、setter和tostring方法已經省略，千萬不能忽略！
}
@ConfifigurationProperties 意思是:我們類裡面的屬性和配置文件中的屬性做綁定
不使用此註解，可以在bean的屬性添加@value()註解，如下：
@Component
// @ConfigurationProperties(prefix = "persion")
public class Persion {
@value("${persion.name}") // $()讀取配置文件、環境變數中的值
private String name;
@value("#{11*2}") // #{SpEL} 採用表達式
private int age;
@value("true") // 直接賦值
private boolean boos;
}
此處採用@ConfifigurationProperties的方式，@value()和@ConfifigurationProperties的
區別見下方表格。prefifix = "persion" 配置文件中那個下面的屬性來一一映射
@Component 如果想要這個註解起作用，必須放到容器裡面
2. Dog
package com.wrq.boot.bean;
public class Dog { // 用作Persion中的屬性
private String name;
private int age;
此處，這個bean的getter、setter和tostring方法已經省略，千萬不能忽略！
}
3. 配置文件
方式一: application.yml
persion:
name: 王大錘
age: 18
weight: 125
boss: false
birth: 2018/5/5
maps: {k1: v1,k2: v2}
list:
- wangli
- wang
dog:
name: xiaogou
age: 2
方式二: application.propertiespersion.name = 王大錘
persion.age = 18
persion.weight = 125
persion.boss = false
persion.birth = 2018/5/5
persion.maps.k1 = v1
persion.maps.k2 = v2
persion.dog.name = xiaogou
persion.dog.age = 15
4. 測試類：BootApplicationTests
package com.wrq.boot;
@RunWith(SpringRunner.class)
@SpringBootTest
public class BootApplicationTests {
@Autowired
Persion persion;
@Test
public void contextLoads() {
System.out.print(persion);
}
}
5. 運行 BootApplicationTests方法
控制台列印：
application.yml的結果：
Persion{name='王大錘', age=18, weight=125.0, boss=false, birth=Sat May
05 00:00:00 CST 2018, maps={k1=v1, k2=v2}, list=[wangli, wang],
dog=Dog{name='xiaogou', age=2}}
application.properties的結果：
Persion{name='��Ǭ', age=18, weight=125.0, boss=false, birth=Sat
May 05 00:00:00 CST 2018, maps={k2=v2, k1=v1}, list=[wangli, wang],
dog=Dog{name='xiaogou', age=15}}
把Bean中的屬性和配置文件綁定，通過yml文件和properties都可以做到,但是properties
文件出現亂碼。
properties中文讀取亂碼：File->Settings->File Encodings最底部選utf-8、Tranparent打
上勾
註解比較
@value和@ConfifigurationProperties獲取值比較
名詞解釋:
鬆散綁定
last-name和lastName都可以獲取導致，則代表支持鬆散綁定
JSR303@Component
@ConfigurationProperties(prefix = "persion") // 如果使用的是@value注入值
時，無法使用校驗
@Validated // 添加此註解
public class Persion {
@Email // 配置文件書寫的屬性必須是郵箱格式，不符合報錯！
private String name;
}
復雜類型封裝
如果獲取配置文件中map的值時,@value是獲取不到值的
@value("${persion.maps}") // 由於使用的是@value，無法獲取配置文件中的map
private Map<String,Object> maps;
@PropertySource
@PropertySource：載入指定配置文件
@ConfifigurationProperties()默認是從全局配置文件中獲取值，也就是
application.properties這個文件中獲取值。
如果做的配置很多，全局的配置文件就會特別大，為了方便管理。我會創建不同的配置文
件定向管理不同的配置。
如創建persion.properties文件單獨存放persion需要的配置
@PropertySource就是用來導入創建的配置文件
示例：
1. persion.properties
同時把兩個全局的配置中關於Persion的配置都注釋掉persion.name = 王弟弟
persion.age = 18
persion.weight = 125
persion.boss = false
persion.birth = 2018/5/5
persion.maps.k1 = v1
persion.maps.k2 = v2
persion.dog.name = xiaogou
persion.dog.age = 15
2. Persion
package com.wrq.boot.bean;
@Component
@PropertySource(value = {"classpath:persion.properties"})
@ConfigurationProperties(prefix = "persion")
public class Persion {
private String name;
private int age;
private double weight;
private boolean boss;
private Date birth;
private Map<String,Object> maps;
private List<Object> list;
private Dog dog;
此處，這個bean的getter、setter和tostring方法已經省略，千萬不能忽略！
}
這樣運行測試類，控制台就可以列印persion.properties中的數據。
通過下面的註解，把類路徑下的persion.properties載入進來。並且把persion開頭的數
據進行綁定。
@PropertySource(value = {"classpath:persion.properties"})@ConfifigurationProperties(prefifix = "persion")
@ImportResource
@ImportResource：導入Spring的配置文件，讓配置文件生效。
示例：
1. com.wrq.boot.service
package com.wrq.boot.service;
/**
* Created by wangqian on 2019/1/12.
*/
public class HelloService {
}
2. resources目錄手動建立bean.xml
<?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="helloService" class="com.wrq.boot.service.HelloService">
</bean>
</beans>
3. 測試類
package com.wrq.boot;
@RunWith(SpringRunner.class)
@SpringBootTest
public class BootApplicationTests {
@Autowired
ApplicationContext ioc;@Test
public void testConfig() {
boolean b = ioc.containsBean("helloService");
System.out.print(b);
}
}
試圖通過添加一個Spring的配置文件bean.xml來把HelloService注入進去。
運行測試類結果：false
結果表明IoC容器中並不包含HelloService，即：配置文件bean.xml沒有生效
解決方式
方式一： 主程序中進行配置@ImportResouece註解
package com.wrq.boot;
@ImportResource(locations = {"classpath:bean.xml"}) // 通過此配置是
bean.xml生效
@SpringBootApplication
public class BootApplication {
public static void main(String[] args) {
//應用啟動起來
SpringApplication.run(BootApplication.class, args);
}
}
方法二：通過配置類實現，這種方式也是Spring Boot推薦的
1. com.wrq.boot.confifigpackage com.wrq.boot.config;
/**
* Created by wangqian on 2019/1/12.
*/
@Configuration
public class MyConfig {
// 將方法的返回值添加到容器之中,並且容器中這個組件的id就是方法名
@Bean
public HelloService helloService(){
System.out.print("通過@Bean給容器添加組件了..");
return new HelloService();
}
}
@Confifiguration標注這是一個配置類
通過@Bean註解，將方法的返回值添加到容器之中,並且容器中這個組件的id就是方
法名
2. 把主程序類中@ImportResource()配置注釋掉
3. 測試成功，添加了HelloService()組件
3. 配置文件佔位符
隨機數
RandomValuePropertySource：配置文件中可以使用隨機數
${random.value}
${random.int}
${random.long}
${random.uuid}
${random.int(10)}
${random.int[1024,65536]}
屬性配置佔位符可以在配置文件中引用前面配置過的屬性（優先順序前面配置過的這里都能用）
${app.name:默認值}來指定找不到屬性時的默認值
persion.name = 王弟弟${random.uuid}
persion.age = ${random.int}
persion.dog.name = ${persion.name}_dog
4. Profifile 多環境支持
Profifile是Spring對不同環境提供不同配置功能的支持，可以通過激活、 指定參數等方式
快速切換環境
1. 多Profifile的方式
格式：application-{profifile}.properties/yml
application-dev.properties
application-prod.properties
默認採用application.properties配置文件，如果使用別的，需要激活：
1. application.properties中配置：
# 激活application-dev.properties配置文件
spring.profiles.active=dev
2. application-dev.properties:
server.port=8082
3. 運行BootApplication主程序:
2019-01-12 20:46:09.345 INFO 14404 --- [main]
s.b.c.e.t. : Tomcat started on port(s):
8082 (http)
2. 多文檔塊的方式
除了上方多Profifile的方式來切換環境，也可以通過YAML多文檔塊的方式。示例:
application.yml:
server:
port: 8081
spring:
profiles:
active: dev
---
spring:
profiles: dev
server:
port: 8083
---
spring:
profiles: prod
server:
port: 8084
3. 激活指定Profifile
1. application.properties中配置：
# 激活application-dev.properties配置文件
spring.profiles.active=dev
2. application.yml中配置
server:
port: 8081
spring:
profiles:
active: dev
---
spring:
profiles: dev
server:
port: 80833. 啟動配置-參數
在IDE中，類似於配置tomcat的地方，按下方配置：
Program arguments:--spring.profiles.active=dev
4. 啟動配置-虛擬機
在IDE中，類似於配置tomcat的地方，按下方配置：
VM options:-Dspring-profiles-active=dev
5. 命令行 使用Maven的package命令打包，移動到jar的目錄。
java -jar spring-boot-project-config.jar --spring.profiles.active=dev
5. 配置文件優先順序
GitHub對應項目：boot-confifig-position
優先順序
Spring Boot 啟動會掃描以下位置的application.properties或者 application.yml文件作
為Spring boot的默認配置文件
fifile:./confifig/ (項目根目錄confifig文件夾下的配置文件)
fifile:./ (項目根目下的配置文件)
classpath:/confifig/ (resources目錄confifig文件夾下的配置文件)
classpath:/ (resources目下的配置文件)
以上是按照優先順序從高到低的順序，所有位置的文件都會被載入，高優先順序配置內容會覆
蓋低優先順序配置內容,形成互補配置。
默認配置
我們也可以通過配置spring.confifig.location來改變默認配置。
項目打包後以後，我們可以使用命令行參數的形式，啟動項目的時候來指定配置文件的新
位置；指定配置文件和默認載入的這些配置文件共同起作用，形成互補配置。
1. Maven->package對項目打包2. 把待使用的配置文件放在本地文件夾中，如：D:/application.properties
3. 命令行執行命令
java -jar boot-config-position-xxxxxx.jar --
spring.config.location=D:/application.properties
這樣即使項目上線了，我們也可以通過修改本地的配置文件，使用一行命令即可，極大方
便了運維人員。
6. 外部配置載入順序
Spring Boot 支持多種外部配置方式
可以從以下位置載入配置，優先順序從高到低，高優先順序配置覆蓋低優先順序的，所以配置形
成互補配置。
1. 命令行參數
java -jar boot-config-position-xxxxxx.jar --server.port // 多個配置用空格
隔開
2. 來自java:comp/env的JNDI屬性
3. Java系統屬性（System.getProperties()）
4. 操作系統環境變數
5. RandomValuePropertySource配置的random.*屬性值
6. jar包外部的application-{profifile}.properties或application.yml(帶spring.profifile)配
置文件
7. jar包內部的application-{profifile}.properties或application.yml(帶spring.profifile)配
置文件
8. jar包外部的application.properties或application.yml(不帶spring.profifile)配置文件
9. jar包內部的application.properties或application.yml(不帶spring.profifile)配置文件
10. @Confifiguration註解類上的@PropertySource
11. 通過SpringApplication.setDefaultProperties指定的默認屬性
注意：從jar包外向jar包內尋找，優先載入profifile最後載入不帶profifile，更多參考官方文
檔
7. 自動配置原理GitHub對應項目：boot-confifig-autoconfifig
1. 配置文件寫什麼？
配置文件可配置屬性查閱
2. 什麼是註解，如何實現一個註解？
關於註解的機制和相關原理可以移步此篇博客
3. 配置原理解析
我們運行Spring Boot應用是從main方法啟動，在主程序類上有一個
@SpringBootApplication註解。
@SpringBootApplication是一個復合註解，包括@ComponentScan，和
@SpringBootConfifiguration，@EnableAutoConfifiguration。
@SpringBootConfifiguration繼承自@Confifiguration，二者功能也一致，標注當前類
是配置類，並會將當前類內聲明的一個或多個以@Bean註解標記的方法的實例納入到
srping容器中，並且實例名就是方法名。
@EnableAutoConfifiguration的作用啟動自動的配置，@EnableAutoConfifiguration注
解的意思就是SpringBoot根據你添加的jar包來配置你項目的默認配置，比如根據
spring-boot-starter-web ，來判斷你的項目是否需要添加了webmvc和tomcat，就
會自動的幫你配置web項目中所需要的默認配置
@ComponentScan，掃描當前包及其子包下被@Component，@Controller，
@Service，@Repository註解標記的類並納入到spring容器中進行管理。是以前的co
ntext:component-scan（以前使用在xml中使用的標簽，用來掃描包配置的平行支
持）。
@SpringBootApplication註解分析
配置原理視頻講解
4. 自動配置類判斷
在配置文件properties中設置：debug=true 來讓控制台列印自動配置報告，方便的得知
那些配置類生效。
=========================
AUTO-CONFIGURATION REPORT
=========================Positive matches:
-----------------
matched:
- @ConditionalOnClass found required class
'org.springframework.web.servlet.DispatcherServlet';
@ConditionalOnMissingClass did not find unwanted class
(OnClassCondition)
- @ConditionalOnWebApplication (required) found 'session' scope
(OnWebApplicationCondition)
Negative matches:
-----------------
ActiveMQAutoConfiguration:
Did not match:
- @ConditionalOnClass did not find required classes
'javax.jms.ConnectionFactory',
'org.apache.activemq.ActiveMQConnectionFactory' (OnClassCondition)
H. 怎麼在MyEclipse中快速配置spring框架
在MyEclipse中快速配置spring框架的步驟如下：
1、建工程；
File->New->Project->WebProject,"Project
Name":MySpringTest,然後"Finish";
2、導入spring包；
選中MySpringTest,右擊,MyEclipse
->AddSpringCapabilities……,都默認即可；
3、建立項目所需類；
（1）、介面Action:（MySpringTest->
src->New->interface,取名為Action）
publicinterfaceAction{
publicStringexecute(Stringstr);
}
（2）、實現介面Action的類UpperAction:（將其message屬性與輸入字元串相連接，並返回其大寫形式。）
{
privateStringmessage;
publicStringgetMessage(){
returnmessage;
}
publicvoidsetMessage(Stringmessage){
this.message=message;
}
publicStringexecute(Stringstr){
return(getMessage()+str).toUpperCase();
}
}
（3）、實現介面Action的類LowerAction:
{
privateStringmessage;
publicStringgetMessage(){
returnmessage;
}
publicvoidsetMessage(Stringmessage){
this.message=message;
}
publicStringexecute(Stringstr){
return(getMessage()+str).toLowerCase();
}
}
（4）、做測試用的SimpleTest類：
publicclassSimpleTest{
publicstaticvoidmain(Stringargs[]){
SimpleTesttest=newSimpleTest();
test.testQuickStart();
}
publicvoidtestQuickStart(){
ApplicationContextctx=(
"src/bean.xml");
Actionaction=(Action)ctx.getBean("action1");
System.out.println(action.execute("RodJohnson"));
action=(Action)ctx.getBean("action2");
System.out.println(action.execute("jeckj"));
}
}
4、配置applicationContext.xml文件；
<beans>
<description>SpringQuickStart</description>
<!--該處bean中的name值必須是其對應的class中的私有成員名
-->
<beanid="action1"class="UpperAction">
<propertyname="message">
<value>HeLLo</value>
</property>
</bean>
<beanid="action2"class="LowerAction">
<propertyname="message">
<value>HeLLo</value>
</property>
</bean>
</beans>
5、至此就完成了spring框架的搭建了。
I. Spring全家桶筆記：Spring+Spring Boot+Spring Cloud+Spring MVC
最近我整理了一下一線架構師的Spring全家桶筆記：Spring+Spring Boot+Spring Cloud+Spring MVC，分享給大家一起學習一下~ 文末免費獲取哦
Spring是一個輕量級控制反轉(IoC)和面向切面(AOP)的容器框架。Spring框架是由於軟體開發的復雜性而創建的。Spring使用的是基本的JavaBean來完成以前只可能由EJB完成的事情。然而，Spring的用途不僅僅限於伺服器端的開發。從簡單性、可測試性和松耦合性角度而言，絕大部分Java應用都可以從Spring中受益。
1.1 Spring面試必備題+解析
1.2 Spring學習筆記
（1）Spring源碼深入解析
（2）Spring實戰
1.3 Spring學習思維腦圖
Spring Boot是由Pivotal團隊提供的全新框架，其設計目的是用來簡化新Spring應用的初始搭建以及開發過程。該框架使用了特定的方式來進行配置，從而使開發人員不再需要定義樣板化的配置。通過這種方式，Spring Boot致力於在蓬勃發展的快速應用開發領域(rapid application development)成為領導者。
2.1 Spring Boot面試必備題+解析
2.2 Spring Boot學習筆記
（1）Spring Boot實踐
（2）SpringBoot揭秘 快速構建微服務體系
2.3 SpringBoot學習思維腦圖
springcloud是微服務架構的集大成者，將一系列優秀的組件進行了整合。基於springboot構建，對我們熟悉spring的程序員來說，上手比較容易。通過一些簡單的註解，我們就可以快速的在應用中配置一下常用模塊並構建龐大的分布式系統。
3.1 Spring Cloud面試必備題+解析
3.2 Spring Cloud學習筆記
（1）Spring Cloud參考指南
SpringMVC是一種基於Java的實現MVC設計模式的請求驅動類型的輕量級Web框架，使用了MVC架構模式的思想，將web層進行職責解耦，基於請求驅動指的就是使用請求-響應模型，框架的目的就是幫助我們簡化開發
4.1 Spring MVC面試必備題+解析
4.2 Spring MVC學習筆記
（1）看透Spring MVC源代碼分析與實踐
（2）精通Spring MVC
最後分享一下一份JAVA核心知識點整理（PDF）
J. Spring詳解(二)
傳統的創建對象的方法是直接通過 new 關鍵字 ，而 spring 則是通過 IOC 容器來創建對象，也就是說我們將創建對象的控制權交給了 IOC 容器。我們可以用一句話來概括 IOC
Spring 容器創建對象的三種方式
傳統的創建對象的方法：new 關鍵字
這里通過 Spring 容器怎麼來創建呢？
第一種方法：利用默認的構造方法
在 src 目錄下新建 applicationContext.xml 文件，這是 spring 配置文件，添加如下代碼：
<?xml version="1.0" encoding="UTF-8"?>
<beans p=""
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">
<!--
創建對象的第一種方式：利用無參構造器
id:唯一標識符
class:類的全類名
-->
/**
* Spring 容器利用構造函數創建對象
*/
@Test
public void testCreateObjectByConstrutor(){
//1、啟動 spring 容器
ApplicationContext context =
new ("applicationContext.xml");
//2、從 spring 容器中取出數據
HelloIoc IOC = (HelloIoc) context.getBean("helloIoc");
//3、通過對象調用方法
IOC.sayHello();
//利用配置文件 alias 別名屬性創建對象
HelloIoc IOC2 = (HelloIoc) context.getBean("helloIoc2");
IOC2.sayHello();
}
HelloIoc.java 中手動添加無參的構造方法，然後執行上面的測試代碼，會發現構造方法會在 sayHello()方法執行之前調用
<?xml version="1.0" encoding="UTF-8"?>
<beans p=""
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">
public static void main(String[] args) {
ApplicationContext ac=new ("beans.xml");
JavaWork javaWork=(JavaWork)ac.getBean("javaWork");
javaWork.doTest();
}
public class JavaWork {
private Tester tester;
public void setTester(Tester tester) {
this.tester = tester;
}
public void doTest(){
/*ZhangSan zhangsan=new ZhangSan();
zhangsan.test();*/
tester.test();
}
}
第二種方法：利用靜態工廠方法
首先創建靜態工廠類 HelloStaticFactory.java
接著在 applicationContext.xml 中進行如下配置：
<!--
創建對象的第二種方式：利用靜態工廠方法
factory-method：靜態工廠類的獲取對象的靜態方法
class:靜態工廠類的全類名
-->
/**
* Spring 容器利用靜態工廠方法創建對象
*/
@Test
public void createObjectStaticFactory(){
ApplicationContext context =
new ("applicationContext.xml");
HelloIoc staticFactory =
(HelloIoc) context.getBean("helloStaticFactory");
staticFactory.sayHello();
}
spring容器只負責調用靜態工廠方法，而這個靜態工廠方法內部實現由程序員完成
利用實例工廠方法
首先創建實例工廠類 HelloInstanceFactory .java
public class HelloInstanceFactory {
public HelloInstanceFactory(){
System.out.println("實例工廠方法構造函數");
}
//利用實例工廠方法創建對象
public HelloIoc getInstance(){
HelloIoc instanceIoc = new HelloIoc();
return instanceIoc;
}
}
接著在 applicationContext.xml 中進行如下配置：
<!--
創建對象的第三種方式：利用實例工廠方法
factory-bean:指定當前Spring中包含工廠方法的beanID
factory-method:工廠方法名稱
-->
/**
* Spring 容器利用實例工廠方法創建對象
*/
@Test
public void createObjectInstanceFactory(){
ApplicationContext context =
new ("applicationContext.xml");
HelloIoc staticFactory =
(HelloIoc) context.getBean("instance");
staticFactory.sayHello();
}
Spring 容器創建對象的時機
默認情況下，啟動 spring 容器便創建對象
在spring的配置文件bean中有一個屬性 lazy-init="default/true/false"
①、如果lazy-init為"default/false"在啟動spring容器時創建對象（默認情況）
②、如果lazy-init為"true",在context.getBean時才要創建對象
在第一種情況下可以在啟動spring容器的時候，檢查spring容器配置文件的正確性，如果再結合tomcat,如果spring容器不能正常啟動，整個tomcat就不能正常啟動。但是這樣的缺點是把一些bean過早的放在了內存中，如果有數據，則對內存來是一個消耗。
反過來，在第二種情況下，可以減少內存的消耗，但是不容易發現錯誤
spring的bean中的scope："singleton/prototype/request/session/global session"
一、默認scope的值是singleton，即產生的對象是單例的
applicationContext.xml 文件中配置：
//spring 容器默認產生對象是單例的 scope="singleton"
@Test
public void test_scope_single_CreateObject(){
ApplicationContext context = new ("applicationContext.xml");
HelloIoc hello1 = (HelloIoc) context.getBean("helloIoc");
HelloIoc hello2 = (HelloIoc) context.getBean("helloIoc");
System.out.println(hello1.equals(hello2)); //true
}
scope=「prototype」
多例模式，並且spring容器啟動的時候並不會創建對象，而是在得到 bean 的時候才會創建對象
applicationContext.xml 文件中配置：
總結：在單例模式下，啟動 spring 容器，便會創建對象；在多例模式下，啟動容器並不會創建對象，獲得 bean 的時候才會創建對象
scope=「request」 每次HTTP請求都會創建一個新的bean
scope=「session」同一個HTTP Session共享一個Bean
scope=「global session」 同一個全局Session共享一個Bean，一般用於portlet應用環境
scope=「application」同一個Application 共享一個Bean
Spring 容器生命周期
/**
* Spring 容器的生命周期
* @author hadoop
*
*/
public class SpringLifeCycle {
public SpringLifeCycle(){
System.out.println("SpringLifeCycle");
}
//定義初始化方法
public void init(){
System.out.println("init...");
}
//定義銷毀方法
public void destroy(){
System.out.println("destroy...");
}
public void sayHello(){
System.out.println("say Hello...");
}
}
applicationContext.xml
public void testSpringLifeCycle(){
ApplicationContext context = new ("applicationContext.xml");
SpringLifeCycle hello = (SpringLifeCycle) context.getBean("springLifeCycle");
hello.sayHello();
//銷毀spring容器
classContext = () context;
classContext.close();
}
1、spring容器創建對象
2、執行init方法
3、調用自己的方法
4、當spring容器關閉的時候執行destroy方法
注意：當scope為"prototype"時，調用 close（） 方法時是不會調用 destroy 方法的