java Spring系列之 配置文件的操做 +Bean的生命週期+不一樣數據類型的注入簡析+注入的原理詳解+配置文件中不一樣標籤體的使用方式

Spring系列之 配置文件的操做

寫在文章前面：
本文帶你們掌握Spring配置文件的基礎操做以及帶領你們理清依賴注入的概念，本文涉及內容普遍，若是各位讀者耐心看完，應該會對自身有一個提高
java

Spring配置文件的做用

Spring配置文件是用於Spring工廠進行Bean生產，依賴關係注入，Bean實例分發的圖紙，他相似於人類的大腦，咱們必須掌握這張圖紙的使用方法，才能進行相關的操做，靈活運用這張圖紙準確的表達本身的意圖。指揮若定，決勝千里。Spring的配置文件是一個或多個標準的xml文檔，applicationContext.xml文件是默認的配置文件，當容器啓動找不到配置文件時，就會嘗試加載這個配置文件。
未使用Spring前程序的開發步驟spring

這裏以配置一個User類爲例，UserImp爲接口，User爲其實現類，咱們原本使用一個 UserImp接口去接收一個User的實現對象，原本是經過如下代碼：apache

UserImp user=new User（）

流程圖：app

使用上述方法的缺點：代碼的耦合度太高框架

使用Spring框架操做maven

這裏以配置一個User類爲例，UserImp爲接口，User爲其實現類，咱們使用一個 UserImp接口去接受一個User的實現對象，代碼以下：ide

UserDao user=Spring客戶端.getBean（id標識符）

那麼其內部的原理是怎麼樣的呢？要實現解耦，基本上都是使用配置文的方式，Spring天然也不例外，下面經過一張流程圖解來帶領你們更好的領會函數

流程圖解：this

Spring入門實現步驟

1.在pom.xml中導入Spring框架的座標
2.建立Bean
3.建立applicationContext.xml
4.在xml中經行配置
5.建立ApplicationContext對象getBeanprototype

實現一個簡單的Spring案例

項目結構：

主函數，使用Spring的API獲取Bean實例
存在的文件夾：

package com.pjh.Dao.Demo;
import com.pjh.Dao.UserDaoImp.UserDaoImp;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class demo1 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new                                                   ClassPathXmlApplicationContext("applicationContext.xml");
        UserDaoImp userDaoImp =(UserDaoImp) classPathXmlApplicationContext.getBean("userDaoImp");
        userDaoImp.save();
    }
}

建立Spring的配置文件：applicationContext.xml
存在的文件夾：

代碼：

<?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.xsd">
<bean id="userDaoImp"  class="com.pjh.Dao.UserDaoImp.UserDaoImp" ></bean>
</beans>

導入Spring開發的基本座標，在pom.xml配置文件
文件位置

代碼：

4.0.0

<groupId>com.pjh</groupId>
<artifactId>SpringIOCInit</artifactId>
<version>1.0-SNAPSHOT</version>

編寫userDaoImp類的相關信息:

package com.pjh.Dao.UserDaoImp;
import com.pjh.Dao.UserDao;
public class UserDaoImp  implements  UserDao{
    public void save() {
        System.out.println("save runing!!");
    }
}

運行結果
成功執行

Bean標籤介紹與基本屬性

3.1 Bean標籤的基本配置
用於配置文件交由Spring配置，默認調用無參構造，若是沒有無參構造則建立失敗
id：Bean實例在Spring中的惟一標識符
class：Bean實例的全限定名稱

若是你在某個實現類中複寫了有參構造，記得添加無參構造方法，由於你複寫了有參構造後，本來的無參構造會消除掉，若是你在這個時候仍然在Spring的配置文件中默認使用無參構造，那麼這時候他就會報錯

如圖

3.2Bean的標籤範圍配置

這裏講解一下singleton（單例的）和prototype（多例的）
當scope取值爲singleton時：
Bean的實例化個數：1個
Bean的實例化時機：當Spring核心配置文件被加載時
Bean的生命週期：
對象建立：當應用加載時對象建立
對象運行：只要容器在，對象就一直活着
對象銷燬：當應用卸載，容器銷燬時
示例
配置文件信息

<?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.xsd">
<bean id="userDaoImp"  class="com.pjh.Dao.UserDaoImp.UserDaoImp"  scope="singleton"></bean>
</beans>

主函數代碼，使用Spring的API建立兩個Bean對象：

