spring如何推斷構造方法

❶ java的spring框架，有些類中沒有無參構造放方法，但是spring還是可以構造出該實例，它是怎麼做到的

監聽器:org.springframework.web.context.ContextLoaderListener 在伺服器啟動時會載入這個監聽器,然後由這個監聽器初始化spring容器

❷ spring 調用實體類 有參構造方法

面試沒有定論，面試官也許自己都沒有準備完全的問題和答案，但是，如果是應聘初級開發的話，基礎知識肯定是少不了的，摘個經典的面試32問吧~

=================
JAVA程序員面試32問

第一，談談final, finally, finalize的區別。
第二，Anonymous Inner Class (匿名內部類) 是否可以extends(繼承)其它類，是否可以implements(實現)interface(介面)?

第三，Static Nested Class 和 Inner Class的不同，說得越多越好(面試題有的很籠統)。

第四，&和&&的區別。

第五，HashMap和Hashtable的區別。

第六，Collection 和 Collections的區別。

第七，什麼時候用assert。

第八，GC是什麼? 為什麼要有GC?

第九，String s = new String("xyz");創建了幾個String Object?

第十，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

第十一，short s1 = 1; s1 = s1 + 1;有什麼錯? short s1 = 1; s1 += 1;有什麼錯?

第十二，sleep() 和 wait() 有什麼區別?

第十三，Java有沒有goto?

第十四，數組有沒有length()這個方法? String有沒有length()這個方法?

第十五，Overload和Override的區別。Overloaded的方法是否可以改變返回值的類型?

第十六，Set里的元素是不能重復的，那麼用什麼方法來區分重復與否呢? 是用==還是equals()? 它們有何區別?

第十七，給我一個你最常見到的runtime exception。

第十八，error和exception有什麼區別?

第十九，List, Set, Map是否繼承自Collection介面?

第二十，abstract class和interface有什麼區別?

第二十一，abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized?

第二十二，介面是否可繼承介面? 抽象類是否可實現(implements)介面? 抽象類是否可繼承實體類(concrete class)?

第二十三，啟動一個線程是用run()還是start()?

第二十四，構造器Constructor是否可被override?

第二十五，是否可以繼承String類?

第二十六，當一個線程進入一個對象的一個synchronized方法後，其它線程是否可進入此對象的其它方法?

第二十七，try 里的code會不會被執行，什麼時候被執行，在return前還是後?

第二十八，編程題: 用最有效率的方法算出2乘以8等於幾?

第二十九，兩個對象值相同(x.equals(y) == true)，但卻可有不同的hash code，這句話對不對?

第三十，當一個對象被當作參數傳遞到一個方法後，此方法可改變這個對象的屬性，並可返回變化後的結果，那麼這里到底是值傳遞還是引用傳遞?

第三十一，swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?

第三十二，編程題: 寫一個Singleton出來。

以下是答案

第一，談談final, finally, finalize的區別。
final—修飾符（關鍵字）如果一個類被聲明為final，意味著它不能再派生出新的子類，不能作為父類被繼承。因此一個類不能既被聲明為 abstract的，又被聲明為final的。將變數或方法聲明為final，可以保證它們在使用中不被改變。被聲明為final的變數必須在聲明時給定初值，而在以後的引用中只能讀取，不可修改。被聲明為final的方法也同樣只能使用，不能重載
finally—再異常處理時提供 finally 塊來執行任何清除操作。如果拋出一個異常，那麼相匹配的 catch 子句就會執行，然後控制就會進入 finally 塊（如果有的話）。
finalize—方法名。Java 技術允許使用 finalize() 方法在垃圾收集器將對象從內存中清除出去之前做必要的清理工作。這個方法是由垃圾收集器在確定這個對象沒有被引用時對這個對象調用的。它是在 Object 類中定義的，因此所有的類都繼承了它。子類覆蓋 finalize() 方法以整理系統資源或者執行其他清理工作。finalize() 方法是在垃圾收集器刪除對象之前對這個對象調用的。

