Spring核心之IOC--配置文件开发

于 2021-06-05 15:22:47 发布
阅读量183 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 企业级开发框架SSM 文章标签： spring java ioc xml
原文链接：www.lagou.com
本文详细介绍了Spring框架中Bean的配置，包括基本的Bean标签配置，如id和class属性，以及作用域(scope)配置，如singleton和prototype。接着讲解了Bean的生命周期，初始化和销毁方法，以及三种实例化方式：无参构造方法、工厂静态方法和工厂普通方法。此外，文章还深入探讨了依赖注入（DI），包括构造方法、set方法和P命名空间注入，并展示了如何注入普通数据类型和集合数据类型。最后，提到了配置文件模块化和导入其他配置文件的方法，以简化大型项目的配置管理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1. Bean标签基本配置

 

<bean id="" class=""></bean>

 

  • 用于配置对象交由Spring来创建。

 

  • 基本属性：

id：Bean实例在Spring容器中的唯一标识class：Bean的全限定名

 

  • 默认情况下它调用的是类中的 无参构造函数，如果没有无参构造函数则不能创建成功。

2. Bean标签范围配置

<bean id="" class="" scope=""></bean>

scope属性指对象的作用范围，取值如下：

取值范围

说明

singleton

默认值，单例的

prototype

多例的

request

WEB项目中，Spring创建一个Bean的对象，将对象存入到request域中

session

WEB项目中，Spring创建一个Bean的对象，将对象存入到session域中

global session

WEB项目中，应用在Portlet环境，如果没有Portlet环境那么globalSession 相当于 session

  1. 当scope的取值为singleton时

Bean的实例化个数：1个

Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例Bean的生命周期：

对象创建：当应用加载，创建容器时，对象就被创建了对象运行：只要容器在，对象一直活着

对象销毁：当应用卸载，销毁容器时，对象就被销毁了

 

     2.  当scope的取值为prototype时

Bean的实例化个数：多个

Bean的实例化时机：当调用getBean()方法时实例化Bean Bean的生命周期：

对象创建：当使用对象时，创建新的对象实例对象运行：只要对象在使用中，就一直活着

对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

3. Bean生命周期配置

<bean id="" class="" scope="" init-method="" destroy-method=""></bean>

 

  • init-method：指定类中的初始化方法名称

 

  • destroy-method：指定类中销毁方法名称

4.Bean实例化三种方式

  • 无参构造方法实例化
  • 工厂静态方法实例化
  • 工厂普通方法实例化

4.1 无参构造方法实例化

它会根据默认无参构造方法来创建类对象，如果bean中没有默认无参构造函数，将会创建失败

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/>

4.2 工厂静态方法实例化

应用场景

依赖的jar包中有个A类，A类中有个静态方法m1，m1方法的返回值是一个B对象。如果我们频繁使用    B对象，此时我们可以将B对象的创建权交给spring的IOC容器，以后我们在使用B对象时，无需调用A类  中的m1方法，直接从IOC容器获得

package com.lagou.factory;

import com.lagou.dao.IUserDao;
import com.lagou.dao.impl.UserDaoImpl;

public class StaticFactoryBean {


    public static IUserDao createUserDao(){

        return  new UserDaoImpl();
    }



}

<bean id="userDao" class="com.lagou.factory.StaticFactoryBean" factory-method="createUserDao" />

4.3 工厂普通方法实例化

应用场景

依赖的jar包中有个A类，A类中有个普通方法m1，m1方法的返回值是一个B对象。如果我们频繁使用

B对象，

此时我们可以将B对象的创建权交给spring的IOC容器，以后我们在使用B对象时，无需调用A类中的m1  方法，直接从IOC容器获得.

package com.lagou.factory;

import com.lagou.dao.IUserDao;
import com.lagou.dao.impl.UserDaoImpl;

public class DynamicFactoryBean {


    public IUserDao createUserDao(){

        return  new UserDaoImpl();
    }



}

<bean id="dynamicFactoryBean" class="com.lagou.factory.DynamicFactoryBean"/>
<bean id="userDao" factory-bean="dynamicFactoryBean" factory- method="createUserDao"/>

5. Bean依赖注入概述

依赖注入 DI（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现

在编写程序时，通过控制反转，把对象的创建交给了  Spring，但是代码中不可能出现没有依赖的情况。IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。

那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。简单的说，就是通过框架把持久层对象传入业务层，而不用我们自己去获取。

6. Bean依赖注入方式

6.1 构造方法

在UserServiceImpl中创建有参构造

package com.lagou.servlet.impl;

import com.lagou.dao.IUserDao;
import com.lagou.servlet.IUserService;

public class UserSerivceImpl implements IUserService {

    private IUserDao userDao;

