Spring框架学了不会应用？一篇文章让你深度了解SpringBean的配置

本文链接：https://blog.csdn.net/m0_73613534/article/details/129160368

基于XML的Spring的应用

SpringBean的配置

Spring开发中主要是对Bean的配置，Bean的常用配置一览如下：

<bean id="" class="">	Bean的id和全限定名配置
<bean name="">	通过name设置Bean的别名，通过别名也能直接获取到Bean实例
<bean scope="">	Bean的作用范围，BeanFactory作为容器时取值singleton和prototype
<bean lazy-init="">	Bean的实例化时机，是否延迟加载。BeanFactory作为容器时无效
<bean init-method="">	Bean实例化后自动执行的初始化方法，method指定方法名
<bean destroy-method="">	Bean实例销毁前的方法，method指定方法名
<bean autowire="byType">	设置自动注入模式，常用的有按照类型byType，按照名字byName
<bean factory-bean="" factory-method=""/>	指定哪个工厂Bean的哪个方法完成Bean的创建

Bean的基础配置

id是确定对象的唯一标识符，getbean方法获取的是id将其实例化，即获取beanName

<bean id="userDao" class="com.itlzxr.service.userServiceImpl"/>

applicationContext.getBean("userService")

不设置id，则获取的Bean实例对象的全限定名，将其存入spring容器（singltonObject单例池）中

key为id名，即userDao，value为userDao的实例对象userDaoImpl

applicationContext.getBean("com.itlzxr.service.userServiceImpl")

Bean别名配置

Bean可设置多个别名，根据别名也可获取Bean对象

<bean id="userService" name="aaa,bbb,ccc" class="com.itlzxr.service.userServiceImpl"/>

此时，Bean具有多个别名，别名均可获取实例对象

applicationContext.getBean("userService")
applicationContext.getBean("aaa")
applicationContext.getBean("bbb")
applicationContext.getBean("ccc")

不配置id，配置了name，则默认情况下别名第一个为beanName

<bean name="aaa,bbb,ccc" class="com.itlzxr.service.userServiceImpl"/>

applicationContext.getBean("aaa")

一般情况下不配置别名，大部分情况配置id即可

Bean的作用范围

默认情况下，简单的spring环境下，Bean的作用范围有两个，singleton和prototype

注：如果在MVC环境下，作用范围则会变为singleton、prototype、session、request

singleton：单例，Bean默认为单例作用范围，spring容器创建时获取实例化对象，每次获取的都是同一个实例对象，并将其存入singletoObje池中，getBean时则从单例池中获取

prototype：原型，只有当执行getBean方法时才会获取实例化对象，getBean创建的是新的Bean实例对象，每次获取的对象都不是同一个对象，且不会被存入singletonObject池中，userDao的信息被存储到beanDefinitionMap中

<bean name="aaa,bbb,ccc" class="com.itlzxr.service.userServiceImpl" scope="singleton"/>

Bean的延迟加载

一般情况下，单例作用范围，spring容器加载完成后就会立刻获取实例化对象，如果配置lazy-init="true"，则不会立刻创建bean实例对象，等到执行getBean方法时创建实例化对象，然后将其存入单例池，后续获取该对象时从单例池中获取，本质上Bean仍为单例

<bean id="userService" name="aaa,bbb,ccc" class="com.itlzxr.service.userServiceImpl" lazy-init="true"/>

Bean初始化方法和销毁方法的配置

<bean id="userService" class="com.itlzxr.service.userServiceImpl" init-method="init" destory-medthod="destory"/>

Bean在被实例化后，可以执行指定的初始化方法完成一些初始化的操作，Bean在销毁之前也可以执行指定的销毁

方法完成一些操作，初始化方法名称和销毁方法名称通过

public class UserServiceImpl implements UserService {
	public UserDaoImpl() { 
        System.out.println("UserServiceImpl创建了..."); 
    }
	public void init(){ 
        System.out.println("初始化方法..."); 
    }
	public void destroy(){ 
        System.out.println("销毁方法..."); 
    }
}

注：Bean的销毁和Bean的销毁方法的调用不是同一个概念，Bean的销毁是指spring容器已被销毁，其维护的Bean对象也被销毁，而有时spring容器已经被销毁但spring也未执行到调用销毁方法的步骤

扩展：除此之外，我们还可以通过实现 InitializingBean 接口，完成一些Bean的初始化操作

