日志

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

 来源    2020-09-16    0  

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>
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!!");
    }
}

运行结果
成功执行

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

相关文章
java – Spring autowire一个存根服务 – 重复bean
问答好.我们需要动态地@Autowire一个不同的Web服务(最好通过在网络服务器上切换JNDI设置),我对如何做到这一点感到茫然.这就是我接近问题的方式.. 两个包: com.mycomp.servic ...
java – Spring:如何在创建主bean之后初始化相关的lazy bean
问答我有懒惰初始化bean的代码: @Component @Lazy class Resource {...} @Component @Lazy @CustomProcessor class Resour ...
1
java – 如何将Spring Bean的生命周期与webapps的生命周期联系起来?
问答我想创建一个具有start()和stop()方法的bean. 当webapp的上下文处于活动状态时,在Spring的运行时启动期间会调用start().取消部署或停止webapp时,将调用stop() ...
1
java – spring:通过读取另一个bean的属性来设置一个bean的属性?
问答通过阅读另一个bean的属性可以设置一个bean的属性吗?例如,假设我有: class A { void setList(List list); } class B { List getList(); ...
1
java – Spring 4 MVC – Rest服务 – 在bean中使用默认值
问答我正在使用Spring 4.1.4并实现一个简单的REST服务.我有一个POST方法,它获取一个Person对象作为请求. @ResponseStatus(value = HttpStatus.CRE ...
1
java – Spring DI – 不要初始化所有依赖bean
问答我有一个ServiceA,它依赖于ServiceB. serviceB来自一个带有lazy-init = true的spring bean文件,也就是说,当我要求那个bean时,我只希望初始化serv ...
1
java – Spring无法在servlet-context和contextConfigLocation bean之间看到bean
问答我有一个spring mvc项目设置如下: <servlet> <servlet-name>appServlet</servlet-name> <servle ...
2
java – Spring 3:禁用spel评估bean属性值?
问答我们正在将我们的应用程序从Spring 2.5更新到3.0,并且我们遇到了新的SpEL评估bean属性的问题. 我们一直在一个模块中使用内部模板语法,遗憾的是它使用与SpEL相同的"#{xy ...
1
java – spring如何使用HTTP作用域绑定bean作用域,如请求,会话等
问答我们有春天的豆子: @Component @Scope(value="session") public class MyBean { // ... } 内部spring如何绑定HT ...
1
java – Spring Boot:由于缺少EmbeddedServletContainerFactory bean,无法启动EmbeddedWebApplicationContext
问答我完全是新的Spring,并开始做这个网站的官方指南: https://spring.io/guides 我想做这个指南: https://spring.io/guides/gs/scheduling ...
1
java – Spring Hateoas @EnableEntityLinks不提供EntityLinks bean(NoSuchBeanDefinitionException)
问答我有一个使用Spring HATEOAS的Spring Boot应用程序,它启用了@EnableEntityLinks.该应用程序有一个mvc控制器,包含一个字段@Autowired EntityLi ...
1
java – Spring事务管理:无法解析bean’transactionManager’的引用
问答我有以下bean配置XML文件(beans.xml): <tx:advice id="txAdvice" transaction-manager="transact ...
1
java – Spring – 登录后执行一些操作
问答用户登录成功后,我需要在DB中存储实际日期.怎么做 ?过滤器,处理器还是什么?需要帮忙.:: public class AuthenticationSuccessHandlerImpl extends ...
Java框架spring 学习笔记(三):Bean 的生命周期
日志当一个 bean 被实例化时,它可能需要执行一些初始化使它转换成可用状态.当bean不再需要,并且从容器中移除时,需要做一些清除工作.为了定义安装和拆卸一个 bean,我们只要声明init-metho ...
1
JAVA Spring 简单的配置和操作 ( 创建实体类, 配置XML文件, 调试 )
日志< 1 > 实体类 Person package java_spring.modle; /** * 一个实体类( Person ) */ public class Person { pri ...
1
java spring boot 导出/下载文本文件操作(包含写文本文件)
日志内容简介 本文主要内容为使用java把内容写入文本文件,并实现下载/导出的功能. 实现步骤 1. controller层 @ResponseBody @RequestMapping(value = & ...
1
Spring原理系列一:Spring Bean的生命周期
日志一.前言 在日常开发中,spring极大地简化了我们日常的开发工作.spring为我们管理好bean, 我们拿来就用.但是我们不应该只停留在使用层面,深究spring内部的原理,才能在使用时融汇贯通. ...
1
Spring Bean的生命周期
日志 面试的时候问到了这个问题,很长时间没接触spring了,回答的不好, 今天总结下: 实例化bean对象(通过构造方法或者工厂方法)设置对象属性(setter等)(依赖注入) 如果Bean实现了Bea ...
2
Spring Bean的生命周期(非常详细)
日志Spring作为当前Java最流行.最强大的轻量级框架,受到了程序员的热烈欢迎.准确的了解Spring Bean的生命周期是非常必要的.我们通常使用ApplicationContext作为Spring ...
1
深究Spring中Bean的生命周期
日志前言 这其实是一道面试题,是我在面试百度的时候被问到的,当时没有答出来(因为自己真的很菜),后来在网上寻找答案,看到也是一头雾水,直到看到了<Spring in action>这本书,书上 ...
1