package com.pjh.Dao.Demo;
import com.pjh.Dao.UserDaoImp.UserDaoImp;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class demo1 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //獲取第一個Bean對象
        UserDaoImp userDaoImp =(UserDaoImp) classPathXmlApplicationContext.getBean("userDaoImp");
        //獲取第二個Bean對象
        UserDaoImp userDaoImp2 =(UserDaoImp) classPathXmlApplicationContext.getBean("userDaoImp");
        //輸出第一個Bean對象的內存地址
        System.out.println(userDaoImp);
        //輸出第二個Bean對象的內存地址
        System.out.println(userDaoImp2);
    }
}

運行結果：
兩個對象的地址值同樣，說明爲同一個對象

當scope取值爲prototype時：
Bean的實例化格式：多個
Bean的實例化時機：當調用getBean（）方法時，實例化Bean
對象建立：當使用對象時，建立新的對象實例
對象運行：只要對象在使用中，對象就一直存在
對象銷燬：對象長時間不使用，就會被java的垃圾回收機制回收

示例
配置文件信息

<?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.xsd">
<bean id="userDaoImp"  class="com.pjh.Dao.UserDaoImp.UserDaoImp"  scope="prototype"></bean>
</beans>

主函數代碼，使用Spring的API建立兩個Bean對象：

package com.pjh.Dao.Demo;
import com.pjh.Dao.UserDaoImp.UserDaoImp;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class demo1 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //獲取第一個Bean對象
        UserDaoImp userDaoImp =(UserDaoImp) classPathXmlApplicationContext.getBean("userDaoImp");
        //獲取第二個Bean對象
        UserDaoImp userDaoImp2 =(UserDaoImp) classPathXmlApplicationContext.getBean("userDaoImp");
        //輸出第一個Bean對象的內存地址
        System.out.println(userDaoImp);
        //輸出第二個Bean對象的內存地址
        System.out.println(userDaoImp2);
    }
}

運行結果：
兩個對象的地址值不同，說明爲不對象

3.3Bean的生命週期配置
init-method：指定類中的初始化方法
destroy-method：指定類中的銷燬方法
使用這兩個方法咱們能夠佐證一下上面所說的Bea對象的建立時機：

編寫spring核心配置文件的信息
scope爲：prototype（雙例）

<?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.xsd">
<bean id="userDaoImp"  class="com.pjh.Dao.UserDaoImp.UserDaoImp" scope="prototype" init-method="initmethod" destroy-method="destroyedmetho"></bean>
</beans>

編寫userDaoImp的相關配置文件信息

package com.pjh.Dao.Demo;
import com.pjh.Dao.UserDaoImp.UserDaoImp;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class demo1 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //獲取第一個Bean對象
        UserDaoImp userDaoImp =(UserDaoImp) classPathXmlApplicationContext.getBean("userDaoImp");
        //獲取第二個Bean對象
        UserDaoImp userDaoImp2 =(UserDaoImp) classPathXmlApplicationContext.getBean("userDaoImp");
        //輸出第一個Bean對象的內存地址
        System.out.println("對象1");
        System.out.println(userDaoImp);
        //輸出第二個Bean對象的內存地址
        System.out.println("對象2");
        System.out.println(userDaoImp2);
    }
}

運行結果：
構造方法被調用了兩次，說明建立了兩個對象
方法被調用的次序：構造方法->初始化方法

scope爲：prototype（單例）
配置文件代碼

<?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.xsd">
<bean id="userDaoImp"  class="com.pjh.Dao.UserDaoImp.UserDaoImp" scope="singleton" init-method="initmethod" destroy-method="destroyedmetho"></bean>
</beans>

主函數

package com.pjh.Dao.Demo;
import com.pjh.Dao.UserDaoImp.UserDaoImp;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class demo1 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //獲取第一個Bean對象
        UserDaoImp userDaoImp =(UserDaoImp) classPathXmlApplicationContext.getBean("userDaoImp");
        //獲取第二個Bean對象
        UserDaoImp userDaoImp2 =(UserDaoImp) classPathXmlApplicationContext.getBean("userDaoImp");
        //輸出第一個Bean對象的內存地址
        System.out.println("對象1");
        System.out.println(userDaoImp);
        //輸出第二個Bean對象的內存地址
        System.out.println("對象2");
        System.out.println(userDaoImp2);
    }
}

運行結果

構造方法與初始化方法均只被調用了一次，故爲同一個對象

**

Bean實例化的三種方式

**
1.使用無參構造實例化
他會根據默認無參構造來建立實例化對象，沒有無參構造的方法這裏會報錯，這點咱們在上面已經說的很清楚了

