ioc註解源碼

❶ ioc和aop的原理面試是什麼

1、ioc原理：

在傳統的實現中，由程序內部代碼來控制組件之間的關系。需要使用new關鍵字來實現兩個組件之間關系的組合，這種實現方式會造成組件之間耦合。IoC很好地解決了該問題，它將實現組件間關系從程序內部提到外部容器，也就是說由容器在運行期將組件間的某種依賴關系動態注入組件中。

對象A依賴於對象B,當對象A需要用到對象B的時候，IoC容器就會立即創建一個對象B送給對象A。IoC容器就是一個對象製造工廠，需要什麼，它會給提供，直接使用即可，而不用考慮所用的東西是如何製成的，也不用考慮最後是怎麼被銷毀的，這一切全部由IOC容器包辦。

2、aop原理：

AOP將業務邏輯組件和切面類都加入到容器中，負責在業務邏輯運行的時候將日誌進行列印，切面類負責動態感知MathCalculator.div運行到哪裡然後執行。通過＠Aspect通知註解給切面類的目標方法標注何時何地運行。

在程序創建之前會根據切入點表達式對增強器進行一一匹配，最終拿到所有的增強器。創建代理對象過程中，會先創建一個代理工廠，獲取到所有的增強器（通知方法），將這些增強器和目標類注入代理工廠，再用代理工廠創建對象。

(1)ioc註解源碼擴展閱讀：

AOP的組成：

1、方面（Aspect）：一個關注點的模塊化，這個關注點實現可能另外橫切多個對象。事務管理是J2EE應用中一個很好的橫切關注點例子。方面用Spring的Advisor或攔截器實現。

2、連接點（Joinpoint）：程序執行過程中明確的點，如方法的調用或特定的異常被拋出。

3、通知（Advice）：在特定的連接點，AOP框架執行的動作。各種類型的通知包括「around」、「before」和「throws」通知。通知類型將在下面討論。許多AOP框架包括Spring都是以攔截器做通知模型，維護一個「圍繞」連接點的攔截器鏈。

4、切入點（Pointcut）：指定一個通知將被引發的一系列連接點的集合。AOP框架必須允許開發者指定切入點：例如，使用正則表達式。

5、引入（Introction）：添加方法或欄位到被通知的類。Spring允許引入新的介面到任何被通知的對象。Spring中要使用Introction,可有通過來實現通知，通過DefaultIntroctionAdvisor來配置Advice和代理類要實現的介面

6、目標對象（Target Object）：包含連接點的對象。也被稱作被通知或被代理對象。POJO

7、AOP代理（AOP Proxy）：AOP框架創建的對象，包含通知。在Spring中，AOP代理可以是JDK動態代理或者CGLIB代理。

8、織入（Weaving）：組裝方面來創建一個被通知對象。這可以在編譯時完成（例如使用AspectJ編譯器），也可以在運行時完成。Spring和其他純java AOP框架一樣，在運行時完成織入。

❷ spring ioc 源碼 怎麼看 知乎

直觀的來說，就是由spring來負責控制對象的生命周期和對象間的關系，將對象之間的關系抽象出來，通過spring容器控制對象生成時機，減少對象之間的耦合度。

❸ IOC和AOP的區別

什麼是IoC
Ioc—Inversion of Control，即「控制反轉」，不是什麼技術，而是一種設計思想。在Java開發中，Ioc意味著將你設計好的對象交給容器控制，而不是傳統的在你的對象內部直接控制。如何理解好Ioc呢？理解好Ioc的關鍵是要明確「誰控制誰，控制什麼，為何是反轉（有反轉就應該有正轉了），哪些方面反轉了」，那我們來深入分析一下：
控制是什麼：傳統Java SE程序設計，我們直接在對象內部通過new進行創建對象，是程序主動去創建依賴對象；而IoC是有專門一個容器來創建這些對象，即由Ioc容器來控制對象的創建；誰控制誰？當然是IoC 容器控制了對象；控制什麼？那就是主要控制了外部資源獲取（不只是對象包括比如文件等）。
為何是反轉，哪些方面反轉了：有反轉就有正轉，傳統應用程序是由我們自己在對象中主動控制去直接獲取依賴對象，也就是正轉；而反轉則是由容器來幫忙創建及注入依賴對象；為何是反轉？因為由容器幫我們查找及注入依賴對象，對象只是被動的接受依賴對象，所以是反轉；哪些方面反轉了？依賴對象的獲取被反轉了。
IoC能做什麼