第二，Anonymous Inner Class (匿名內部類) 是否可以extends(繼承)其它類，是否可以implements(實現)interface(介面)?
匿名的內部類是沒有名字的內部類。不能extends(繼承) 其它類，但一個內部類可以作為一個介面，由另一個內部類實現。

第三，Static Nested Class 和 Inner Class的不同，說得越多越好(面試題有的很籠統)。
Nested Class （一般是C++的說法），Inner Class (一般是JAVA的說法)。Java內部類與C++嵌套類最大的不同就在於是否有指向外部的引用上。具體可見http: //
註： 靜態內部類（Inner Class）意味著1創建一個static內部類的對象，不需要一個外部類對象，2不能從一個static內部類的一個對象訪問一個外部類對象

第四，&和&&的區別。
&是位運算符。&&是布爾邏輯運算符。

第五，HashMap和Hashtable的區別。
都屬於Map介面的類，實現了將惟一鍵映射到特定的值上。
HashMap 類沒有分類或者排序。它允許一個 null 鍵和多個 null 值。
Hashtable 類似於 HashMap，但是不允許 null 鍵和 null 值。它也比 HashMap 慢，因為它是同步的。

第六，Collection 和 Collections的區別。
Collections是個java.util下的類，它包含有各種有關集合操作的靜態方法。
Collection是個java.util下的介面，它是各種集合結構的父介面。

第七，什麼時候用assert。
斷言是一個包含布爾表達式的語句，在執行這個語句時假定該表達式為 true。如果表達式計算為 false，那麼系統會報告一個 AssertionError。它用於調試目的：
assert(a > 0); // throws an AssertionError if a <= 0
斷言可以有兩種形式：
assert Expression1 ;
assert Expression1 : Expression2 ;
Expression1 應該總是產生一個布爾值。
Expression2 可以是得出一個值的任意表達式。這個值用於生成顯示更多調試信息的 String 消息。
斷言在默認情況下是禁用的。要在編譯時啟用斷言，需要使用 source 1.4 標記：
javac -source 1.4 Test.java
要在運行時啟用斷言，可使用 -enableassertions 或者 -ea 標記。
要在運行時選擇禁用斷言，可使用 -da 或者 -disableassertions 標記。
要系統類中啟用斷言，可使用 -esa 或者 -dsa 標記。還可以在包的基礎上啟用或者禁用斷言。
可以在預計正常情況下不會到達的任何位置上放置斷言。斷言可以用於驗證傳遞給私有方法的參數。不過，斷言不應該用於驗證傳遞給公有方法的參數，因為不管是否啟用了斷言，公有方法都必須檢查其參數。不過，既可以在公有方法中，也可以在非公有方法中利用斷言測試後置條件。另外，斷言不應該以任何方式改變程序的狀態。

第八，GC是什麼? 為什麼要有GC? (基礎)。
GC是垃圾收集器。Java 程序員不用擔心內存管理，因為垃圾收集器會自動進行管理。要請求垃圾收集，可以調用下面的方法之一：
System.gc()
Runtime.getRuntime().gc()

第九，String s = new String("xyz");創建了幾個String Object?
兩個對象，一個是「xyx」,一個是指向「xyx」的引用對象s。

第十，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?
Math.round(11.5)返回（long）12，Math.round(-11.5)返回（long）-11;

第十一，short s1 = 1; s1 = s1 + 1;有什麼錯? short s1 = 1; s1 += 1;有什麼錯?
short s1 = 1; s1 = s1 + 1;有錯，s1是short型，s1+1是int型,不能顯式轉化為short型。可修改為s1 =(short)(s1 + 1) 。short s1 = 1; s1 += 1正確。

第十二，sleep() 和 wait() 有什麼區別? 搞線程的最愛
sleep()方法是使線程停止一段時間的方法。在sleep 時間間隔期滿後，線程不一定立即恢復執行。這是因為在那個時刻，其它線程可能正在運行而且沒有被調度為放棄執行，除非(a)「醒來」的線程具有更高的優先順序
(b)正在運行的線程因為其它原因而阻塞。
wait()是線程交互時，如果線程對一個同步對象x 發出一個wait()調用，該線程會暫停執行，被調對象進入等待狀態，直到被喚醒或等待時間到。

