spring bea 修改bean属性 spring配置文件bean属性

1.Spring Bean是什么？

作为 Spring 核心机制的依赖注入，改变了传统的编程习惯，对组件的实例化不再由应用程序完成，转而交由 Spring 容器完成，在需要时注入应用程序中，从而对组件之间依赖关系进行了解耦。这一切都离不开 Spring 配置文件中使用的<bean>元素。

Spring 容器可以被看作一个大工厂，而 Spring 容器中的Bean就相当于该工厂的产品。如果希望这个大工厂能够生产和管理Bean，这时则需要告诉容器需要哪些Bean，以及需要以何种方式将这些 Bean装配到一起。

Spring 配置文件支持两种不同的格式，分别是 XML文件格式和 Properties文件格式。

通常情况下，Spring 会以 XML 文件格式作为 Spring 的配置文件，这种配置方式通过 XML 文件注册并管理 Bean之间的依赖关系。

XML 格式配置文件的根元素是 <beans>，该元素包含了多个 <bean>子元素，每一个<bean> 子元素定义了一个 Bean，并描述了该 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">
        
</beans>

在<beans></beans>标签内可以配置IOC容器需要控制的对象（还有各种外部资源）。

2.Spring Bean的常用属性

<bean>元素的常用属性表

属性名称	描述
id	是一个 Bean 的唯一标识符，Spring 容器对 Bean 的配置和管理都通过该属性完成
name	Spring 容器同样可以通过此属性对容器中的 Bean 进行配置和管理，name 属性中可以为 Bean 指定多个名称，每个名称之间用逗号或分号隔开
class	该属性指定了 Bean 的具体实现类，它必须是一个完整的类名，使用类的全限定名
scope	用于设定 Bean 实例的作用域，其属性值有 singleton（单例）、prototype（原型）、request、session 和 global Session。其默认值是 singleton
constructor-arg	<bean>元素的子元素，可以使用此元素传入构造参数进行实例化。该元素的 index 属性指定构造参数的序号（从 0 开始），type 属性指定构造参数的类型
property	<bean>元素的子元素，用于调用 Bean 实例中的 Set 方法完成属性赋值，从而完成依赖注入。该元素的 name 属性指定 Bean 实例中的相应属性名
ref	<property> 和 <constructor-arg> 等元素的子元素，该元素中的 bean 属性用于指定对 Bean 工厂中某个 Bean 实例的引用
value	<property> 和 <constractor-arg> 等元素的子元素，用于直接指定一个常量值
list	用于封装 List 或数组类型的依赖注入
set	用于封装 Set 类型属性的依赖注入
map	用于封装 Map 类型属性的依赖注入
entry	<map> 元素的子元素，用于设置一个键值对。其 key 属性指定字符串类型的键值，ref 或 value 子元素指定其值

3.Spring Bean的三种注入方法

注意：需要以下基础包

提供一个下载地址：百度云 提取码：0we8

3.1 构造函数注入（最基础的方法）

1.目录：config1.xml(Spring bean的配置文件)、InstanceTest1(测试主函数)、Person1实体类

2.代码：

Person1

package com.cheng.spring.constructor;

public class Person1 {
    String name;
    String password;

    //有参构造函数
    public Person1(String name, String password) {
        this.name = name;
        this.password = password;
    }
    //无参构造函数
    public Person1(){}