IoC不是一種技術，只是一種思想，一個重要的面向對象編程的法則，它能指導我們如何設計出松耦合、更優良的程序。傳統應用程序都是由我們在類內部主動創建依賴對象，從而導致類與類之間高耦合，難於測試；有了IoC容器後，把創建和查找依賴對象的控制權交給了容器，由容器進行注入組合對象，所以對象與對象之間是鬆散耦合，這樣也方便測試，利於功能復用，更重要的是使得程序的整個體系結構變得非常靈活。
其實IoC對編程帶來的最大改變不是從代碼上，而是從思想上，發生了「主從換位」的變化。應用程序原本是老大，要獲取什麼資源都是主動出擊，但是在IoC/DI思想中，應用程序就變成被動的了，被動的等待IoC容器來創建並注入它所需要的資源了。
IoC和DI
DI—Dependency Injection，即「依賴注入」：是組件之間依賴關系由容器在運行期決定，形象的說，即由容器動態的將某個依賴關系注入到組件之中。依賴注入的目的並非為軟體系統帶來更多功能，而是為了提升組件重用的頻率，並為系統搭建一個靈活、可擴展的平台。通過依賴注入機制，我們只需要通過簡單的配置，而無需任何代碼就可指定目標需要的資源，完成自身的業務邏輯，而不需要關心具體的資源來自何處，由誰實現。
註：如果想要更加深入的了解IoC和DI，請參考大師級人物Martin Fowler的一篇經典文章《Inversion of Control Containers and the Dependency Injection pattern》，原文地址：http://www.martinfowler.com/articles/injection.html。
AOP：面向切面編程
什麼是AOP：
概念：在軟體業，AOP為Aspect Oriented Programming的縮寫，意為：面向切面編程，通過預編譯方式和運行期動態代理實現程序功能的統一維護的一種技術。AOP是OOP的延續，是軟體開發中的一個熱點，也是Spring框架中的一個重要內容，是函數式編程的一種衍生范型。利用AOP可以對業務邏輯的各個部分進行隔離，從而使得業務邏輯各部分之間的耦合度降低，提高程序的可重用性，同時提高了開發的效率。（網路）
簡單的說：就是將程序中重復的代碼抽取出來，在需要執行的時候，使用動態代理的技術，在不修改源碼的基礎上，對我們的已有方法進行增強。
AOP的作用和優勢：
作用：從定義中來看，就是為了在程序運行期間，不修改源碼對已有方法進行增強。
優勢：減少重復代碼 提交了開發效率 維護方便
實現方式： 就是動態代理的技術
具體的作用：實現事務的控制 日誌 和 安全模塊
想系統的學習編程可以來我這看看，希望對您有所幫助！~

❹ java中的Spring裡面的ioc和aop有什麼區別他們都有什麼用

IOC的基本概念是：不創建對象，但是描述創建它們的方式。在代碼中不直接與對象和服務連接，但在配置文件中描述哪一個組件需要哪一項服務。Spring容器負責將這些聯系在一起。也就是說，Spring的IOC負責管理各種對象的創建、清除以及它們之間的聯系。AOP是指面向切面編程（也叫面向方面），可以通過預編譯方式和運行期動態代理實現在不修改源代碼的情況下給程序動態統一添加功能的一種技術。一般用於事務管理、許可權控制、錯誤處理等各種業務中共同性的東西。

❺ 如何閱讀Nutz的源碼

開始學習框架思想了,打算先從nutz入手,因為nutz是國人寫的,中文注釋,容易理解

而且nutz框架比較小,但是麻雀雖小五臟俱全,大牛的思想還是可以學到的.

1、

這里if感覺多此一舉,既然這樣判斷何不在warn裡面判斷呢(效率問題),感覺這樣寫法有點蛋疼,

❻ 什麼是AOP、IOC他們的作用是什麼