第十三，Java有沒有goto?
Goto—java中的保留字，現在沒有在java中使用。

第十四，數組有沒有length()這個方法? String有沒有length()這個方法？
數組沒有length()這個方法，有length的屬性。
String有有length()這個方法。

第十五，Overload和Override的區別。Overloaded的方法是否可以改變返回值的類型?
方法的重寫Overriding和重載Overloading是Java多態性的不同表現。重寫Overriding是父類與子類之間多態性的一種表現，重載Overloading是一個類中多態性的一種表現。如果在子類中定義某方法與其父類有相同的名稱和參數，我們說該方法被重寫 (Overriding)。子類的對象使用這個方法時，將調用子類中的定義，對它而言，父類中的定義如同被「屏蔽」了。如果在一個類中定義了多個同名的方法，它們或有不同的參數個數或有不同的參數類型，則稱為方法的重載(Overloading)。Overloaded的方法是可以改變返回值的類型。

第十六，Set里的元素是不能重復的，那麼用什麼方法來區分重復與否呢? 是用==還是equals()? 它們有何區別?
Set里的元素是不能重復的，那麼用iterator()方法來區分重復與否。equals()是判讀兩個Set是否相等。
equals()和==方法決定引用值是否指向同一對象equals()在類中被覆蓋，為的是當兩個分離的對象的內容和類型相配的話，返回真值。

第十七，給我一個你最常見到的runtime exception。
ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException, CannotRedoException, CannotUndoException, ClassCastException, CMMException, , DOMException, EmptyStackException, IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException, IllegalStateException,
ImagingOpException, IndexOutOfBoundsException, MissingResourceException, NegativeArraySizeException, NoSuchElementException, NullPointerException, ProfileDataException, ProviderException, RasterFormatException, SecurityException, SystemException, UndeclaredThrowableException, UnmodifiableSetException, UnsupportedOperationException

第十八，error和exception有什麼區別?
error 表示恢復不是不可能但很困難的情況下的一種嚴重問題。比如說內存溢出。不可能指望程序能處理這樣的情況。
exception 表示一種設計或實現問題。也就是說，它表示如果程序運行正常，從不會發生的情況。

第十九，List, Set, Map是否繼承自Collection介面?
List，Set是

Map不是

第二十，abstract class和interface有什麼區別?
聲明方法的存在而不去實現它的類被叫做抽象類（abstract class），它用於要創建一個體現某些基本行為的類，並為該類聲明方法，但不能在該類中實現該類的情況。不能創建abstract 類的實例。然而可以創建一個變數，其類型是一個抽象類，並讓它指向具體子類的一個實例。不能有抽象構造函數或抽象靜態方法。Abstract 類的子類為它們父類中的所有抽象方法提供實現，否則它們也是抽象類為。取而代之，在子類中實現該方法。知道其行為的其它類可以在類中實現這些方法。
介面（interface）是抽象類的變體。在介面中，所有方法都是抽象的。多繼承性可通過實現這樣的介面而獲得。介面中的所有方法都是抽象的，沒有一個有程序體。介面只可以定義static final成員變數。介面的實現與子類相似，除了該實現類不能從介面定義中繼承行為。當類實現特殊介面時，它定義（即將程序體給予）所有這種介面的方法。然後，它可以在實現了該介面的類的任何對象上調用介面的方法。由於有抽象類，它允許使用介面名作為引用變數的類型。通常的動態聯編將生效。引用可以轉換到介面類型或從介面類型轉換，instanceof 運算符可以用來決定某對象的類是否實現了介面。

第二十一，abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized?
都不能

第二十二，介面是否可繼承介面? 抽象類是否可實現(implements)介面? 抽象類是否可繼承實體類(concrete class)?
介面可以繼承介面。抽象類可以實現(implements)介面，抽象類是否可繼承實體類，但前提是實體類必須有明確的構造函數。