<bean id="userDaoImp"  class="com.pjh.Dao.UserDaoImp.UserDaoImp" ></bean>

2.工廠靜態方法實例化
工廠的靜態方法返回實例化對象

package com.pjh.Dao.factory;
import com.pjh.Dao.UserDaoImp.UserDaoImp;
public class factory {
    public static UserDaoImp getUserDaoImp(){
        return new UserDaoImp();
    }
}

<bean id="factory" class="com.pjh.Dao.factory.factory"  factory-method="getUserDaoImp"></bean>

3.工廠實例方法實例實例化
工廠的非靜態方法放回Bean實例

package com.pjh.Dao.factory;
import com.pjh.Dao.UserDaoImp.UserDaoImp;
public class factory {
    public UserDaoImp getUserDaoImp(){
        return new UserDaoImp();
    }
}

配置文件的代碼

<bean id="factory" class="com.pjh.Dao.factory.factory" ></bean>
   <bean id="userDao" factory-bean="factory" factory-method="getUserDaoImp"></bean>

依賴注入

依賴注入是Spring框架核心IOC的具體實現，其本質是經過控制反轉，把建立對象的操做交給Spring來實現，可是代碼中不可能出現沒有依賴的狀況，IOC解耦只是下降他們之間的耦合性，並不會徹底消除依賴，例如：業務層仍然調用持久層的方法，只是這種業務層和持久層的依賴關係，在使用Spring以後，交給Spring來管理，簡單的來講就是讓框架來完成持久層傳入業務層的操做。

下面經過userServic類內部使用userDaoImp類來說述依賴注入的相關操做
userDaoImp代碼

package com.pjh.Dao.UserDaoImp;
import com.pjh.Dao.UserDao;
public class UserDaoImp  implements  UserDao{
    public void save() {
        System.out.println("save runing!!");
    }
}

userService代碼

package com.pjh.Dao.service;
import com.pjh.Dao.UserDao;
import com.pjh.Dao.UserDaoImp.UserDaoImp;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class userService {
    public  void save(){
        ClassPathXmlApplicationContext userDao = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao1 = (UserDaoImp)userDao.getBean("userDao");
        userDao1.save()
    }
}

Spring的配置文件：
將userService和userDao的建立權交給Spring

<bean id="userDao" class="com.pjh.Dao.UserDaoImp.UserDaoImp"></bean>
<bean id="userService" class="com.pjh.Dao.service.userService"></bean>

主函數代碼
從容器中獲取userService進行操做

package com.pjh.Dao.Demo;
import com.pjh.Dao.UserDaoImp.UserDaoImp;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class demo3 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //獲取第二個Bean對象
        UserDaoImp userDaoImp =(UserDaoImp) classPathXmlApplicationContext.getBean("userService");
        //調用save方法
        userDaoImp.save();
    }
}

對上述案例的依賴注入的分析
當前作法是在容器的外部獲取userImp和userDao來在程序中進行結合

最終的目的：
由於UserService和UserDao都在Sprin容器內部，因此能夠在Spring容器中，將UserDao設置到userService內部

那麼咱們應該如何操做才能在配置文件將UserDao設置到userService內部呢？這無外乎就是使用1.set方法2.構造方兩種方式，下面咱們來逐一講解

**

1.set方法注入

**

在Userservice中添加setUserDa方法

package com.pjh.Dao.service;
import com.pjh.Dao.UserDao;
public class UserService {
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public  void save(){
        userDao.save();
    }
}

在Spring容器中調用set方法經行注入
配置配置文件的方法1

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
        <!--核心配置部分-->
   <bean id="userDao" class="com.pjh.Dao.UserDaoImp.UserDaoImp"></bean>
    <bean id="userService" class="com.pjh.Dao.service.UserService">
    <property name="userDao" ref="userDao"></property>**
</bean>
        </beans>

配置配置文件的方2
使用P命名空間，其本質上也是set注入，不過比上面的方法更加簡單，體如今配置文件中
首先咱們要先引入P命名空間

xmlns:p="http://www.springframework.org/schema/p"

其次咱們要修改注入方式

<bean id="userService" class="com.pjh.Dao.service.UserService" p:userDao-ref="userDao">

整個配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
 <!--核心配置部分-->
  <bean id="userDao" class="com.pjh.Dao.UserDaoImp.UserDaoImp"></bean>
    <bean id="userService" class="com.pjh.Dao.service.UserService" p:userDao-ref="userDao">
</bean>
        </beans>