什麼是IoC
Ioc—Inversion of Control，即「控制反轉」，不是什麼技術，而是一種設計思想。在Java開發中，Ioc意味著將你設計好的對象交給容器控制，而不是傳統的在你的對象內部直接控制。如何理解好Ioc呢？理解好Ioc的關鍵是要明確「誰控制誰，控制什麼，為何是反轉（有反轉就應該有正轉了），哪些方面反轉了」，那我們來深入分析一下：
控制是什麼：傳統Java SE程序設計，我們直接在對象內部通過new進行創建對象，是程序主動去創建依賴對象；而IoC是有專門一個容器來創建這些對象，即由Ioc容器來控制對象的創建；誰控制誰？當然是IoC 容器控制了對象；控制什麼？那就是主要控制了外部資源獲取（不只是對象包括比如文件等）。
為何是反轉，哪些方面反轉了：有反轉就有正轉，傳統應用程序是由我們自己在對象中主動控制去直接獲取依賴對象，也就是正轉；而反轉則是由容器來幫忙創建及注入依賴對象；為何是反轉？因為由容器幫我們查找及注入依賴對象，對象只是被動的接受依賴對象，所以是反轉；哪些方面反轉了？依賴對象的獲取被反轉了。
IoC能做什麼

IoC不是一種技術，只是一種思想，一個重要的面向對象編程的法則，它能指導我們如何設計出松耦合、更優良的程序。傳統應用程序都是由我們在類內部主動創建依賴對象，從而導致類與類之間高耦合，難於測試；有了IoC容器後，把創建和查找依賴對象的控制權交給了容器，由容器進行注入組合對象，所以對象與對象之間是鬆散耦合，這樣也方便測試，利於功能復用，更重要的是使得程序的整個體系結構變得非常靈活。
其實IoC對編程帶來的最大改變不是從代碼上，而是從思想上，發生了「主從換位」的變化。應用程序原本是老大，要獲取什麼資源都是主動出擊，但是在IoC/DI思想中，應用程序就變成被動的了，被動的等待IoC容器來創建並注入它所需要的資源了。
IoC和DI
DI—Dependency Injection，即「依賴注入」：是組件之間依賴關系由容器在運行期決定，形象的說，即由容器動態的將某個依賴關系注入到組件之中。依賴注入的目的並非為軟體系統帶來更多功能，而是為了提升組件重用的頻率，並為系統搭建一個靈活、可擴展的平台。通過依賴注入機制，我們只需要通過簡單的配置，而無需任何代碼就可指定目標需要的資源，完成自身的業務邏輯，而不需要關心具體的資源來自何處，由誰實現。
註：如果想要更加深入的了解IoC和DI，請參考大師級人物Martin Fowler的一篇經典文章《Inversion of Control Containers and the Dependency Injection pattern》，原文地址：http://www.martinfowler.com/articles/injection.html。
AOP：面向切面編程
什麼是AOP：
概念：在軟體業，AOP為Aspect Oriented Programming的縮寫，意為：面向切面編程，通過預編譯方式和運行期動態代理實現程序功能的統一維護的一種技術。AOP是OOP的延續，是軟體開發中的一個熱點，也是Spring框架中的一個重要內容，是函數式編程的一種衍生范型。利用AOP可以對業務邏輯的各個部分進行隔離，從而使得業務邏輯各部分之間的耦合度降低，提高程序的可重用性，同時提高了開發的效率。（網路）
簡單的說：就是將程序中重復的代碼抽取出來，在需要執行的時候，使用動態代理的技術，在不修改源碼的基礎上，對我們的已有方法進行增強。
AOP的作用和優勢：
作用：從定義中來看，就是為了在程序運行期間，不修改源碼對已有方法進行增強。
優勢：減少重復代碼 提交了開發效率 維護方便
實現方式： 就是動態代理的技術
具體的作用：實現事務的控制 日誌 和 安全模塊
想系統的學習編程可以來我這看看，希望對您有所幫助！~

❼ spring的ioc和aop都是什麼

什麼是IoC