第二十三，啟動一個線程是用run()還是start()?
啟動一個線程是調用start()方法，使線程所代表的虛擬處理機處於可運行狀態，這意味著它可以由JVM調度並執行。這並不意味著線程就會立即運行。run()方法可以產生必須退出的標志來停止一個線程。

第二十四，構造器Constructor是否可被override?
構造器Constructor不能被繼承，因此不能重寫Overriding，但可以被重載Overloading。

第二十五，是否可以繼承String類?
String類是final類故不可以繼承。

第二十六，當一個線程進入一個對象的一個synchronized方法後，其它線程是否可進入此對象的其它方法?
不能，一個對象的一個synchronized方法只能由一個線程訪問。

第二十七，try 里的code會不會被執行，什麼時候被執行，在return前還是後?
會執行，在return前執行。

第二十八，編程題: 用最有效率的方法算出2乘以8等於幾?
有C背景的程序員特別喜歡問這種問題。

2 << 3

第二十九，兩個對象值相同(x.equals(y) == true)，但卻可有不同的hash code，這句話對不對?
不對，有相同的hash code。

第三十，當一個對象被當作參數傳遞到一個方法後，此方法可改變這個對象的屬性，並可返回變化後的結果，那麼這里到底是值傳遞還是引用傳遞?
是值傳遞。Java 編程語言只由值傳遞參數。當一個對象實例作為一個參數被傳遞到方法中時，參數的值就是對該對象的引用。對象的內容可以在被調用的方法中改變，但對象的引用是永遠不會改變的。

第三十一，swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?
switch（expr1）中，expr1是一個整數表達式。因此傳遞給 switch 和 case 語句的參數應該是 int、 short、 char 或者 byte。long,string 都不能作用於swtich。

第三十二，編程題: 寫一個Singleton出來。
Singleton模式主要作用是保證在Java應用程序中，一個類Class只有一個實例存在。
一般Singleton模式通常有幾種種形式:
第一種形式: 定義一個類，它的構造函數為private的，它有一個static的private的該類變數，在類初始化時實例話，通過一個public的getInstance方法獲取對它的引用,繼而調用其中的方法。
public class Singleton {
private Singleton(){}
//在自己內部定義自己一個實例，是不是很奇怪？
//注意這是private 只供內部調用
private static Singleton instance = new Singleton();
//這里提供了一個供外部訪問本class的靜態方法，可以直接訪問
public static Singleton getInstance() {
return instance;
}
}
第二種形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//這個方法比上面有所改進，不用每次都進行生成對象，只是第一次
//使用時生成實例，提高了效率！
if (instance==null)
instance＝new Singleton();
return instance; }
}
其他形式:
定義一個類，它的構造函數為private的，所有方法為static的。
一般認為第一種形式要更加安全些
第三十三 Hashtable和HashMap
Hashtable繼承自Dictionary類，而HashMap是Java1.2引進的Map interface的一個實現

HashMap允許將null作為一個entry的key或者value，而Hashtable不允許

還有就是，HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因為contains方法容易讓人引起誤解。

最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在
多個線程訪問Hashtable時，不需要自己為它的方法實現同步，而HashMap
就必須為之提供外同步。

Hashtable和HashMap採用的hash/rehash演算法都大概一樣，所以性能不會有很大的差異

❸ "spring"三種實現機制，每種具體說明實現的原理

IoC，直觀地講，就是容器控製程序之間的關系，而非傳統實現中，由程序代碼直接操控。這也就是所謂「控制反轉」的概念所在。IoC還有另外一個名字——「依賴注入（Dependency Injection）」

IoC的3種依賴注入類型如下

第1種是通過介面注射，這種方式要求我們的類必須實現容器給定的一個介面，然後容器會利用這個介面給我們這個類注射它所依賴的類。

第2種是通過setter方法注射，這種方式也是Spring推薦的方式。

第3種是通過構造方法注射類，這種方式Spring同樣給予了實現，它和通過setter方式一樣，都在類里無任何侵入性，但是，不是沒有侵入性，只是把侵入性轉移了，顯然第1種方式要求實現特定的介面，侵入性非常強，不方便以後移植。

