Spring入門 · Spring

# Spring ## Spring是什么 ### 輕量級框架輕量級的意思是Spring僅發布了單一jar包，額外的消耗可忽略不計，可以理解為代碼量少非侵入性--對應侵入性，一般使用一個jar包，都需要直接或簡介繼承提供的類或實現對應接口，存在依賴性，無依賴性即相反 *** ### Spring還是一個Bean容器(普通Java類容器) 這里可以對比著理解Tomcat，Tomcat是一個Servlet容，管理著Servlet的生命周期，即Servlet的創建，調用及銷毀,而Spring類似Tomcat,只不過管理的是Bean實例對象的生命周期，控制著對象的創建方式，調用及銷毀器 *** ### Spring是一個開源的JavaEE框架面試的時候一定先說Spring是一個框架 *** ### Spring框架的組成 Spring有許多延伸，每一個延伸功能都可以做成一個獨立的框架，而其中最為主要的是其中的核心容器因為Spring有許多延伸，所以在面試的時候不需要提這么多延伸，只需要答出最為主要的即可：Spring主要是一個IOC框架 ![](https://box.kancloud.cn/74c2c7b43749dbb464543a5ab311a65a_622x459.png) #### **核心容器core** 核心容器：主要組件就是BeanFactory--Bean工廠 BeanFactory是所有基于Spring框架系統的核心，通過BeanFactory，Spring使用工廠模式來實現IOC（控制反轉），將應用程序的配置和依賴關系與實際的應用程序分離。 Spring之所以稱為容器，就是由BeanFactory的自動裝備和注入。 #### **ORM--對象關系映射** 對象--Java編程中萬物皆對象，關系--數據庫表，例如我們所學的Oracle就是關系型數據庫的一種，數據庫管理數據用的是表，表與表之間有關系，所以ORM模塊提供了一些接口，允許第三方ORM框架接入（例如Mabatis等）。數據庫除了關系型數據庫還有鍵值型數據庫，文檔型數據庫，鍵值型數據庫里不使用表管理數據，使用的是鍵值對，redis是典型代表。文檔型數據庫里存的是json,典型代表mongodb。 #### **WEB模塊** 整體替代了以前的Servlet *** ### Spring的下載 Spring的官網[https://spring.io/](https://spring.io/) ![](https://box.kancloud.cn/aa72a80fc83c4d897072687183c7f7a7_1095x504.png) ![![](https://box.kancloud.cn/c674dcdabd383ff8e9dd5f603eba2d00_335x410.png)](images/screenshot_1520786479363.png) 下載地址：[ http://repo.spring.io/release/org/springframework/spring]( http://repo.spring.io/release/org/springframework/spring) 下載完成后解壓，目錄如下 ![](https://box.kancloud.cn/19ea5c00ba6380fe87d53afb2b097023_584x136.png) 當中lib包是一些jar包，不是都有用，可以有選擇性的保留或刪除 *** ### IOC簡介--控制反轉 #### 聲明一個簡單的bean 第一個例子：首先設置一個接口Perofrmance表示參賽者。 ``` package com.moonlit.myspring; public interface Performer { void perform() throws PerformanceException; } ``` 創建一個Juggler(雜技師)類繼承Performer表示參賽者是雜技師。 ``` package com.moonlit.myspring; public class Juggler implements Performer { private int beanBags = 3; public Juggler() { } public Juggler(int beanBags) { this.beanBags = beanBags; } public void perform() throws PerformanceException { System.out.println("JUGGLING " + beanBags + " BEANBAGS"); } } ``` 在spring-idol.xml配置文件中定義一個名為duke的bean，他對應Juggler類（把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-3.0.xsd"> <bean id="duke" class="com.moonlit.myspring.Juggler" /> </beans> ``` 測試代碼： ``` package com.moonlit.practice; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.moonlit.myspring.PerformanceException; import com.moonlit.myspring.Performer; public class FirstBean { public static void main(String[] args) throws PerformanceException { ApplicationContext context = new ClassPathXmlApplicationContext("spring-idol.xml"); Performer performer = (Performer) context.getBean("duke"); performer.perform(); } } ``` 運行結果如下： ``` JUGGLING 3 BEANBAGS ``` 理解：首先定義了一個接口Performer，然后寫了一個類Juggler繼承自Peformer,Juggler有一個私有成員變量beanBags,他的默認值是3，然后Juggler實現了Performer的perform方法，方法的輸出帶有beanBags的數量。然后在測試的程序中，通過ApplicationContext類型對象加載了spring-idol.xml文件的內容，而在xml文件中定義了名為"duke"的bean，然后剛好就用到了。然后bean返回的是一個Juggler，所以將 ``` Performer performer = (Performer) context.getBean("duke"); ``` 改成 ``` Juggler performer = (Juggler) context.getBean("duke"); ``` 也是可以的，但是在這里想看的效果是通過application context返回的是不是一個Juggler，因為通過輸出的結果就可以知道了，所以這里用(Performer)，對中輸出的效果顯示bean對應的Performer真的是一個Juggler，這就是通過xml定義一個bean并通過application context獲得這個bean對象的整個過程。 ### 構造器注入之前講到的名為"duke"的bean有一個私有成員變量beanBags代表這個雜技師bean的一次性能夠拋出的最多的數量，Juggler有一個構造函數，構造函數的第一個參數（這里只有一個參數）beanBags是一個整型的值，用于傳遞給Juggler的私有成員變量beanBags。構造器注入的方法是：在bean中添加一個constructor-arg（如果構造函數的參數有兩個，那就添加兩個constructor-arg）。在spring-idol.xml中修改bean "duke"如下： ``` <bean id="duke" class="com.moonlit.myspring.Juggler" > <constructor-arg name="beanBags" value="15" /> </bean> ``` 再次運行FirstBean程序，輸出如下： ``` JUGGLING 15 BEANBAGS ``` 可以看到通過構造器諸如已經把duke的beanBags改為了15。構造函數中的參數可能不是一個基礎類型的變量，而可能是一個變量，這個時候只要把constructor-arg的value改成ref即可，ref對應的值需要被聲明稱一個bean元素。使用一個會唱歌的雜技師PoeticJuggler類來演示，PoeticJuggler繼承自Juggler，它具有一個Poem類型的私有成員變量poem，代表他要朗誦的詩歌。 Poem類： ``` package com.moonlit.myspring; public interface Poem { void recite(); } ``` 定義一首名為Sonnet29的類用于表示名為一首sonnet29的詩：http://shakespeare-online.com/sonnets/29.html Sonnet29實現了Poem接口。 ``` package com.moonlit.myspring; public class Sonnet29 implements Poem { private static String[] LINES = { "When, in disgrace with fortune and men's eyes,", "I all alone beweep my outcast state,", "And trouble deaf heaven with my bootless cries,", "And look upon myself, and curse my fate,", "Wishing me like to one more rich in hope,", "Featur'd like him, like him with friends possess'd,", "Desiring this man's art and that man's scope,", "With what I most enjoy contented least;", "Yet in these thoughts myself almost despising,", "Haply I think on thee, and then my state,", "Like to the lark at break of day arising", "From sullen earth, sings hymns at heaven's gate;", "For thy sweet love remember'd such wealth brings", "That then I scorn to change my state with kings.", }; public Sonnet29() { } public void recite() { for (String line : LINES) System.out.println(line); } } ``` 有了Poem和他的一個實現類Sonnet29之后，開始來寫PoeticJuggler，他繼承自Juggler并且有一個Poem類型私有成員變量poem。 ``` package com.moonlit.myspring; public class PoeticJuggler extends Juggler { private Poem poem; public PoeticJuggler(Poem poem) { super(); this.poem = poem; } public PoeticJuggler(int beanBags, Poem poem) { super(beanBags); this.poem = poem; } public void perform() throws PerformanceException { super.perform(); System.out.println("While reciting..."); poem.recite(); } } ``` 并且，需要在xml文件中聲明Sonnet29和PoeticJuggler類對應的bean。 ``` <bean id="sonnet29" class="com.moonlit.myspring.Sonnet29" /> <bean id="poeticDuke" class="com.moonlit.myspring.PoeticJuggler"> <constructor-arg value="16" /> <constructor-arg ref="sonnet29" /> </bean> ``` 可以看到，"poeticDuke"使用了兩個constructor-arg來聲明參數，第一個參數使用value，第二個參數使用ref，Sonnet29類型的bean--"connet29"。使用測試程序查看效果: ``` package com.moonlit.practice; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.moonlit.myspring.PerformanceException; import com.moonlit.myspring.Performer; public class FirstBean { public static void main(String[] args) throws PerformanceException { ApplicationContext context = new ClassPathXmlApplicationContext( "spring-idol.xml"); Performer performer = (Performer) context.getBean("duke"); performer.perform(); } } ``` 程序輸出如下： ``` JUGGLING 16 BEANBAGS While reciting... When, in disgrace with fortune and men's eyes, I all alone beweep my outcast state, And trouble deaf heaven with my bootless cries, And look upon myself, and curse my fate, Wishing me like to one more rich in hope, Featur'd like him, like him with friends possess'd, Desiring this man's art and that man's scope, With what I most enjoy contented least; Yet in these thoughts myself almost despising, Haply I think on thee, and then my state, Like to the lark at break of day arising From sullen earth, sings hymns at heaven's gate; For thy sweet love remember'd such wealth brings That then I scorn to change my state with kings. ``` 理解：可以通過構造器注入來模擬構造函數傳入的參數，通過constructor-arg value="XX"傳遞一個基本類型的參數XX，通過constructor-arg ref="XX"傳遞一個bean。 ### 注入各種bean屬性這里通過一個MoonlightPoet類來演示了注入Bean屬性property的效果。 ``` package com.moonlit.myspring; import java.util.List; import java.util.Map; import java.util.Map.Entry; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import java.util.Properties; public class MoonlightPoet { private String name; private int age; private Poem poem; private List<String> list; private Map<String, String> map; public void perform() { System.out.println("name : " + name); System.out.println("age : " + age); poem.recite(); for (String val : list) System.out.println("in list : " + val); for (Entry<String, String> entry : map.entrySet()) System.out.println("in map : " + entry.getKey() + " -- " + entry.getValue()); } public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext( "spring-idol.xml"); MoonlightPoet moonlightPoet = (MoonlightPoet) context.getBean("moonlightPoet"); moonlightPoet.perform(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Poem getPoem() { return poem; } public void setPoem(Poem poem) { this.poem = poem; } public List<String> getList() { return list; } public void setList(List<String> list) { this.list = list; } public Map<String, String> getMap() { return map; } public void setMap(Map<String, String> map) { this.map = map; } } ``` 該bean在xml文件中定義如下： ``` <bean id="moonlightPoet" class="com.moonlit.myspring.MoonlightPoet"> <property name="name" value="moonlit" /> <property name="age" value="22" /> <property name="poem" ref="sonnet29" /> <property name="list"> <list> <value>hello</value> <value>world</value>  </list> </property> <property name="map"> <map> <entry key="key1" value="value1" /> <entry key="key2" value="value2" /> <entry key="key3" value="value3" /> </map> </property> </bean> ``` 輸出結果： ``` name : moonlit age : 22 When, in disgrace with fortune and men's eyes, I all alone beweep my outcast state, And trouble deaf heaven with my bootless cries, And look upon myself, and curse my fate, Wishing me like to one more rich in hope, Featur'd like him, like him with friends possess'd, Desiring this man's art and that man's scope, With what I most enjoy contented least; Yet in these thoughts myself almost despising, Haply I think on thee, and then my state, Like to the lark at break of day arising From sullen earth, sings hymns at heaven's gate; For thy sweet love remember'd such wealth brings That then I scorn to change my state with kings. in list : hello in list : world in map : key1 -- value1 in map : key2 -- value2 in map : key3 -- value3 ``` 理解：注入簡單值： <property name="XX" value="YY" /> 其中XX是變量名，YY是值。引用其他Bean： <property name="XX" ref="YY"> 其中XX是變量名，YY是引用的bean的id。裝配List： <property name="XX"> <value>YY</value> 或者 <ref bean="ZZ"> </property> 其中XX是變量名，YY是值，ZZ是引用的bean。裝配Map： <map> <entry key="XX" value="YY" /> 或者 <entry key="XX" value-ref="YY" /> 或者 <entry key-ref="XX" value="YY" /> 或者 <entry key-ref="XX" value-ref="YY" /> </map> 因為map的key和value可以對應一個基礎類型的值，也可以對應一個bean，所以key,value對應值，key-ref,value-ref對應bean。使用Spring的命名空間p裝配屬性可以在beans中添加 ``` xmlns:p="http:www.springframework.org/schema/beans" ``` 來使用p:作為<bean>元素所有屬性的前綴來裝配Bean的屬性。用法如下： ``` <bean id="kenny" class="XX" p:song = "Jingle Bells" p:instrument-ref = "saxphone" /> ``` -ref后綴作為一個標識來告知Spring應該裝配一個引用而不是字面值。 ### 自動裝配bean屬性 Spring提供了四種類型的自動裝配策略： byName – 把與Bean的屬性具有相同名字(或者ID)的其他Bean自動裝配到Bean的對應屬性中。 byType – 把與Bean的屬性具有相同類型的其他Bean自動裝配到Bean的對應屬性中。 constructor – 把與Bean的構造器入參具有相同類型的其他Bean自動裝配到Bean的對應屬性中。 autodetect – 首先使用costructor進行自動裝配。如果失敗，再嘗試使用byType進行自動裝配。這里以關羽和青龍偃月刀為例：首先定義一個武器接口Weapon： ``` package com.moonlit.myspring; public interface Weapon { public void attack(); } ``` 然后定義一個Weapon接口的實現Falchion類: ``` package com.moonlit.myspring; public class Falchion implements Weapon { public void attack() { System.out.println("falcon is attacking!"); } } ``` 定義一個英雄接口Hero： ``` package com.moonlit.myspring; public interface Hero { public void perform(); } ``` 然后定義一個Hero接口的實現Guanyu類（代表關羽）： ``` package com.moonlit.myspring; public class GuanYu implements Hero { private Weapon weapon; public void perform() { System.out.println("GuanYu pick up his weapon."); weapon.attack(); } public Weapon getWeapon() { return weapon; } public void setWeapon(Weapon weapon) { this.weapon = weapon; } } ``` 在不涉及自動裝配的情況下，想要通過Spring的DI將Fachion類對象注入到Guanyu類的weapon屬性中，可以新建一個xml文件（這里取名為spring-idol.xml）并在里面填寫： spring-idol.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-3.0.xsd"> <bean id="falchion" class="com.moonlit.myspring.Falchion" /> <bean id="guanyu" class="com.moonlit.myspring.GuanYu"> <property name="weapon" ref="falchion" /> </bean> </beans> ``` 其中最主要的內容就是兩個bean的聲明部分： ``` <bean id="falchion" class="com.moonlit.myspring.Falchion" /> <bean id="guanyu" class="com.moonlit.myspring.GuanYu"> <property name="weapon" ref="falchion" /> </bean> ``` 第一個bean標簽定義了一個Falchion類型的bean，第二個bean標簽中將第一個bean作為weapon的值裝配到了weapon屬性中。然后可以寫一個測試程序來查看效果： ``` package com.moonlit.practice; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.moonlit.myspring.Hero; public class AutowirePractice { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("spring-idol.xml"); Hero guanyu = (Hero) context.getBean("guanyu"); guanyu.perform(); } } ``` 輸出結果如下： ``` GuanYu pick up his weapon. falcon is attacking! ``` 到目前為止還沒有涉及到自動裝配的內容，接下來開始講述自動裝配的內容。 #### byName自動裝配改變spring-idol.xml中bean聲明內容的形式如下： ``` <bean id="weapon" class="com.moonlit.myspring.Falchion" /> <bean id="guanyu" class="com.moonlit.myspring.GuanYu" autowire="byName" /> ``` 得到一樣的結果。將Falchion類的id去了一個和Guanyu類的屬性weapon一樣的名字，并且在guanyu bean中添加了autowire="byName"用于指明裝配類型是byName自動裝配。這個時候guanyu bean就是在上下文中找名為weapon的bean裝配到他自己的weapon屬性中。 #### byType自動裝配改變spring-idol.xml中bean聲明內容的形式如下： ``` <bean id="falchion" class="com.moonlit.myspring.Falchion" /> <bean id="guanyu" class="com.moonlit.myspring.GuanYu" autowire="byType" /> ``` 得到一樣的結果。這里已經不用關注Falchion類對應的bean的id是什么了，因為已經定義guanyu bean的autowire屬性為"byType"。這個時候guanyu bean會在上下文中尋找和weapon具有相同類型的類對應的bean。因為Guanyu類的weapon實現Weapon借口，整個上下文中目前只有一個Weapon接口的實現Falchion類，所以以"byType"類型就檢測到了falchion bean并將其注入到了guanyu bean的weapon屬性中。但是也會出現一種情況就是檢測的時候可能會出現多個相同type的bean，這個時候就不知道要裝配那個了。比如，在新建一個實現Weapon接口的方天畫戟類HalBerd： ``` package com.moonlit.myspring; public class Halberd implements Weapon { public void attack() { System.out.println("halberd is attacking!!!"); } } ``` 并且在xml文件中聲明一個新的halberd bean： ``` <bean id="halberd" class="com.moonlit.myspring.Halberd" /> ``` 在這種情況下就會出錯，因為有兩個bean滿足byType的結果。這個時候有兩種解決辦法：第一種方法是將其中一個bean的primary屬性設為false，比如：將方天畫戟falchion bean的primary屬性設為true，以防冠以使用方天畫戟（很好奇呂布死了之后，赤兔馬歸關羽了，方天畫戟去哪里了）： ``` <bean id="falchion" class="com.moonlit.myspring.Falchion" /> <bean id="halberd" class="com.moonlit.myspring.Halberd" primary="true" /> <bean id="guanyu" class="com.moonlit.myspring.GuanYu" autowire="byType" /> ``` 輸出結果如下： ``` GuanYu pick up his weapon. halberd is attacking!!! ``` 從輸出結果中可以看到，關羽沒有使用青龍偃月刀，而是使用方天畫戟進行攻擊了。 primary的默認屬性是false。第二種方法是設置其中一個bean的autowire-candidate屬性為false，比如：將方天畫戟的autowire-candidate屬性設為false： ``` <bean id="falchion" class="com.moonlit.myspring.Falchion" /> <bean id="halberd" class="com.moonlit.myspring.Halberd" primary="true" autowire-candidate="false" /> <bean id="guanyu" class="com.moonlit.myspring.GuanYu" autowire="byType" /> ``` 這個時候測試程序的輸出如下： ``` GuanYu pick up his weapon. falcon is attacking! ``` 可以看到這個時候關羽又重拾了青龍偃月刀。可以看到，當halberd bean的autowire-candidate屬性設為false時，他將不會作為自動裝配的競選bean之一，這個時候雖然halberd的primary屬性為true，但是halberd bean沒有參與自動裝配的競選，所以自動裝配到了falchion。這種感覺就好像：“隔壁村李小花覬覦已久，但是一個要成為海賊王的男人，于是拒絕了她……最終她嫁給了隔壁老王，過上了幸福的生活”。 ### 使用注解裝配bean 使用@Autowired注解從Spring2.5開始，最有趣的一種裝配Spring Bean的方式是使用注解自動裝配Bean的屬性。 Spring默認禁用注解裝配，最簡單的啟用方式是使用Spring的context命名空間配置中的<context:annotation-config>元素，如下所示： ``` <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"> <context:annotation-config />  </beans> ``` 繼續上一節的例子，在xml文件中定義兩個bean：falchion bean和guanyu bean，為了實現@Autowired自動裝配，在GuanYu類中的setWeapon()方法前添加了@Autowired注解，如下： GuanYu.java: ``` package com.moonlit.myspring; import org.springframework.beans.factory.annotation.Autowired; public class GuanYu implements Hero { @Autowired private Weapon weapon; public void perform() { System.out.println("Guan Yu pick up his weapon."); weapon.attack(); } public Weapon getWeapon() { return weapon; } public void setWeapon(Weapon weapon) { this.weapon = weapon; } } ``` 通過基于注解的方式，可以不用在xml文件中為guanyu bean添加autowire屬性了。 spring-idol內部的代碼： ``` <context:annotation-config /> <bean id="falchion" class="com.moonlit.myspring.Falchion" /> <bean id="guanyu" class="com.moonlit.myspring.GuanYu" /> ``` @Autowired注解存在一個限制：匹配多個Bean 限定歧義性的依賴有可能存在多個bean滿足裝配條件，比如，這里，falchion bean和halberd bean都滿足裝配到guanyu bean的weapon屬性中的條件。此時如果只是用@Autowired注解的話就會出問題，才@Autowired注解下添加@Qualifier注解如下： ``` @Autowired @Qualifier("falchion") private Weapon weapon; ``` 就會將falchion bean裝入到weapon中。如上所示，@Qualifier注解將嘗試注入ID為falchion的Bean。除了通過Bean的ID來限定，也可以給Bean添加一個qualifier屬性，通過這個qualifier屬性來獲得限定，如：給halberd bean添加一個qualifier，值為"weaponOfGuanYu"： ``` <bean id="halberd" class="com.moonlit.myspring.Halberd"> <qualifier value="weaponOfGuanYu" /> </bean> ``` 然后對GuanYu類weapon類的注解如下： ``` @Autowired @Qualifier("weaponOfGuanYu") private Weapon weapon; ``` 輸出如下： ``` Guan Yu pick up his weapon. halberd is attacking!!! ``` 可以看出，@qualifier降低了@Autowired的匹配范圍，最終篩選得到了halberd bean裝入weapon屬性。這里的<qualifier>元素限定了方天畫戟（halberd）Bean是關羽使用的武器（weaponOgGuanYu）。除了可以在XML中指定qualifier，還可以使用Qualifier類來標注Halberd類： ``` package com.moonlit.myspring; import org.springframework.beans.factory.annotation.Qualifier; @Qualifier("weaponOfGuanYu") public class Halberd implements Weapon { public void attack() { System.out.println("halberd is attacking!!!"); } } ``` 程序運行將得到相同的結果。即使<context:annotation-config>有助于完全消除Spring配置文件中的元素，但是還是不能完全消除，仍然需要使用<bean>元素顯示定義Bean。因此<context:component-scan>元素出現了，它除了完成<context:annotation-config>一樣的工作，還允許Spring自動檢測Bean和定義Bean。這就意味著不使用<bean>元素，Spring應用中的大多數（或者所有）Bean都能夠自動實現定義和裝配。 ### 自動檢測為了配置Spring自動檢測，需要使用<context:component-scan>元素來代替<context:annotation-config>元素： ``` <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <context:component-scan base-package="com.moonlit.myspring"> </context:component-scan> </beans> ``` <context:component-scan>元素會掃描指定的包以及所有子包，并查找出能夠自動注冊為Spring Bean的類。base-package屬性標示了<context:component-scan>元素所掃描的包。為自動檢測標注Bean 默認情況下，<context:component-scan>查找使用構造型（stereotype）注解所標注的類，這些特殊的注解如下：類型說明 @component 通用的構造型注解，標示該類為Spring 組件。 @Controller 標識將該類定義為Spring MVC controller。 @Repository 標識將該類定義為數據倉庫（例如：Dao層）。 @Service 標識將該類定義為服務（例如：Service層）。 ``` @component（"guanyu"） ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml"); Hero hero = (Hero)applicationContext.getBean("guanyu"); hero.perform(); ```

Spring入門