public class UserDaoImpl implements UserDao, InitializingBean {
	public UserDaoImpl() {System.out.println("UserDaoImpl创建了...");}
	public void init(){System.out.println("初始化方法...");}
	public void destroy(){System.out.println("销毁方法...");}
	//执行时机早于init-method配置的方法
	public void afterPropertiesSet() throws Exception {
		System.out.println("InitializingBean..."); 
	}
}

Bean的实例化配置

Spring的实例化方式主要如下两种：

构造方式实例化：底层通过构造方法对Bean进行实例化

工厂方式实例化：底层通过调用自定义的工厂方法对Bean进行实例化

构造方式实例化Bean又分为无参构造方法实例化和有参构造方法实例化，Spring中配置的几乎都是无参构造该方式

//有参构造方法
public UserDaoImpl(String name){
}

有参构造在实例化Bean时，需要参数的注入，通过标签，嵌入在标签内部提供构造参数

<bean id="userService" class="com.itlzxr.service.impl.UserServiceImpl">
	<constructor-arg name="name" value="lzxr"/>
</bean>

注：标签不单单只是在构造方法时使用，只要创建Bean对象时就会使用

<bean id="userDao" class="com.itlzxr.factory.UserDaoFactoryBean" factory-method="getUserDao">
	<constructor-arg name="name" value="lzxr"/>
</bean>

工厂方式实例化Bean又分为如下三种

静态工厂方法实例化Bean

实例工厂方法实例化Bean

实现FactoryBean规范延迟实例化Bean

静态工厂方法实例化Bean，其实就是定义一个工厂类，提供一个静态方法用于生产Bean实例，在将该工厂类及其静态方法配置给Spring即可

该方法不是构造方法，而是构造Bean的方法，只要是创建Bean的方法，内部参数在spring的配置当中都可以使用< 标签进行传递

public class UserDaoFactoryBean {
    public static UserService userService() {
        // Bean创建之前可进行其他业务操作
        return new UserServiceImpl();
    }
}

将其打印查看其具体信息，运行ApplicationTest，进行测试

ApplicationContext applicationContext = new ClassPathxmlApplicationContext("applicationContext.xml");
Object userDao = applicationContext.getBean("userDao");
System.out.println(userDao);

断点调试，发现其被存入到了单例池中

有些Bean不是通过构造方法来获取，而是通过某些对象的方法获取的，如果要将这些Bean交给spring去管理，可以使用实例工厂方式实例化

实例工厂方法实例化Bean，也就是非静态工厂方法产生Bean实例，与静态工厂方式比较，该方式需要先有工厂对象，再用工厂

对象去调用非静态方法，所以在进行配置时，要先配置工厂Bean，在配置目标Bean

<!-- 配置实例工厂Bean -->
<bean id="userDaoFactoryBean2" class="com.itlzxr.factory.UserDaoFactoryBean2"/>
<!-- 配置实例工厂Bean的哪个方法作为工厂方法 -->
<bean id="userDao" factory-bean="userDaoFactoryBean2" factory-method="getUserDao">
<constructor-arg name="name" value="lzxr"/>
</bean>

通过断点观察单例池singletonObjects，发现单例池中既有工厂Bean实例，也有目标Bean实例，且都是在Spring容器创建时，就完成了Bean的实例化

不管是静态工厂方式还是非静态工厂方式，都是自定义的工厂方法

Spring提供了FactoryBean的接口规范，FactoryBean接口定义如下：

public interface FactoryBean<T> {
	String OBJECT_TYPE_ATTRIBUTE = “factoryBeanObjectType”;
	T getObject() throws Exception; //获得实例对象方法
	Class<?> getObjectType(); //获得实例对象类型方法
	default boolean isSingleton() {
		return true;
	}
}

定义工厂实现FactoryBean

public class UserDaoFactoryBean3 implements FactoryBean<UserDao> {
	public UserDao getObject() throws Exception {
		return new UserDaoImpl();
	}
	public Class<?> getObjectType() {
		return UserDao.class;
	}
}

配置FactoryBean交由Spring管理即可

    <bean id="userDao3" class="com.itlzxr.factory.MyFactory3"></bean>

通过Spring容器根据beanName可以正常获得UserDaoImpl

ApplicationContext applicationContext = new ClassPathxmlApplicationContext("applicationContext.xml");
Object userDao = applicationContext.getBean("userDao");
System.out.println(userDao);

通过断点观察发现Spring容器创建时，FactoryBean被实例化了，并存储到了单例池singletonObjects中

但是getObject() 方法尚未被执行，UserDaoImpl也没被实例化，当首次用到UserDaoImpl时，才调用getObject()