    public String getName() {
        return name;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

config1.xml(Spring bean的配置文件)，以下选一种方式

• 第一种方法：通过无参构造函数构建对象，并通过属性的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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 装配Java类，每个bean就是指一个Java类 -->
    <!-- 第一种方法 -->
    <bean id="person1" class="com.cheng.spring.constructor.Person1">
        <!-- 使用property为实例的属性赋值 -->
        <property name="name" value="王者农药"/>
        <property name="password" value="123"/>
    </bean>
</beans>

• 第二种方法：通过有参构造函数对参数进行赋值

<?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">
    <!-- 装配Java类，每个bean就是指一个Java类 -->
    <!-- 第二种方法 -->
    <bean id="person1" class="com.cheng.spring.constructor.Person1">
        <!-- 使用constructor-arg为实例的属性赋值 -->
        <constructor-arg index="0" value="王者农药"/>
        <constructor-arg index="1" value="123"/>
    </bean>
</beans>

InstanceTest1(测试主函数)

package com.cheng.spring.constructor;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class InstanceTest1 {
    public static void main(String[] args) {
            // 定义Spring配置文件的路径
            String xmlPath = "com/cheng/spring/constructor/config1.xml";
            // 初始化Spring容器，加载配置文件，并对bean进行实例化
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
            // 通过容器获取id为person1的实例
            Person1 person1=(Person1)applicationContext.getBean("person1");
            System.out.println("person1的name="+person1.name+",person1的pass="+person1.password);
    }
}

3.运行InstanceTest1

通过Spring bean对需要的id进行实例化并通过无参构造函数/有参构造函数来对属性进行赋值，拿到最终的实例对象。

3.2 静态工厂方式实例化

1.目录：config2.xml(Spring bean的配置文件)、InstanceTest2(测试主函数)、Person2(实体类)、MyBeanFactory(静态工厂类)

2.代码：

Person2

package com.cheng.spring.static_factory;

public class Person2 {
}

MyBeanFactory(静态工厂类)

package com.cheng.spring.static_factory;

public class MyBeanFactory {
    // 创建Bean实例的静态工厂方法
    public static Person2 createBean() {
        return new Person2();
    }
}

config2.xml(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">
    <!-- factory-method 属性用于告诉 Spring 容器调用工厂类中的 createBean() 方法获取 Bean 的实例 -->
    <bean id="person2" class="com.cheng.spring.static_factory.MyBeanFactory" factory-method="createBean" />
</beans>

InstanceTest2(测试主函数)

package com.cheng.spring.static_factory;


import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class InstanceTest2 {
    public static void main(String[] args) {
        // 定义Spring配置文件的路径
        String xmlPath = "com/cheng/spring/static_factory/config2.xml";
        // 初始化Spring容器，加载配置文件，并对bean进行实例化
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        // 通过容器获取id为person2实例
        System.out.println(applicationContext.getBean("person2"));
    }
}

3.运行InstanceTest2

通过配置静态工厂类的bean，使用静态工厂类中的方法来实例化Person2。

3.3 实例工厂方式实例化

1.目录：config3.xml(Spring bean的配置文件)、InstanceTest3(测试主函数)、Person3(实体类)、MyBeanFactory(工厂类)

2.代码：

Person3

package com.cheng.spring.factory;

public class Person3 {
}

MyBeanFactory(工厂类)

package com.cheng.spring.factory;

public class MyBeanFactory {
    public MyBeanFactory() {
        System.out.println("person3工厂实例化中");
    }
    // 创建Bean的方法
    public Person3 createBean() {
        return new Person3();
    }
}

config3.xml(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="myBeanFactory" class="com.cheng.spring.factory.MyBeanFactory" />
    <!-- factory-bean属性指定一个实例工厂，factory-method属性确定使用工厂中的哪个方法 -->
    <bean id="person3" factory-bean="myBeanFactory" factory-method="createBean" />
</beans>

InstanceTest3(测试主函数)

package com.cheng.spring.factory;


import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class InstanceTest3 {
    public static void main(String[] args) {
        // 定义Spring配置文件的路径
        String xmlPath = "com/cheng/spring/factory/config3.xml";
        // 初始化Spring容器，加载配置文件，并对bean进行实例化
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        // 通过容器获取id为person3实例
        System.out.println(applicationContext.getBean("person3"));
    }
}

3.运行InstanceTest3

通过配置工厂类的bean，先实例化工厂类，再使用工程类中的方法来实例化Person3。

4.总结

Spring容器通过对xml中<beans></beans>内容进行管理，来实现对各个对象的依赖注入；
有三种注入的方法：构造函数注入、静态工厂注入、实例工厂注入。

如果对你有所帮助，请点个赞支持一下，谢谢~