IOC
宣告一個bean
首先設定一個介面Performance表示表演者。

package com.moonlit.myspring;
//表演
public interface Perform {
    //方法
    public void perform();

}

  **建立一個Juggler（雜技師）的類繼承Performer表示表演者是雜技師**
        package com.moonlit.myspring;
    //雜技
    public class Juggler implements Perform {
        private int bags=3;//小球的個數
    
        public Juggler(int bags){
            this.bags=bags;
        }
        
        public Juggler(){}
        
        @Override
        public void perform() {
            System.out.println("表演拋"+bags+"小球");
    
        }
    }
 

在spring-idaol.xml配置檔案中定義了一個名為duke的bean，他對應Juggler類

<?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 class FirstBean { 
public static void main(String[] args)  { 
ApplicationContext context = new ClassPathXmlApplicationContext("spring-idol.xml"); 
Performer performer = (Performer) context.getBean("duke"); performer.perform(); 
}
 } 
 

執行結果如下：

表演拋3個小球

理解：首先定義了一個介面Performer，然後寫了一個類Juggler實現了Performer，Juggler裡面有一個私有的成員變數bags，他的預設值是3，
然後Juggler實現了Performance的perform方法
方法輸出帶有bags的數量。
然後再測試的過程中，通過ApplicationContext 型別載入了spring-idol.xml的檔案內容，而在xml中定義了名字為“duke”的bean，然後剛好就用到了。然後bean返回是一個Juggler，所以將：

Performer performer = (Performer) context.getBean("duke");

改成

Juggler performer = (Juggler) context.getBean("duke");

也是可以的，但是想看見效果可以通過ApplicationContext 返回是不是一個Juggler，因為通過輸出結果就可以知道了，所以用（Performer）,輸出的效果顯示bean對應的Performer真的是一個Juggler，這就通過xml定義一個bean並通過applicationcontext獲取得到這個bean的整個過程。

方便理解bean，我們可以把

 <bean id="duke" class="com.moonlit.myspring.Juggler" />

看成

Juggler duke=new Juggler();

每一次執行spring容器就會建立個Juggler名字為duke的物件。

構造器注入

這裡通過一個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;



public class MoonlightPoem {
    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");
        MoonlightPoem moonlightPoet = (MoonlightPoem) 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="mooncake" class="com.moonlit.myspring.MoonlightPoem">
    <property name="age" value="25"></property>
    <property name="name" value="luhan"></property>
    <property name="poem" ref="songxiaofeng"></property>
    <property name="list">
    <list>
    <value>zhangsan</value>
    <value>lisi</value>
    </list>
    </property>

    <property name="map">
    <map>
    <entry key="1" value="1"></entry>
    <entry key="2" value="2"></entry>
    <entry key="3" value="3"></entry>
    </map>
    </property>
    </bean>

結果為

in list : luhan 25
in list : songxiaofeng
in map : key1 -- value1
in map : key2 -- value2
in map : key3 -- value3

自動裝配bean屬性

Spring提供了四種類型的自動裝配策略：

byName – 把與Bean的屬性具有相同名字(或者ID)的其他Bean自動裝配到Bean的對應屬性中。

byType – 把與Bean的屬性具有相同型別的其他Bean自動裝配到Bean的對應屬性中。

constructor – 把與Bean的構造器入參具有相同型別的其他Bean自動裝配到Bean的對應屬性中。

autodetect – 首先使用costructor進行自動裝配。如果失敗，再嘗試使用byType進行自動裝配。