此工厂方式产生的Bean实例不会存储到单例池singletonObjects中，会存储到 factoryBeanObjectCache 缓存池中，并且后期每次使用到userDao都从该缓存池中返回的是同一个userDao实例。

Bean的依赖注入方式

Bean的依赖注入有两种方式：

通过Bean的set方法注入

<property name="userDao" ref="userDao"/>
<property name="userDao" value="haohao"/>

通过构造Bean的方法进行注入

<constructor-arg name="name" ref="userDao"/>
<constructor-arg name="name" value="haohao"/>

其中，ref 是 reference 的缩写形式，翻译为：涉及，参考的意思，用于引用其他Bean的id。value 用于注入普通属性值。

依赖注入的数据类型有如下三种：

普通数据类型，例如：String、int、boolean等，通过value属性指定。

引用数据类型，例如：UserDaoImpl、DataSource等，通过ref属性指定。

集合数据类型，例如：List、Set、Map、Properties等。

注入 List 集合 – 普通数据

public class UserServiceImpl implements UserService {
    private UserDao userDao;

    //注入List 通过set方法注入
    private List<String> stringList;

    public void setStringList(List<String> stringList) {
        this.stringList = stringList;
    }
    
    public void show() {
        System.out.println(stringList);
    }
}

stringList既不是普通数据类型，也不是引用数据类型，因此，需要利用子标签来对其进行指定，而list内部存的只是普通字符串，直接使用标签进行指定

<bean id="userService" class="com.itlzxr.service.impl.UserServiceImpl">
        <property name="stringList">
            <list>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </list>
        </property>
    </bean>

注入 List 集合 – 引用数据

    private List<UserDao> userDaoList;

    public void setUserDaoList(List<UserDao> userDaoList) {
        this.userDaoList = userDaoList;
    }

很明显，此处为list集合，应使用子标签，而此集合内部存的是Bean对象，因此，不可使用标签进行指定

解决此问题有两种方式：

内部进行配置，可以配置多个对象，每一个bean配置都代表一个bean对象

<bean id="userService" class="com.itlzxr.service.impl.UserServiceImpl">
        <property name="userDaoList">
            <list>
                <bean class="com.itlzxr.dao.impl.UserDaoImpl"></bean>
                <bean class="com.itlzxr.dao.impl.UserDaoImpl"></bean>
                <bean class="com.itlzxr.dao.impl.UserDaoImpl"></bean>
            </list>
        </property>
    </bean>

利用ref引用进行配置，外部进行bean配置，内部对其引用

<bean id="userService" class="com.itlzxr.service.impl.UserServiceImpl">
        <property name="userDaoList">
            <list>
                <ref bean="userDao1"></ref>
                <ref bean="userDao2"></ref>
                <ref bean="userDao3"></ref>
            </list>
        </property>
    </bean>

    <bean id="userDao1" class="com.itlzxr.dao.impl.UserDaoImpl"></bean>
    <bean id="userDao2" class="com.itlzxr.dao.impl.UserDaoImpl"></bean>
    <bean id="userDao3" class="com.itlzxr.dao.impl.UserDaoImpl"></bean>

注入 Set 集合（同list相似，区别在于list有序，set无序

    <bean id="userService" class="com.itlzxr.service.impl.UserServiceImpl">
        <property name="stringSet">
            <set>
                <value>xxxx</value>
                <value>yyyy</value>
            </set>
        </property>
        <property name="userDaoSet">
            <set>
                <ref bean="userDao1"></ref>
                <ref bean="userDao2"></ref>
                <ref bean="userDao3"></ref>
            </set>
        </property>
    </bean>

    <bean id="userDao1" class="com.itlzxr.dao.impl.UserDaoImpl"></bean>
    <bean id="userDao2" class="com.itlzxr.dao.impl.UserDaoImpl"></bean>
    <bean id="userDao3" class="com.itlzxr.dao.impl.UserDaoImpl"></bean>

	private Set<String> stringSet;
    private Set<UserDao> userDaoSet;

	// 注入Set
	// 注入泛型为字符串的Set集合
    public void setStringSet(Set<String> stringSet) {
        this.stringSet = stringSet;
    }

	// 注入泛型为对象的Set集合
    public void setUserDaoSet(Set<UserDao> userDaoSet) {
        this.userDaoSet = userDaoSet;
    }