這裏的name和ref雖然是同名的，可是name指userDao是UserService中的參數，UserService中有一個UserDao類型的名叫userDao的參數，ref則是當前的這個xml文件中名叫userDao的Bean，用於傳入UserService中

2.使用構造方法進行注入

方法1
建立有參構造便可

package com.pjh.Dao.service;
import com.pjh.Dao.UserDao;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class UserService {
    public  void save(){
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //獲取第二個Bean對象
        UserDao userService=(UserDao) classPathXmlApplicationContext.getBean("userDao");
        //調用save方法
        userService.save();
    }
}

方法二

配置Spring容器調用有參構造時經行注入

首先要在UserService中設置有參構造

package com.pjh.Dao.service;
import com.pjh.Dao.UserDao;
public class UserService {
    private UserDao userDao;
    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }
    public  void save(){
        //調用save方法
        userDao.save();
    }
}

其次要更改Spring配置文件中的代碼

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
 <!--核心配置部分-->
  <bean id="userDao" class="com.pjh.Dao.UserDaoImp.UserDaoImp"></bean>
    <bean id="userService" class="com.pjh.Dao.service.UserService" >
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>
        </beans>

這裏的name和ref雖然是同名的，可是name指userDao是UserService中的參數，UserService中有一個UserDao類型的名叫userDao的參數，ref則是當前的這個xml文件中名叫userDao的Bean，用於傳入UserService中

<bean id="userService" class="com.pjh.Dao.service.UserService" >
 <constructor-arg name="userDao" ref="userDao"></constructor-arg>

**

普通數據類型和集合的注入

**

上面的數據類型都是注入的引用Bean，除了引用數據類型，集合，普通數據類型等均可以進行注入
注入的三種數據類型
普通數據類型
引用數據類型
集合數據類型

引用數據類型咱們在上面已經敘述過了，接下來咱們來說講普通數據類型和集合的注入

普通數據類型和集合
1.普通數據類型注入
示例：往UserDaoImp類中注入age 與name

package com.pjh.Dao.UserDaoImp;
import com.pjh.Dao.UserDao;
public class UserDaoImp  implements  UserDao{
    private  int age;
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void save() {
        System.out.println(name+":"+age);
    }
}

spring配置文件中的代碼

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
 <!--核心配置部分-->
  <bean id="userDao" class="com.pjh.Dao.UserDaoImp.UserDaoImp">
      <!--注入age-->
      <property name="age" value="14"></property>
      <!--注入name-->
     <property name="name" value="Mike"></property>
  </bean>

        </beans>

2.集合數據類型List 注入

示例：往UserDaoImp類中注入intlist

package com.pjh.Dao.UserDaoImp;
import com.pjh.Dao.UserDao;
import java.util.List;
public class UserDaoImp  implements  UserDao{
    private List<Integer> intlist;
    public void setIntlist(List<Integer> intlist) {
        this.intlist = intlist;
    }
    public void save() {
        System.out.println(intlist);
    }
}

Spring的配置文件代碼

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
 <!--核心配置部分-->
  <bean id="userDao" class="com.pjh.Dao.UserDaoImp.UserDaoImp">
      <!--注入集合-->
      <property name="intlist">
          <list>
              <value>1</value>
              <value>2</value>
              <value>3</value>
          </list>
      </property>
  </bean>
        </beans>

3.集合數據類型List<引用數據類型> 注入
這裏的引用數據類型我用一個簡單的User類代替，user類代碼以下

package com.pjh.Dao.UserDaoImp;
public class User {
    private  int age;
    private  String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

UserDaoImp中的代碼

package com.pjh.Dao.UserDaoImp;
import com.pjh.Dao.UserDao;
import java.util.List;
public class UserDaoImp  implements  UserDao{
    private List<User> userslist;
    public void setUserslist(List<User> userslist) {
        this.userslist = userslist;
    }
    public void save() {
        System.out.println(userslist);
    }
}

Spring核心配置文件中的代碼

<!--核心配置部分-->
    <!--建立第一個bean對象-->
    <bean id="user1" class="com.pjh.Dao.UserDaoImp.User">
        <property name="name" value="zhangsna"></property>
        <property name="age" value="1"></property>
    </bean>
    <!--建立第二個bean對象-->
    <bean id="user2" class="com.pjh.Dao.UserDaoImp.User">
        <property name="name" value="lisi"></property>
        <property name="age" value="2"></property>
    </bean>
  <bean id="userDao" class="com.pjh.Dao.UserDaoImp.UserDaoImp">
      <!--注入集合-->
    <property name="userslist">
        <list>
            <ref bean="user1"></ref>
            <ref bean="user2"></ref>
        </list>
    </property>
  </bean>

4.集合數據類型 Map<String，引用數據類型>的注入

這裏的引用數據類型我用一個簡單的User類代替，user類代碼以下

package com.pjh.Dao.UserDaoImp;
public class User {
    private  int age;
    private  String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

UserDaoImp中的代碼

package com.pjh.Dao.UserDaoImp;
import com.pjh.Dao.UserDao;
import java.util.Map;
public class UserDaoImp  implements  UserDao{
    private Map<String,User> usersMap;
    public void setUsersMap(Map<String, User> usersMap) {
        this.usersMap = usersMap;
    }

