Spring DI IOC

做爲一名即將畢業的大四學生，雖然我已經在公司實習了4個多月，可是幾乎接觸不到ssh搭建框架的配置。好比hibernate的一對多，多對多關係啊，還有spring的一些配置。最近準備去參加下面試，在看java面試寶典的時候發現不少基礎的配置都忘記了，因而拿出書來複習下。順便共享下，但願也能幫到正在找工做的同窗們哈。話很少說，進入主題。

面試和筆試常常會看到Spring IOC DI AOP的問題下面咱們就來解釋和實戰下這幾個東東

IOC(Inversion of Control)控制反轉

它把傳統上由程序代碼直接操控的對象的調用權交給容器，經過容器來實現對象組建的裝配和管理。

IOC主要有兩種實現的方式

（1）依賴查找（Dependency Lookup）:容器提供回調接口和上下文環境給組件。EJB和Apache Avalon都使用這種方法。

（不懂沒用過，從書上抄過來，面試的時候能說下）

（2）依賴注入（Dependency Injection）:組件不作定位查詢，只提供普通的Java方法讓容器去決定依賴關係。

                                                          Inversion of Control

                                                                            |

                                            ______________________________________________

                                            |                                                                    |

                                    Dependency Lookup                                    Dependency Injection

                                                                                                                    |

                                                                                               ————————————————

                                                                                               |                            |                             |

                                                                                   interface Injection       Setter Injection       Constructor Injection

上面的結構圖，圖字應該打引號，不知道怎麼畫圖的說。你們將就下吧。

下面上代碼，設置注入

package com.ioc.test;
public interface Person { // 定義Person接口
 public void userAxe(); // Person接口裏定義一個使用斧頭的方法
}

package com.ioc.test;
public interface Axe { // 定義Axe接口
 public String chop(); // Axe接口裏面有個砍的方法
}

package com.ioc.test;
public class Chinese implements Person { // Chinese實現Person接口
 private Axe axe; // 面向Axe接口編程，而不是具體的實現類
 public Chinese() { // 默認的構造方法
 }
 public void setAxe(Axe axe) { // 設置注入所須要的setXxx()方法
  this.axe = axe;
 }
 public void userAxe() { // 實現Person接口的userAxe方法
  System.out.println(axe.chop());
 }
}

package com.ioc.test;
public class StoneAxe implements Axe { // Axe的一個實現類StoneAxe
 public StoneAxe() { // 默認構造方法
 }
 public String chop() { // 實現Axe接口的chop()方法
  return "石斧砍柴好慢";
 }
}

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

"
http://www.springframework.org.dtd/spring-beans.dtd
">

<beans>

 <!-- 定義的Bean的id是chinese,class指定實現類 -->

 <bean id="chinese" class="com.ioc.test.Chinese">

 <!-- property元素用來指定須要容器注入的屬性，axe屬性須要容器注入，此處是設置注入，所以Chinese類必須擁有setAxe()方法 -->

  <property name="axe">

   <ref local="stoneAxe"/>

  </property>

 </bean>

 <bean id="stoneAxe" class="com.ioc.test.StoneAxe">

 </bean>

</beans>

package com.ioc.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BeanTest {
 public static void main(String[] args) {
  ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml"); // 這兩個方法要傳入的路徑不一樣 bean.xml在src目錄下
  // ApplicationContext ctx = new FileSystemXmlApplicationContext("src/bean.xml");
  Person p = (Person) ctx.getBean("chinese"); // 經過id得到person
  p.userAxe();
 }
}

    上面就是設置注入的代碼，運行結果控制檯打印出  石斧砍柴好慢 。

在該程序中，咱們並無手動構造任何對象，StoneAxe 和 Chinese 實例都是由BeanFactory構造的，並且它們的依賴關係設置也是有DI容器完成的。咱們所作的事情，只是告訴了BeanFactory這些對象間的依賴關係。     

提示：主程序調用Person的userAxe()方法時，該方法須要使用Axe的實例，但程序中並無將特定的Person實例和Axe實例耦合在一塊兒。或者說，程序裏沒有爲Person實例傳入Axe的實例，Axe的實例由Spring在運行期間動態注入。  

構造注入代碼

package com.ioc.test;
public class Animal {
 private String name;
 private int age;
 public Animal(String name, int age) {
  this.name = name;
  this.age = age;
 }
 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;
 }
}

 <bean id="animal" class="com.ioc.test.Animal">

  <constructor-arg><value>Dog</value></constructor-arg>

  <constructor-arg><value>3</value></constructor-arg>

 </bean>

這樣就能getBean("animal")獲得com.ioc.test.Animal類。 可是3 和 Dog的順序不能錯，不然報出異常。

咱們能夠經過按類型匹配傳入參數

 <bean id="animal" class="com.ioc.test.Animal">

  <constructor-arg type="java.lang.String"><value>Dog</value></constructor-arg>

  <constructor-arg type="int"><value>3</value></constructor-arg>

 </bean>

當不肯定參數類型而肯定參數個數時，能夠用索引匹配傳入參數

<bean id="animal" class="com.ioc.test.Animal">


  <constructor-arg index="0"><value>Dog</value></constructor-arg>


  <constructor-arg index="1"><value>3</value></constructor-arg>


 </bean>

聯合使用

<bean id="animal" class="com.ioc.test.Animal">



  <constructor-arg type="java.lang.String" index="0"><value>Dog</value></constructor-arg>



  <constructor-arg type="int" index="1"><value>3</value></constructor-arg>



 </bean>

提示：設值注入與構造注入的區別在於：設值注入是在須要某一個Bean實例時，建立一個默認的Bean實例，而後調用對應的設值方法注入依賴關係；而構造注入則在建立Bean實例時，已經完成了依賴關係的注入。

關於他們的優缺點：看上面的例子想下把，或者百度一下啦。

屬性注入

@Autowired,@Resource ，@EJB

前面兩個的區別你們去百度吧，EJB沒用過

package com.ioc.test;
public class Office {
 private String officeNo = "001";
 public String toString() {
  return "辦公號： " + officeNo;
 }
 public String getOfficeNo() {
  return officeNo;
 }
 public void setOfficeNo(String officeNo) {
  this.officeNo = officeNo;
 }
}

package com.ioc.test;
import org.springframework.beans.factory.annotation.Autowired;
public class Boss {
 @Autowired
 private Office office;
 public String toString() {
  return "office--" + office;
 }
 public Office getOffice() {
  return office;
 }
 public void setOffice(Office office) {
  this.office = office;
 }
}

 <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"></bean>

 <bean id="boss" class="com.ioc.test.Boss">

 </bean>

 <bean id="office" class="com.ioc.test.Office">

  <property name="officeNo" value="002"> <!-- 從新給officeNo屬性賦值 -->

  </property>

 </bean>

在測試類中

   Boss boss = (Boss) ctx.getBean("boss"); // 經過id得到person

  System.out.println(boss);

打印結果  ： office--辦公號： 002

還有方法注入，可是書上說方法注入的使用過於複雜，並且不適用。咱們徹底能夠經過改進應用的架構設計，避免使用它。

做爲應屆生只知道這麼點啦。AOP的例子晚點寫上來，但願能幫助到你們。