java Spring系列之 組態檔的操作 +Bean的生命周期+不同資料型別的注入簡析+注入的原理詳解+組態檔中不同標簽體的使用方式

Spring系列之 組態檔的操作

寫在文章前面：
本文帶大家掌握Spring組態檔的基礎操作以及帶領大家理清依賴注入的概念，本文涉及內容廣泛，如果各位讀者耐心看完，應該會對自身有一個提升

Spring組態檔的作用

Spring組態檔是用于Spring工廠進行Bean生產，依賴關系注入，Bean實體分發的圖紙，他類似于人類的大腦，我們必須掌握這張圖紙的使用方法，才能進行相關的操作，靈活運用這張圖紙準確的表達自己的意圖，運籌帷幄，決勝千里，Spring的組態檔是一個或多個標準的xml檔案，applicationContext.xml檔案是默認的組態檔，當容器啟動找不到組態檔時，就會嘗試加載這個組態檔，
未使用Spring前程式的開發步驟

這里以配置一個User類為例，UserImp為介面，User為其實作類，我們本來使用一個 UserImp介面去接收一個User的實作物件，本來是通過以下代碼：

 UserImp user=new User（）

流程圖：

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

使用Spring框架操作

這里以配置一個User類為例，UserImp為介面，User為其實作類，我們使用一個 UserImp介面去接受一個User的實作物件，代碼如下：

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

那么其內部的原理是怎么樣的呢？要實作解耦，基本上都是使用配置文的方式，Spring自然也不例外，下面通過一張流程圖解來帶領大家更好的領會

流程圖解：

Spring入門實作步驟

1.在pom.xml中匯入Spring框架的坐標
2.創建Bean
3.創建applicationContext.xml
4.在xml中經行配置
5.創建ApplicationContext物件getBean

實作一個簡單的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=https://www.cnblogs.com/pjhaymy/p/"14">
      
     
  

        

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=https://www.cnblogs.com/pjhaymy/p/"zhangsna">
        
    
    
    
        
        
    
  
      
    
        
            
            
        
    
  

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=https://www.cnblogs.com/pjhaymy/p/"zhangsna">
        
    
    
    
        
        
    
  
      
    
        
    
  

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=https://www.cnblogs.com/pjhaymy/p/"zhangsna">
        
    
    
    
        
        
    
  
      
    
       
           aaa
           bbb
       
    
  

引入其他組態檔（分模塊開發）

我們的上面的只是一個小案例所以只用了一個組態檔，但是我們以后如果開發一個大專案的時候，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組態檔的詳細教程，寫了好幾個小時，屬實不易，在肝文程序中也碰到了許多錯誤，也都一一修正，文章也盡量使用圖文的形式來呈現，利于讀者理解，肝作不易，覺得有幫助的還請點贊關注，我會給大家帶來更多的文章，知識點

標籤：面向對象

上一篇：華為 PPPoE

下一篇：PHP面試技巧 之 職場暗語知多少？！