❹ 關於Spring構造方法注入的問題

<bean id="memberBean" class="MemberBean">
<constructor-arg name="name" value="AAA" />
<constructor-arg name="salary" value="3500" />

<constructor-arg name="dept" ref="dept1"/>

<constructor-arg name="sex" value="男" />
</bean>

如上例，請使用參數的名字進行匹配就行了。

❺ 請你談談對spring的理解

1.解釋spring的ioc? 幾種注入依賴的方式？spring的優點？

IOC你就認為他是一個生產和管理bean的容器就行了，原來需要在調用類中new的東西，現在都是有這個IOC容器進行產生，同

時，要是產生的是單例的bean，他還可以給管理bean的生命周期！

spring的IOC有三種注入方式 ：

第一是根據屬性注入 也叫set方法注入；
第二種是根據構造方法進行注入；

第三種是根據註解進行注入，這種方式我認為比較好，方便，要是bean多的話，使用前兩種方式會使得配置文件過於臃腫。

Spring的優點：主要是根據它的IOC和AOP體現的。我感覺他就是把我們以前用到的工廠模式和代理模式進行了一個封裝。
IOC主要是解決了代碼的耦合性問題，而AOP是面向切面編程的最好解釋！

2.解釋Spring中IOC, DI, AOP
ioc就是控制翻轉或是依賴注入。通俗的講就是如果在什麼地方需要一個對象，你自己不用去通過new 生成你需要的對象，

而是通過spring的bean工廠為你長生這樣一個對象。

aop就是面向切面的編程。比如說你每做一次對資料庫操作，都要生成一句日誌。如果，你對資料庫的操作有很多類，
那你每一類中都要寫關於日誌的方法。但是如果你用aop，那麼你可以寫一個方法，在這個方法中有關於資料庫操作的方法，
每一次調用這個方法的時候，就加上生成日誌的操作。

3.spring的ioc/aop/代理
ioc是控制反轉，是spring的核心思想。通過面向介面編程來實現對業務組件的動態依賴。 aop是面向

切面編程，它並不是只在spring或者java中才有的，它和面向對象編程（oop）是相對而言的另一種編程思想。

spring在實現aop編程時利用的是java的代理機制。 個人覺得java代理機制真的是很神奇。核心內容並不多

4.spring的ioc是解耦,aop是干什麼的
AOP面向切面編程 將程序中的交叉業務邏輯（比如安全，日誌，事務等），封裝成一個切面，然後注入到目標對象（具體業務邏輯）中去。
比如： 很多方法可能會拋異常，你要記錄這個異常到日誌中去，可以寫個攔截器類，在這個類中記錄日誌，
在spring.xml中配置一個對這些要記錄日誌的方法的aop攔截器 在這個方法執行後調用這個攔截器，記錄日誌。
這樣就不用每次拋異常都要手動記錄日誌。 spring的事務管理用到的就是aop 這樣也可以提高程序的內聚性。

5.講解一下Java中Spring中IOC和AOP
IoC：說直白點，就是通過配置文件（XML或.properties）指定需要實例化的JAVA類（類名的完整字元串），
包括該JAVA類的一組初始化值，然後我們在代碼中載入該配置文件，然後通過 .getBean() 函數就可以得到一個該JAVA類的對象，
並且該對象已經根據配置文件中指定的屬性值進行了初始化。

AOP：這個比IoC更簡單，直白點說就是實現調用某個方法之前或/和之後，自動執行一系列自定義的語句

6.簡述Spring框架中IOC和AOP
IOC：控制反轉，是一種設計模式。一層含義是控制權的轉移：由傳統的在程序中控制依賴轉移到由容器來控制；
第二層是依賴注入：將相互依賴的對象分離，在spring配置文件中描述他們的依賴關系。他們的依賴關系只在使用的時候才建立。

