**延遲初始化Bean:**   
    也叫惰性初始化，指的是不提前初始化Bean，而是隻有在真正使用的時候才建立以   及初始化Bean。
    配置方式很簡單，只需要在<bean>標籤上指定"lazy-init"屬性值為true即可延遲初始  化Bean。
    Spring容器會在建立容器時提前初始化Singleton作用域的bean，Singleton就是單例 的意思，即整個容器每個bean只有一個例項。Spring容器預先初始化Bean同城能夠幫助我們提前發現配置錯誤，所以沒有什麼情況建議開啟，除非有某個bean可能需要載入很大資源，而且很有可能在整個應用程式生命週期中很有可能使用不到，可以設定為延遲初始化。
    延遲初始化的Bean通常會再第一次使用的時候被初始化，或者在被非延遲初始化Bean作為以來物件注入時為依賴物件注入時在會隨著初始化該Bean時初始化，因為在這個時候使用延遲初始化Bean。
        <bean id
 
="user" 
            Class="org.liang.entity.User"  
            lazy-init="true" />

depends-on : 是指指定Bean初始化以及銷燬時的順序，使用depends-on屬性指定的Bean要初始化完畢以後才會初始化當前的Bean，由於只有“Singleton”Bean能夠被Spring管理銷燬，所以當指定的Bean都是Singleton時，使用depends-on時，使用depends-on屬性指定的Bean要在指定的Bean之後銷燬。

ResourceBean.java

package
 
 org.liang.entity;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * Created by rcc on 2018/1/29.
 */
public class ResourceBean {
    private FileOutputStream fos;
    private String fileAddress;

    //初始化方法
    public void init
 
(){
        System.out.println("ResourceBean: ================初始化");
        System.out.println("ResourceBean: ============載入");
        try {
            this.fos = new FileOutputStream(new File(fileAddress));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }


    //銷燬資源方法
    public void destroy(){
        System.out.println("ResourceBean:===============銷燬");
        System.out.println("ResourceBean:===============釋放資源，執行一些操作");
        try {
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public FileOutputStream getFos() {
        return fos;
    }

    public void setFos(FileOutputStream fos) {
        this.fos = fos;
    }

    public String getFileAddress() {
        return fileAddress;
    }

    public void setFileAddress(String fileAddress) {
        this.fileAddress = fileAddress;
    }
}

DependentBean.java

“`
package org.liang.factory;

import org.liang.entity.ResourceBean;

import java.io.IOException;

/**
* Created by rcc on 2018/1/29.
*/
public class DependentBean {
private ResourceBean resourceBean;

//寫入內容
public void write(String ss) throws IOException {
    System.out.println("DependentBean:==============寫資源");
    resourceBean.getFos().write(ss.getBytes());
}

//初始化方法
public void init() throws IOException {
    System.out.println("DependentBean:==============初始化");
    resourceBean.getFos().write("DependentBean:================初始化=======".getBytes());
}
//銷燬方法
public void destory() throws IOException {
    System.out.println("DependentBean:==============銷燬");
    //在銷燬之前需要向文字中寫入銷燬內容
    resourceBean.getFos().write("DependentBean:==============銷燬======".getBytes());
}


public ResourceBean getResourceBean() {
    return resourceBean;
}

public void setResourceBean(ResourceBean resourceBean) {
    this.resourceBean = resourceBean;
}

}

“`Spring-config.xml

 <!--測試 懶載入-->
    <bean id="resourceBean"
          class="org.liang.entity.ResourceBean"
          init-method="init" destroy-method="destroy">
        <property name="fileAddress" value="E:/lazy.txt" />
    </bean>
    <!--
        init-method="init" ：指定初始化方法，在構造器注入和setter注入完畢後執行。
        destroy-method="destroy"：指定銷燬方法，只有“singleton”作用域能銷燬，“prototype”作用域的一定不能，
                                    其他作用域不一定能；
    -->
    <bean id="dependentBean"
          class="org.liang.factory.DependentBean"
          init-method="init"
          destroy-method="destory"
          depends-on="resourceBean"
          autowire="byName"> <!--autowire="default"-->
        <property name="resourceBean" ref="resourceBean"/>

    </bean>
    <!--在此配置中，resourceBean初始化在dependentBean之前被初始化，
           resourceBean銷燬會在dependentBean銷燬之後執行-->


    <!--
        自動裝配：
            default:表示使用預設的自動裝配，預設的是自動裝配需要在<beans>標籤中使用default-autowire屬性指定，其支援“no”、“byName ”、“byType”、“constructor”四種自動裝配
            no:意思是不支援自動裝配，必須明確指定依賴。
            byName:通過設定Bean定義屬性autowire="byName",意思是根據名字進行自動裝配，只能用於setter注入。
     -->

MoreDependencyInjectTest .java

package org.liang.test;

import org.liang.factory.DependentBean;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;

/**
 * Created by rcc on 2018/1/30.
 */
public class MoreDependencyInjectTest {
    public static void main(String [] args){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        DependentBean dependentBean = context.getBean(DependentBean.class);
        //註冊銷燬回撥否則銷燬的方法不會執行
        context.registerShutdownHook();
        try {
            dependentBean.write("hello world!!");
        } catch (IOException e) {
            e.printStackTrace();
        }



        /*

        返回的結果：

            ResourceBean: ================初始化
            ResourceBean: ============載入
            DependentBean:==============初始化
            DependentBean:==============寫資源
            DependentBean:==============銷燬
            ResourceBean:===============銷燬
            ResourceBean:===============釋放資源，執行一些操作
          */
    }
}

自動裝配

    指的是由Spring來自主地注入依賴物件，無需人工參與。

    目前Spring3.0支援“no”、“byName ”、“byType”、“constructor”四種自動裝配，預設是“no”指不支援自動裝配的，其中Spring3.0已不推薦使用之前版本的“autodetect”自動裝配，推薦使用Java 5+支援的（@Autowired）註解方式代替；如果想支援“autodetect”自動裝配，請將schema改為“spring-beans-2.5.xsd”或去掉。



           自動裝配的好處是減少構造器注入和setter注入配置，減少配置檔案的長度。自動裝配通過配置<bean>標籤的“autowire”屬性來改變自動裝配方式。接下來讓我們挨著看下配置的含義。

           一、default：表示使用預設的自動裝配，預設的自動裝配需要在<beans>標籤中使用default-autowire屬性指定，其支援“no”、“byName ”、“byType”、“constructor”四種自動裝配，如果需要覆蓋預設自動裝配，請繼續往下看；

           二、no：意思是不支援自動裝配，必須明確指定依賴。

           三、byName：通過設定Bean定義屬性autowire="byName"，意思是根據名字進行自動裝配，只能用於setter注入。比如我們有方法“setHelloApi”，則“byName”方式Spring容器將查詢名字為helloApi的Bean並注入，如果找不到指定的Bean，將什麼也不注入。

        四、“byType”：通過設定Bean定義屬性autowire="byType"，意思是指根據型別注入，用於setter注入，比如如果指定自動裝配方式為“byType”，而“setHelloApi”方法需要注入HelloApi型別資料，則Spring容器將查詢HelloApi型別資料，如果找到一個則注入該Bean，如果找不到將什麼也不注入，如果找到多個Bean將優先注入<bean>標籤“primary”屬性為true的Bean，否則丟擲異常來表明有個多個Bean發現但不知道使用哪個
  五、“constructor”：通過設定Bean定義屬性autowire="constructor"，功能和“byType”功能一樣，根據型別注入構造器引數，只是用於構造器注入方式，