Ioc—Inversion of
Control，即「控制反轉」，不是什麼技術，而是一種設計思想。在Java開發中，Ioc意味著將你設計好的對象交給容器控制，而不是傳統的在你的對象內部直接控制。如何理解好Ioc呢？理解好Ioc的關鍵是要明確「誰控制誰，控制什麼，為何是反轉（有反轉就應該有正轉了），哪些方面反轉了」，那我們來深入分析一下：

控制是什麼：傳統Java
SE程序設計，我們直接在對象內部通過new進行創建對象，是程序主動去創建依賴對象；而IoC是有專門一個容器來創建這些對象，即由Ioc容器來控制對象的創建；誰控制誰？當然是IoC
容器控制了對象；控制什麼？那就是主要控制了外部資源獲取（不只是對象包括比如文件等）。

為何是反轉，哪些方面反轉了：有反轉就有正轉，傳統應用程序是由我們自己在對象中主動控制去直接獲取依賴對象，也就是正轉；而反轉則是由容器來幫忙創建及注入依賴對象；為何是反轉？因為由容器幫我們查找及注入依賴對象，對象只是被動的接受依賴對象，所以是反轉；哪些方面反轉了？依賴對象的獲取被反轉了。

IoC能做什麼

IoC不是一種技術，只是一種思想，一個重要的面向對象編程的法則，它能指導我們如何設計出松耦合、更優良的程序。傳統應用程序都是由我們在類內部主動創建依賴對象，從而導致類與類之間高耦合，難於測試；有了IoC容器後，把創建和查找依賴對象的控制權交給了容器，由容器進行注入組合對象，所以對象與對象之間是鬆散耦合，這樣也方便測試，利於功能復用，更重要的是使得程序的整個體系結構變得非常靈活。

其實IoC對編程帶來的最大改變不是從代碼上，而是從思想上，發生了「主從換位」的變化。應用程序原本是老大，要獲取什麼資源都是主動出擊，但是在IoC/DI思想中，應用程序就變成被動的了，被動的等待IoC容器來創建並注入它所需要的資源了。

IoC和DI

DI—Dependency
Injection，即「依賴注入」：是組件之間依賴關系由容器在運行期決定，形象的說，即由容器動態的將某個依賴關系注入到組件之中。依賴注入的目的並非為軟體系統帶來更多功能，而是為了提升組件重用的頻率，並為系統搭建一個靈活、可擴展的平台。通過依賴注入機制，我們只需要通過簡單的配置，而無需任何代碼就可指定目標需要的資源，完成自身的業務邏輯，而不需要關心具體的資源來自何處，由誰實現。

註：如果想要更加深入的了解IoC和DI，請參考大師級人物Martin Fowler的一篇經典文章《Inversion of Control
Containers and the Dependency Injection
pattern》，原文地址：http://www.martinfowler.com/articles/injection.html。

AOP：面向切面編程

什麼是AOP：

概念：在軟體業，AOP為Aspect Oriented
Programming的縮寫，意為：面向切面編程，通過預編譯方式和運行期動態代理實現程序功能的統一維護的一種技術。AOP是OOP的延續，是軟體開發中的一個熱點，也是Spring框架中的一個重要內容，是函數式編程的一種衍生范型。利用AOP可以對業務邏輯的各個部分進行隔離，從而使得業務邏輯各部分之間的耦合度降低，提高程序的可重用性，同時提高了開發的效率。（網路）

簡單的說：就是將程序中重復的代碼抽取出來，在需要執行的時候，使用動態代理的技術，在不修改源碼的基礎上，對我們的已有方法進行增強。

AOP的作用和優勢：

作用：從定義中來看，就是為了在程序運行期間，不修改源碼對已有方法進行增強。

優勢：減少重復代碼 提交了開發效率 維護方便

實現方式： 就是動態代理的技術

具體的作用：實現事務的控制 日誌 和 安全模塊

想系統的學習編程可以來我這看看，希望對您有所幫助！~

❽ hibernate Spring 框架下,IOC注入以及事務的問題.

我想問你的類是否遵循了Bean的要求，有構造方法，有序列化標識，註解在底層依然是由容器替我們去創建bean對象，用bean對象需要遵守默認的約定。不知道對你是否有幫助。

❾ 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();
}