AOP：面向切面，是一種編程思想，OOP的延續。將系統中非核心的業務提取出來，進行單獨處理。比如事務、日誌和安全等。
Spring 的AOP和IOC都是為了解決系統代碼耦合度過高的問題。使代碼重用度高、易於維護。
不過AOP和IOC並不是spring中特有的，只是spring把他們應用的更靈活方便 。

❻ spring註解怎麼實現的

【Spring如何使用註解機制完成自動裝配】
Java實例構造時會調用默認父類無參構造方法，Spring正是利用了這一點，讓"操作元素的代碼"得以執行。

【兩種處理策略】
(1)類級別的註解：如@Component、@Repository、@Controller、@Service以及JavaEE6的@ManagedBean和@Named註解，都是添加在類上面的類級別註解。
Spring容器根據註解的過濾規則掃描讀取註解Bean定義類，並將其注冊到Spring IoC容器中。

(2)類內部的註解：如@Autowire、@Value、@Resource以及EJB和WebService相關的註解等，都是添加在類內部的欄位或者方法上的類內部註解。
SpringIoC容器通過Bean後置註解處理器解析Bean內部的註解。

Spring實現@Autowire解析和注入的核心的類是通過來實現的。
我們可以通過其方法列表看出，其中對欄位的注入，對屬性的注入，還有選擇相應的構造方法來注入。
1，從構造方法的緩存中查詢其構造方法
2，若緩存中不存在，則根據反射獲取所有構造方法
3，遍歷所有構造方法，查詢器是否含有@Autowired屬性
4，判斷Autowired註解中指定了required屬性 （required屬性就是判斷是否強依依賴）若存在required就使用默認構造方法。
5，返回指定的構造方法

注入的時候則是通過inject方法來實現。

================================================================================================================================
Spring對註解的支持主要都是通過反射來獲取相應的註解，來做相應的處理，我們的工程中大部分都是使用@Service 和@Autowired來使用，其實我們還可以使用到其他的註解來加快我們的開發，滿足我們的多樣性需求。

annotation是挺簡單的東西.其實就是個聲明。然後通過反射去取那些聲明了值。
autowire其實也是這個意思。通過反射去看你autowire的方式，通過定義的方式，去給你聲明的變數賦值。

通過java的反射機制相關的API來訪問Annotation信息。
相關類（框架或工具中的類）根據這些信息來決定如何使用該程序元素或改變它們的行為。
Java語言解釋器在工作時會忽略這些Annotation，因此在JVM中這些Annotation是「不起作用」的，只能通過配套的工具才能對這些Annotation類型的信息進行訪問和處理。
註解本身不做任何事情，只是像xml文件一樣起到配置作用。
註解代表的是某種業務意義，註解背後處理器的工作原理如上源碼實現：
——首先解析所有屬性，判斷屬性上是否存在指定註解。
——如果存在則根據搜索規則取得bean，然後利用反射原理注入。
——如果標注在欄位上面，也可以通過欄位的反射技術取得註解，根據搜索規則取得bean，然後利用反射技術注入。

================================================================================================================================
Spring 3.0 新增了另外兩個實現類： 和 。從名字便可以看出，它們是為註解而生，直接依賴於註解作為容器配置信息來源的 IoC 容器初始化類。由於 是 的 web 版本，其用法與後者相比幾乎沒有什麼差別，因此本文將以 為例進行講解。

我們需要在用於指定配置信息的類上加上 @Configuration 註解，以明確指出該類是 Bean 配置的信息源。並且 Spring 對標注 Configuration 的類有如下要求：
配置類不能是 final 的；
配置類不能是本地化的，亦即不能將配置類定義在其他類的方法內部；
配置類必須有一個無參構造函數。

將配置類中標注了 @Bean 的方法的返回值識別為 Spring Bean，並注冊到容器中，受 IoC 容器管理。@Bean 的作用等價於 XML 配置中的 <bean/> 標簽。

在一般的項目中，為了結構清晰，通常會根據軟體的模塊或者結構定義多個 XML 配置文件，然後再定義一個入口的配置文件，該文件使用 <import/> 將其他的配置文件組織起來。最後只需將該文件傳給 的構造函數即可。