    public void save() {
        System.out.println(usersMap);
    }
}

Spring配置文件中的代碼

<!--核心配置部分-->
    <!--建立第一個bean對象-->
    <bean id="user1" class="com.pjh.Dao.UserDaoImp.User">
        <property name="name" value="zhangsna"></property>
        <property name="age" value="1"></property>
    </bean>
    <!--建立第二個bean對象-->
    <bean id="user2" class="com.pjh.Dao.UserDaoImp.User">
        <property name="name" value="lisi"></property>
        <property name="age" value="2"></property>
    </bean>
  <bean id="userDao" class="com.pjh.Dao.UserDaoImp.UserDaoImp">
      <!--注入集合-->
    <property name="usersMap">
        <map>
           <entry key="user1" value-ref="user1"></entry>
            <entry key="user2" value-ref="user2"></entry>
        </map>
    </property>
  </bean>

5.集合數據類型Properties的注入

UserDaoImp中的代碼

package com.pjh.Dao.UserDaoImp;
import com.pjh.Dao.UserDao;
import java.util.Map;
import java.util.Properties;

public class UserDaoImp  implements  UserDao{
    private Properties properties;

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void save() {
        System.out.println(properties);
    }
}

Spring配置文件中的代碼

<!--核心配置部分-->
    <!--建立第一個bean對象-->
    <bean id="user1" class="com.pjh.Dao.UserDaoImp.User">
        <property name="name" value="zhangsna"></property>
        <property name="age" value="1"></property>
    </bean>
    <!--建立第二個bean對象-->
    <bean id="user2" class="com.pjh.Dao.UserDaoImp.User">
        <property name="name" value="lisi"></property>
        <property name="age" value="2"></property>
    </bean>
  <bean id="userDao" class="com.pjh.Dao.UserDaoImp.UserDaoImp">
      <!--注入集合-->
    <property name="properties">
       <props>
           <prop key="user1">aaa</prop>
           <prop key="user2">bbb</prop>
       </props>
    </property>
  </bean>

引入其餘配置文件（分模塊開發）

咱們的上面的只是一個小案例因此只用了一個配置文件，可是咱們之後若是開發一個大項目的時候，spring的配置文件很繁雜並且體積大，咱們能夠將配置文件按照一個個開發模塊拆解到其餘的配置文件中，這樣利於咱們的管理，在spring的主配置文件中經過import進行加載

<import resource="applicationContext-xxx.xml"></import>

配置文件標籤的小總結

<bean>標籤
    id屬性:在容器中Bean實例的惟一標識，不容許重複
    class屬性:要實例化的Bean的全限定名
    scope屬性:Bean的做用範圍，經常使用是Singleton(默認)和prototype
    <property>標籤：屬性注入
        name屬性：屬性名稱
        value屬性：注入的普通屬性值
        ref屬性：注入的對象引用值
        <list>標籤
        <map>標籤
        <properties>標籤
    <constructor-arg>標籤
<import>標籤:導入其餘的Spring的分文件

ApplicationContext的繼承體

applicationContext：接口類型，表明應用上下文，經過其實例得到Spring容器中的Bean對象

Applicationj的實現類

1）ClassPathXmlApplicationContext 
      它是從類的根路徑下加載配置文件 推薦使用這種
2）FileSystemXmlApplicationContext 
      它是從磁盤路徑上加載配置文件，配置文件能夠在磁盤的任意位置。
3）AnnotationConfigApplicationContext
      當使用註解配置容器對象時，須要使用此類來建立 spring 容器。它用來讀取註解。

以上就是Spring配置文件的詳細教程，寫了好幾個小時，屬實不易，在肝文過程當中也碰到了許多錯誤，也都一一修正，文章也儘可能使用圖文的形式來呈現，利於讀者理解，肝做不易，以爲有幫助的還請點贊關注，我會給你們帶來更多的文章，知識點