java Spring系列之 配置文件的操作 +Bean的生命周期+不同数据类型的注入简析+注入的原理详解+配置文件中不同标签体的使用方式

2022-12-17 07:47:31

Spring系列之 配置文件的操作

写在文章前面：

本文带大家掌握Spring配置文件的基础操作以及带领大家理清依赖注入的概念，本文涉及内容广泛，如果各位读者耐心看完，应该会对自身有一个提升

java Spring系列之 配置文件的操作 +Bean的生命周期+不同数据类型的注入简析+注入的原理详解+配置文件中不同标签体的使用方式

Spring配置文件的作用

Spring配置文件是用于Spring工厂进行Bean生产，依赖关系注入，Bean实例分发的图纸，他类似于人类的大脑，我们必须掌握这张图纸的使用方法，才能进行相关的操作，灵活运用这张图纸准确的表达自己的意图。运筹帷幄，决胜千里。Spring的配置文件是一个或多个标准的xml文档，applicationContext.xml文件是默认的配置文件，当容器启动找不到配置文件时，就会尝试加载这个配置文件。

未使用Spring前程序的开发步骤

这里以配置一个User类为例，UserImp为接口，User为其实现类，我们本来使用一个 UserImp接口去接收一个User的实现对象，本来是通过以下代码：

 UserImp user=new User（）

流程图：

java Spring系列之 配置文件的操作 +Bean的生命周期+不同数据类型的注入简析+注入的原理详解+配置文件中不同标签体的使用方式

使用上述方法的缺点：代码的耦合度过高

使用Spring框架操作

这里以配置一个User类为例，UserImp为接口，User为其实现类，我们使用一个 UserImp接口去接受一个User的实现对象，代码如下：

UserDao user=Spring客户端.getBean（id标识符）

那么其内部的原理是怎么样的呢？要实现解耦，基本上都是使用配置文的方式，Spring自然也不例外，下面通过一张流程图解来带领大家更好的领会

流程图解：

java Spring系列之 配置文件的操作 +Bean的生命周期+不同数据类型的注入简析+注入的原理详解+配置文件中不同标签体的使用方式

Spring入门实现步骤

1.在pom.xml中导入Spring框架的坐标

2.创建Bean

3.创建applicationContext.xml

4.在xml中经行配置

5.创建ApplicationContext对象getBean

实现一个简单的Spring案例

项目结构：

java Spring系列之 配置文件的操作 +Bean的生命周期+不同数据类型的注入简析+注入的原理详解+配置文件中不同标签体的使用方式

主函数，使用Spring的API获取Bean实例

存在的文件夹：

java Spring系列之 配置文件的操作 +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

存在的文件夹：

java 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" ></bean>

</beans>

导入Spring开发的基本坐标，在pom.xml配置文件

文件位置

java Spring系列之 配置文件的操作 +Bean的生命周期+不同数据类型的注入简析+注入的原理详解+配置文件中不同标签体的使用方式

代码：

4.0.0

<groupId>com.pjh</groupId>

<artifactId>SpringIOCInit</artifactId>

<version>1.0-SNAPSHOT</version>

org.springframework
spring-context
5.0.3.RELEASE

编写userDaoImp类的相关信息:

package com.pjh.Dao.UserDaoImp;

import com.pjh.Dao.UserDao;

public class UserDaoImp  implements  UserDao{

    public void save() {

        System.out.println("save runing!!");

    }

}

运行结果

成功执行

java Spring系列之 配置文件的操作 +Bean的生命周期+不同数据类型的注入简析+注入的原理详解+配置文件中不同标签体的使用方式

Bean标签介绍与基本属性

3.1 Bean标签的基本配置

用于配置文件交由Spring配置，默认调用无参构造，如果没有无参构造则创建失败

id：Bean实例在Spring中的唯一标识符

class：Bean实例的全限定名称

如果你在某个实现类中复写了有参构造，记得添加无参构造方法，因为你复写了有参构造后，原本的无参构造会消除掉，如果你在这个时候仍然在Spring的配置文件中默认使用无参构造，那么这时候他就会报错

如图

java Spring系列之 配置文件的操作 +Bean的生命周期+不同数据类型的注入简析+注入的原理详解+配置文件中不同标签体的使用方式

3.2Bean的标签范围配置

java Spring系列之 配置文件的操作 +Bean的生命周期+不同数据类型的注入简析+注入的原理详解+配置文件中不同标签体的使用方式

这里讲解一下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);

    }

}

运行结果：

两个对象的地址值一样，说明为同一个对象

java Spring系列之 配置文件的操作 +Bean的生命周期+不同数据类型的注入简析+注入的原理详解+配置文件中不同标签体的使用方式

当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);

    }

}

运行结果：

两个对象的地址值不一样，说明为不对象

java Spring系列之 配置文件的操作 +Bean的生命周期+不同数据类型的注入简析+注入的原理详解+配置文件中不同标签体的使用方式

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);

    }

}

运行结果：

构造方法被调用了两次，说明创建了两个对象

方法被调用的次序：构造方法->初始化方法

java Spring系列之 配置文件的操作 +Bean的生命周期+不同数据类型的注入简析+注入的原理详解+配置文件中不同标签体的使用方式

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);

    }

}

运行结果

构造方法与初始化方法均只被调用了一次，故为同一个对象

java Spring系列之 配置文件的操作 +Bean的生命周期+不同数据类型的注入简析+注入的原理详解+配置文件中不同标签体的使用方式

**

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来在程序中进行结合

java Spring系列之 配置文件的操作 +Bean的生命周期+不同数据类型的注入简析+注入的原理详解+配置文件中不同标签体的使用方式

最终的目的：

因为UserService和UserDao都在Sprin容器内部，所以可以在Spring容器中，将UserDao设置到userService内部

java Spring系列之 配置文件的操作 +Bean的生命周期+不同数据类型的注入简析+注入的原理详解+配置文件中不同标签体的使用方式

那么我们应该如何操作才能在配置文件将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对象

java Spring系列之 配置文件的操作 +Bean的生命周期+不同数据类型的注入简析+注入的原理详解+配置文件中不同标签体的使用方式

Applicationj的实现类

1）ClassPathXmlApplicationContext

      它是从类的根路径下加载配置文件 推荐使用这种

2）FileSystemXmlApplicationContext

      它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。

3）AnnotationConfigApplicationContext

      当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

以上就是Spring配置文件的详细教程，写了好几个小时，属实不易，在肝文过程中也碰到了许多错误，也都一一修正，文章也尽量使用图文的形式来呈现，利于读者理解，肝作不易，觉得有帮助的还请点赞关注，我会给大家带来更多的文章，知识点

java Spring系列之 配置文件的操作 +Bean的生命周期+不同数据类型的注入简析+注入的原理详解+配置文件中不同标签体的使用方式

上一篇：Keepalived 实现双机热备


下一篇：linux 下安装编译配置 QT