    public UserSerivceImpl(IUserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void save() {
        // 调用dao层的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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--xmlns:p="http://www.springframework.org/schema/p" 这行代码属于P命名空间注入方式时要用到的-->
    

   <bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"></bean>

   <!-- 配置UserService-->
    <bean id="userService" class="com.lagou.servlet.impl.UserSerivceImpl">
        <!--标签name的值代表方法中的用于接收注入的成员变量名-->
        <!--采用有参构造方法的方式进行注入-->
         <!--有参构造方法注入方式一-->
        <constructor-arg index="0" type="com.lagou.dao.IUserDao" ref="userDao" />
         <!--有参构造方法注入方式二-->
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
    </bean>


</beans>

6.2 set方法

在UserServiceImpl中创建set方法

package com.lagou.servlet.impl;

import com.lagou.dao.IUserDao;
import com.lagou.servlet.IUserService;

public class UserSerivceImpl implements IUserService {

    private IUserDao userDao;

    public void setUserDao(IUserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void save() {
        // 调用dao层的save方法
        userDao.save();

    }
}

配置Spring容器调用set方法进行注入

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--xmlns:p="http://www.springframework.org/schema/p" 这行代码属于P命名空间注入方式时要用到的-->
    

   <bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"></bean>

   <!-- 配置UserService-->
    <bean id="userService" class="com.lagou.servlet.impl.UserSerivceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>


</beans>

6.3 P命名空间注入

P命名空间注入本质也是set方法注入，但比起上述的set方法注入更加方便，主要体现在配置文件  中，如下：

首先，需要引入P命名空间: 

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

其次，需要修改注入方式：

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.lagou.service.impl.UserServiceImpl" p:userDao-ref="userDao"/>

7. Bean依赖注入的数据类型

上面操作，都是注入Bean对象，除了对象的引用可以注入，普通数据类型和集合都可以在容器中进  行注入。

注入数据的三种数据类型

  1. 普通数据类型
  2. 引用数据类型
  3. 集合数据类型

其中引用数据类型，此处就不再赘述了，之前的操作都是对UserDao对象的引用进行注入的。下面将  以set方法注入为例，演示普通数据类型和集合数据类型的注入。

7.1 注入普通数据类型

package com.lagou.domain;

public class User {

    private String username; //需要注入的普通数据类型
    private Integer age; //需要注入的普通数据类型

    public void setUsername(String username) {
        this.username = username;
    }

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

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

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"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd">


    <!--配置User对象-->
    <bean id="user" class="com.lagou.domain.User">
        <property name="username" value="柳岩"/>
        <property name="age" value="18"/>
    </bean>


   
</beans>

7.2 注入集合数据类型

以下分别介绍：List集合注入、Set集合注入、Array数组注入、Map集合注入、Properties配置注入

package com.lagou.dao.impl;

import com.lagou.dao.IUserDao;

import java.util.*;

public class UserDaoImpl implements IUserDao {

    // 注入普通数据类型
    private String username;
    private Integer age;


    // 注入集合数据类型
    private List<Object> list;
    private Set<Object> set;
    private Object[] array;
    private Map<String,Object> map;
    private Properties properties;
    public void init(){
        System.out.println("初始化方法执行了...");
    }
    public void destory(){
        System.out.println("销毁方法执行了...");
    }


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

    public void setMap(Map<String, Object> map) {
        this.map = map;
    }

    public void setArray(Object[] array) {
        this.array = array;
    }

    public void setSet(Set<Object> set) {
        this.set = set;
    }

    public void setList(List<Object> list) {
        this.list = list;
    }

    public void setUsername(String username) {
        this.username = username;
    }

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

    public void save() {
        System.out.println("list集合：" + list);
        System.out.println("set集合：" + set);
        System.out.println("array数组：" + Arrays.toString(array));
        System.out.println("map集合：" + map);
        System.out.println("properties：" + properties);

        System.out.println("dao被调用了....");
    }
}

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--xmlns:p="http://www.springframework.org/schema/p" 这行代码属于P命名空间注入方式时要用到的-->



    <!--配置UserDao 方式一：无参构造方法进行实例化-->
    <bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl" >
        <!--ref:用于引用数据类型的注入，value是用于普通数据类型的注入-->
        <property name="username" value="子慕"></property>
        <property name="age" value="18"></property>

        <!--进行list集合数据类型的注入-->
        <property name="list">
            <list>
                <value>aaa</value>
                <ref bean="user"></ref>
            </list>
        </property>

        <!--进行set集合数据类型的注入-->
        <property name="set">
            <set>
                <value>bbb</value>
                <ref bean="user"></ref>
            </set>
        </property>

        <!--进行array数组数据类型的注入-->
        <property name="array">
            <array>
                <value>ccc</value>
                <ref bean="user"></ref>
            </array>
        </property>

        <!--进行map集合数据类型的注入-->
        <property name="map">
            <map>
                <entry key="k1" value="ddd"></entry>
                <entry key="k2" value-ref="user"></entry>
            </map>
        </property>

        <!--进行properties数据类型的注入-->
        <property name="properties">
            <props>
                <prop key="k1">v1</prop>
                <prop key="k2">v2</prop>
                <prop key="k3">v3</prop>
            </props>
        </property>

    </bean>

    
</beans>

8. 配置文件模块化

实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分  配置拆解到其他配置文件中，也就是所谓的配置文件模块化。

（1）并列的多个配置文件

ApplicationContext act = new ClassPathXmlApplicationContext("beans1.xml","beans2.xml","...");

（2）主从配置文件

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

注意：

  • 同一个xml中不能出现相同名称的bean,如果出现会报错
  • 多个xml如果出现相同名称的bean，不会报错，但是后加载的会覆盖前加载的bean

9. 知识总结

Spring的重点配置

<bean>标签：创建对象并放到spring的IOC容器

id属性:在容器中Bean实例的唯一标识，不允许重复class属性:要实例化的Bean的全限定名

scope属性:Bean的作用范围，常用是Singleton(默认)和prototype

 

<constructor-arg>标签：属性注入name属性：属性名称

value属性：注入的普通属性值ref属性：注入的对象引用值

 

<property>标签：属性注入name属性：属性名称

value属性：注入的普通属性值ref属性：注入的对象引用值

<list>

<set>

<array>

<map>

<props>

 

<import>标签:导入其他的Spring的分文件

 

节选自拉钩教育JAVA系列课程

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值