針對基於註解的配置，Spring 也提供了類似的功能，只需定義一個入口配置類，並在該類上使用 @Import 註解引入其他的配置類即可，最後只需要將該入口類傳遞給 。
@Configuration
@Import({BookStoreServiceConfig.class,BookStoreDaoConfig.class})
public class BookStoreConfig{ … }

================================================================================================================================
http://zxf-noimp.iteye.com/blog/1071765

【定義註解】
// 在運行時執行
@Retention(RetentionPolicy.RUNTIME)
// 註解適用地方(欄位和方法)
@Target({ ElementType.FIELD, ElementType.METHOD })
public @interface ZxfResource {

//註解的name屬性
public String name() default "";
}

【註解處理器】
public (String fileName) {
//讀取配置文件中管理的bean
this.readXML(fileName);
//實例化bean
this.instancesBean();
//註解處理器
this.annotationInject();
}

❼ Spring的構造方法注入

分別給構造方法的參數賦值，例如構造函數有三個參數：

❽ Spring只執行無參構造方法嗎

系統不會在調用有參構造方法的時候自動調用無參構造方法。需要自己手工實現 1、在有參構造函數中調用無參構造函數 例如： public class TA{ public TA(){//定義無參構造函數 }

❾ Spring是怎麼用的

spring是J2EE應用程序框架，是輕量級的IoC和AOP的容器框架，主要是針對javaBean的生命周期進行管理的輕量級容器。Spring包含7大模塊，每個模塊可以單獨使用、也可以結合起來使用；但是在實際開發過程中，一般需要結合Struts、Hibernate來使用。

Spring 框架中核心組件有三個：Core、Context 和 Beans。其中最核心的組件就是Beans, Spring提供的最核心的功能就是Bean Factory。
Spring 解決了的最核心的問題就是把對象之間的依賴關系轉為用配置文件來管理，也就是Spring的依賴注入機制。這個注入機制是在Ioc 容器中進行管理的。
Bean 組件是在 Spring 的 org.springframework.beans 包下。這個包主要解決了如下功能：Bean 的定義、Bean 的創建以及對 Bean 的解析。對 Spring 的使用者來說唯一需要關心的就是 Bean 的創建，其他兩個由 Spring 內部機制完成。 Spring Bean 的創建採用典型的工廠模式，頂級介面是 BeanFactory。
BeanFactory 有三個子類：ListableBeanFactory、HierarchicalBeanFactory 和 AutowireCapableBeanFactory。但是從上可以發現最終的默認實現類是 DefaultListableBeanFactory，查閱這些介面的源碼和說明發現，每個介面都有他使用的場合，它主要是為了區分在 Spring 內部在操作過程中對象的傳遞和轉化過程中，對對象的數據訪問所做的限制。例如 ListableBeanFactory 介面表示這些 Bean 是可列表的，而 HierarchicalBeanFactory 表示的是這些 Bean 是有繼承關系的，也就是每個 Bean 有可能有父 Bean。AutowireCapableBeanFactory 介面定義 Bean 的自動裝配規則。這四個介面共同定義了 Bean 的集合、Bean 之間的關系、以及 Bean 行為。
Bean 的定義就是完整的描述在 Spring 的配置文件中你定義的 <bean/> 節點中所有的信息，包括各種子節點。當 Spring 成功解析定義的一個 <bean/> 節點後，在 Spring 的內部他就被轉化成 BeanDefinition 對象。以後所有的操作都是對這個對象完成的。Bean 的解析過程非常復雜，功能被分的很細，因為這里需要被擴展的地方很多，必須保證有足夠的靈活性，以應對可能的變化。Bean 的解析主要就是對 Spring 配置文件的解析。

❿ spring中怎麼通過構造方法註解給一個對象注入對象

#MyService.java
public class MyService(){
public MyDao ;
public MyService(MyDao ){
super();
this.=;
}
}
#beans.xml
<bean id="" class="com.xx.xx.My">
<bean id="MyService" class="com.xx.xx.MyService">
<constructor-arg><bean=""/></constructor-arg>
</bean>