注入 Map 集合

    <bean id="userService" class="com.itlzxr.service.impl.UserServiceImpl">
        <property name="map">
            <map>
                <!--每个键值对组成一个entry-->
                <entry key="d1" value-ref="userDao1"></entry>
                <entry key="d2" value-ref="userDao2"></entry>
                <entry key="d3" value-ref="userDao3"></entry>
            </map>
        </property>
    </bean>

 private Map<String, UserDao> map;

    // //注入值为对象的Map集合
    public void setMap(Map<String, UserDao> map) {
        this.map = map;
    }

注入 Properties 键值对

    private Properties properties;

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

<bean id="userService" class="com.itlzxr.service.impl.UserServiceImpl">
        <property name="properties">
            <props>
                <prop key="p1">111</prop>
                <prop key="p2">222</prop>
            </props>
        </property>
    </bean>

扩展：自动装配方式

如果被注入的属性类型是Bean引用的话，那么可以在标签中使用 autowire 属性去配置自动注入方式，属性值有两个：

byName：通过属性名自动装配，即去匹配 setXxx 与 id="xxx"（name="xxx"）是否一致

byType：通过Bean的类型从容器中匹配，匹配出多个相同Bean类型时，报错

<bean id="userService" class="com.itlzxr.service.impl.UserServiceImpl" autowire="byType">

spring的其他配置标签

Spring 的 xml 标签大体上分为两类，一种是默认标签，一种是自定义标签

默认标签：就是不用额外导入其他命名空间约束的标签，例如标签

自定义标签：就是需要额外引入其他命名空间约束，并通过前缀引用的标签，例如< context:property-placeholder/ >标签

Spring的默认标签用到的是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"
xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

自定义标签

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-beans.xsd">
    <context:property-placeholder></context:property-placeholder>
</beans>

该命名空间约束下的默认标签如下：

标签	作用
<beans>	一般作为 xml 配置根标签，其他标签都是该标签的子标签
<bean>	Bean的配置标签，上面已经详解了，此处不再阐述
<import>	外部资源导入标签
<alias>	指定Bean的别名标签，使用较少

<bean> 标签，除了经常用的做为根标签外，还可以嵌套在根标签内，使用profile属性切换开发环境

<!-- 配置测试环境下，需要加载的Bean实例 -->
<beans profile="test">
</beans>
<!-- 配置开发环境下，需要加载的Bean实例 -->
<beans profile="dev">
</beans>
<!--默认环境-->
<!--配置UserServiceImpl-->
<bean id="userService" class="com.itlzxr.service.impl.UserServiceImpl"></bean>
<!--配置UserDaoImpl-->
<bean id="userDao" class="com.itlzxr.dao.impl.UserDaoImpl"></bean>

可以使用以下两种方式指定被激活的环境：

使用命令行动态参数，虚拟机参数位置加载 -Dspring.profiles.active=test

使用代码的方式设置环境变量 System.setProperty("spring.profiles.active","test")

在没有指定环境的情况下，只有默认环境下的标签生效，若指定了测试环境，则测试环境和默认环境的标签都生效

标签，用于导入其他配置文件，项目变大后，就会导致一个配置文件内容过多，可以将一个配置文件根据业务某块进行拆分，拆分后，最终通过标签导入到一个主配置文件中，项目加载主配置文件就连同导入的文件一并加载了

    <!--导入用户模块配置文件-->
    <import resource="applicationContext-user.xml"></import>
    <!--导入商品模块配置文件-->
    <import resource="applicationContext-order.xml"></import>

标签是为某个Bean添加别名，与在标签上使用name属性添加别名的方式一样

我们为UserServiceImpl指定四个别名：aaa、bbb、xxx、yyy

<!--配置UserService-->
<bean id="userService" name="aaa,bbb" class="com.itlzxr.service.impl.UserServiceImpl">
	<property name="userDao" ref="userDao"/>
</bean>
<!--指定别名-->
<alias name="userService" alias="xxx"/>
<alias name="userService" alias="yyy"/>

断点调试，在beanFactory中维护着一个名为aliasMap的Map<String,String>集合，存储别名和beanName之间的映射关系

Spring的自定义标签需要引入外部的命名空间，并为外部的命名空间指定前缀，使用 <前缀:标签> 形式的标签，称之为自定义标签，自定义标签的解析流程也是 Spring xml扩展点方式之一

<!--默认标签-->
<bean id="userDao" class="com.itlzxr.dao.impl.UserDaoImpl"/>
<!--自定义标签-->
<context:property-placeholder/>
<mvc:annotation-driven/>
<dubbo:application name="application"/>