Spring Bean的配置详解

柔情只为你懂 2024-03-30 13:31 68阅读 0赞

**目录**

1.bean基础配置

例如：配置UserDaolmpl由Spring容器负责管理

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

3.bean的别名配置

4.bean作用范围配置

5.bean的实例化

6.bean生命周期

7.Spring的get方法

8.Bean的延迟加载

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

10.Bean的依赖注入配置

--------------------

#### 1.bean基础配置 ####

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>类别</td> 
   <td>描述</td> 
  </tr> 
  <tr> 
   <td>名称</td> 
   <td>bean</td> 
  </tr> 
  <tr> 
   <td>类型</td> 
   <td>标签</td> 
  </tr> 
  <tr> 
   <td>所属</td> 
   <td>beans标签</td> 
  </tr> 
  <tr> 
   <td>功能</td> 
   <td>定义Spring核心容器管理的对象</td> 
  </tr> 
  <tr> 
   <td>格式</td> 
   <td> <p>&lt;beans&gt;</p> <p>&nbsp; &nbsp; &nbsp; &lt;bean/&gt;</p> <p>&nbsp; &nbsp; &nbsp;&lt;bean&gt;&lt;/bean&gt;</p> <p>&lt;/beans&gt;</p> </td> 
  </tr> 
  <tr> 
   <td>属性列表</td> 
   <td> <p>id:bean的id，使用容器可以通过id值获取对应的bean，在一个容器中id值唯一</p> <p>class：bean的类型，即配置的bean的全路径类名</p> </td> 
  </tr> 
  <tr> 
   <td>范例</td> 
   <td> <p>&lt;bean id="userDao"class="com.tangyuan.dao.impl.User DaoImpl"/&gt;</p> <p>&nbsp;&lt;bean id="userService" &nbsp;class="com.tangyuan.service.impl.UserServiceImpl"/&gt;</p> </td> 
  </tr> 
 </tbody> 
</table>

#### 例如：配置UserDaolmpl由Spring容器负责管理 ####

此时存储到Spring容器(singleObjects单例池) 中的Bean的beanNames是userDao，值是UserDaolmpl对象， 可以根据beanName获取Bean实例

applicationContext.getBean("userDao");

如果不配置id， 则Spring会把当前Bean实例的全限定名作为beanName

applicationContext.getBean("com.tangyuan.dao.impl.UserDaoImpl");

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

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

#### 3.bean的别名配置 ####

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>类别</td> 
   <td>描述</td> 
  </tr> 
  <tr> 
   <td>名称</td> 
   <td>name</td> 
  </tr> 
  <tr> 
   <td>类型</td> 
   <td>属性</td> 
  </tr> 
  <tr> 
   <td>所属</td> 
   <td>bean标签</td> 
  </tr> 
  <tr> 
   <td>功能</td> 
   <td>定义bean的别名，可定义多个，使用逗号(,)分号(;)空格()分隔</td> 
  </tr> 
  <tr> 
   <td>范例</td> 
   <td>&lt;bean id="userDao"name="aaa,bbb" class="com.tangyuan.dao.impl.UserDaoImpl"/&gt;</td> 
  </tr> 
 </tbody> 
</table>

注意事项:

获取bean无论是通过id还是name获取,如果无法获取到,将会抛出异常NoSuchBeanDefinitionException:No bean named 'UserDaoImpl' available

**可以为当前Bean指定多个别名， 根据别名也可以获得Bean对象**

配置了别名时，如果有id设置了,那么id就是BeanName,如果没有设置id,那么BeanName就是别名第一个，如果都没有，那么class就是BeanName

此时多个名称都可以获得UserDaolmpl实例对象

applicationContext.getBean("userDao") ；
    applicationContext.getBean("aaa") ；
    applicationContext.getBean("bbb") ；

####  ####

#### 4.bean作用范围配置 ####

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>类别</td> 
   <td>描述</td> 
  </tr> 
  <tr> 
   <td>名称</td> 
   <td>scope</td> 
  </tr> 
  <tr> 
   <td>类型</td> 
   <td>属性</td> 
  </tr> 
  <tr> 
   <td>所属</td> 
   <td>bean标签</td> 
  </tr> 
  <tr> 
   <td>功能</td> 
   <td> <p>定义bean的作用范围,可选范围如下：</p> 
    <ul> 
     <li>singleton：单例（默认）</li> 
     <li>&nbsp;prototype：非单例</li> 
    </ul></td> 
  </tr> 
  <tr> 
   <td>范例</td> 
   <td>&lt;bean id="userDao"class="com.tangyuan.dao.impl.UserDaoImpl" scope="prototype"/&gt;</td> 
  </tr> 
 </tbody> 
</table>

默认情况下， 单纯(基本)的Spring环境Bean的作用范围有两个：

*  Singleton和Prototype
 *  singleton：单例， 默认值， Spring容器创建的时候， 就会进行Bean的实例化， 并存储到容器内部的单例池中,每次getBean时都是从单例池中获取相同的Bean实例；
 *  prototype：原型， Spring容器初始化时不会创建Bean实例， 当调用getBean时才会实例化Bean,每次getBean都会创建一个新的Bean实例。
 *  注意：在webmvc环境中:-------> singleton+prototype+request和session

**①:为什么bean默认为单例？**

对于Spring而言，它帮我们管理的bean要放置到Spring容器中，假定一个场景，如果造出来的bean不是非单例的，bean的数量会有无穷无尽，用一次造一个，所以Spring不是帮助我们管理这一类的bean的，这样的话，对Spring容器也会有一个特别大的压力，如果Spring造出来的bean都是单例的，对我们的业务不会造成伤害，造一个dao对象，执行完方法，下一次，你也需要再造一个dao对象，执行另一个方法，这两个对象没有什么不同的，可以直接使用这个对象。Spring帮助我们管理对象的时候，其实就是管理那些可以多用的对象，就是这个对象你用完之后，下次还可以用它，这样，效率才会更高一些，因此，它就简单一些，造出来的bean就是单例的

**②.适合交给容器管理的bean**

*  表现层对象
 *  业务层对象
 *  数据层对象
 *  工具对象

**③：不适合交给容器管理的bean**

*  封装实体的域对象

## 5.bean的实例化 ##

> 构造方法

*  bean本质上就是对象，可以使用构造方法来完成bean的创建

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

*  构造方式实例化：底层通过构造方法对Bean进行实例化 ----默认无参
 *  有参--->在xml文件中添加
 *  <constructor-arg name="构造函数的参数名" value="值" ></constructor-arg>
 *  工厂方式实例化：底层通过调用自定义的工厂方法对Bean进行实例化

构造方式实例化Bean又分为无参构造方法实例化和有参构造方法实例化， Spring中配置的<bean>几乎都是无参 造该方式， 此处不在赘述。下面讲解有参构造方法实例化Bean

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

有参构造在实例化Bean时， 需要参数的注入， 通过<constructor-arg>标签， 嵌入在<bean>标签内部提供构造参 数，如下：

注：无参构造方法如果不存在，将抛出异常BeanCreationException

> 工厂方式实例化Bean

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

*  静态工厂方法实例化Bean
 *  实例工厂方法实例化Bean
 *  实现FactoryBean规范延迟实例化Bean

**静态工厂方法实例化Bean的基本操作如下：**

1.创建一个静态的static方法(无参)

public static UserDao userDao(){
                //Bean在创建之前可以进行一些其他的业务逻辑处理操作
                return  new UserDaoImpl();
            }

一个静态的static方法(有参)

public static UserDao userDao(String name,int age){
                //Bean在创建之前可以进行一些其他的业务逻辑处理操作
                return  new UserDaoImpl();
            }

2.在xml文件中进行设置

*  无参设置------>

<bean id="userDao1" class="com.tangyuan.factory.MyBeanFactory" factory-method="userDao"></bean>

*  有参设置------->

<bean id="userDao1" class="com.tangyuan.factory.MyBeanFactory" factory-method="userDao">
             <constructor-arg name="name" value="秦始皇"></constructor-arg>
             <constructor-arg name="age" value="12"></constructor-arg>
         </bean>

3.测试

ClassPathXmlApplicationContext applicationContext=new                  ClassPathXmlApplicationContext("applicationContext.xml");
     UserDao userDao1 = (UserDao) applicationContext.getBean("userDao1");
            System.out.println(userDao1);//com.tangyuan.dao.impl.UserDaoImpl@57536d79

**实例工厂方法实例化Bean**

1.创建一个方法(无参)

public  UserDao userDao(){
                //Bean在创建之前可以进行一些其他的业务逻辑处理操作
                return  new UserDaoImpl();
            }

创建一个方法(有参)

public  UserDao userDao(String username){
                //Bean在创建之前可以进行一些其他的业务逻辑处理操作
                return  new UserDaoImpl();
            }

2.在xml文件中进行设置----->先实例化工厂对象，再实例化Bean

*  无参设置------->

<bean id="myBeanFactory2" class="com.tangyuan.factory.MyBeanFactory2"></bean>
    
        
        <bean id="userDao2" factory-bean="myBeanFactory2" factory-method="userDao"></bean>

*  有参设置------>

3.测试

ClassPathXmlApplicationContext applicationContext=new                  ClassPathXmlApplicationContext("applicationContext.xml");
    UserDao userDao2 = (UserDao) applicationContext.getBean("userDao2");
    System.out.println(userDao2);//com.tangyuan.dao.impl.UserDaoImpl@3b0143d3

**实现FactoryBean规范延迟实例化Bean**

1.创建一个类,继承FactoryBean<T>接口，并实现其中的方法

package com.tangyuan.factory;
    
    import com.tangyuan.dao.UserDao;
    import com.tangyuan.dao.impl.UserDaoImpl;
    import org.springframework.beans.factory.FactoryBean;
    
    /**
     * @author 唐渊
     * @create  2022-11-21 11:16
     */
    public class MyBeanFactory3 implements FactoryBean<UserDao> {
        //代替原始实例工厂中创建对象的方法
        @Override
        public UserDao getObject() throws Exception {
            return new UserDaoImpl();
        }
    
        //返回Bean的类型
        @Override
        public Class<?> getObjectType() {
            return UserDao.class;
        }
    }

2.在xml文件中进行设置

<bean id="userDao3" class="com.tangyuan.factory.MyBeanFactory3"></bean>

3.测试--------getBean()方法之后,才会调用getObject()方法

ClassPathXmlApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
      UserDao userDao3 = (UserDao) applicationContext.getBean("userDao3");
            System.out.println(userDao3);//com.tangyuan.dao.impl.UserDaoImpl@1e965684

注：这里的bean是单例模式

如果，需要改成非单例的，在类中添加下面的方法,并返回false即可，如果想改为单例的，返回ture，或者不写，默认是单例

public boolean isSingleton(){
       return false;
    }

## 6.bean生命周期 ##

*  生命周期：从创建到消亡的完整过程
 *  bean生命周期：bean从创建到销毁的整体过程
 *  bean生命周期控制：在bean创建后到销毁前做一些事情

Spring Bean的生命周期是从Bean实例化之后， 即通过反射创建出对象之后， 到Bean成为一个完整对象， 最终存储 到单例池中， 这个过程被称为Spring Bean的生命周期。Spring Bean的生命周期大体上分为三个阶段：

*  Bean的实例化阶段：Spring框架会取出Bean Definition的信息进行判断当前Bean的范围是否是singleton的， 是否不是延迟加载的， 是否不是Factory Bean等， 最终将一个普通的singleton的Bean通过反射进行实例化；
 *  Bean的初始化阶段：Bean创建之后还仅仅是个"半成品"， 还需要对Bean实例的属性进行填充、执行一些Aware 接口方法、执行Bean PostProcessor方法、执行Initializing Bean接口的初始化方法、执行自定义初始化init方法 等。该阶段是Spring最具技术含量和复杂度的阶段， Aop增强功能， 后面要学习的Spring的注解功能等、 spring高频面试题Bean的循环引用问题都是在这个阶段体现的；
 *  Bean的完成阶段：经过初始化阶段， Bean就成为了一个完整的Spring Bean， 被存储到单例池 singleton Objects中去了， 即完成了Spring Bean的整个生命周期。

由于Bean的初始化阶段的步骤比较复杂， 所以着重研究Bean的初始化阶段 Spring Bean的初始化过程涉及如下几个过程：

*  Bean实例的属性填充
 *  Aware接口属性注入
 *  BeanPostProcessor的before() 方法回调
 *  InitializingBean接口的初始化方法回调
 *  自定义初始化方法init回调
 *  BeanPostProcessor的after() 方法回调

ps:执行顺序-------InitializingBean接口的初始化方法--->自定义初始化方法init----->BeanPostProcessor的before() 方法------>BeanPostProcessor的after()

Bean实例属性填充 BeanDefinition中有对当前Bean实体的注入信息通过属性propertyValues进行了存储

Bean实例属性填充 Spring在进行属性注入时， 会分为如下几种情况：

*  注入普通属性， String、int或存储基本类型的集合时， 直接通过set方法的反射设置进去；
 *  注入单向对象引用属性时， 从容器中getBean获取后通过set方法反射设置进去， 如果容器中没有， 则先创建被 注入对象Bean实例(完成整个生命周期) 后， 在进行注入操作；
 *  注入双向对象引用属性时，就比较复杂了，涉及了循环引用(循环依赖)问题，下面会详细阐述解决方案。

单向:service的创建依赖dao的注入，dao的注入不需要service的注入

步骤：UserService创建----->UserDao创建----->UserService执行注入UserDao的操作：setUserDao方法执行

多个实体之间相互依赖并形成闭环的情况就叫做"循环依赖"，也叫做"循环引用"

beanA ----A依赖于B--------><--------B依赖于A-----beanB

public class User ServiceImpl implements User Service{
          public void setUserDao(UserDao userDao){}
    }
    public class UserDaoImpl  implements UserDao{
        public void setUserService(UserService userService) {}
    }

![9359545d0ba34642bfe572409a7b2de8.png][]

Spring提供了三级缓存存储完整Bean实例和半成品Bean实例， 用于解决循环引用问题 在Default List able BeanFactory的上四级父类Default Singleton Bean Registry中提供如下三个Map：

public class Default singleton Bean Registry...{
    //1、最终存储单例Bean成品的容器， 即实例化和初始化都完成的Bean， 称之为"一级缓存"
    Map<String， Object>singleton Objects=new Concurrent HashMap(256) ；
    //2、早期Bean单例池， 缓存半成品对象， 且当前对象已经被其他对象引用了， 称之为"二级缓存"
    Map<String， Object>early Singleton Objects=new Concurrent HashMap(16) ；
    //3、单例Bean的工厂池， 缓存半成品对象， 对象未被引用， 使用时在通过工厂创建Bean， 称之为"三级缓存"
    Map<String， Object Factory<?>>singleton Factories=new HashMap(16) ；
    }

UserService和UserDao循环依赖的过程结合上述三级缓存描述一下:

*  UserService实例化对象， 但尚未初始化， 将UserService存储到三级缓存；
 *  UserService属性注入， 需要UserDao， 从缓存中获取， 没有UserDao；
 *  UserDao实例化对象， 但尚未初始化， 将UserDao存储到到三级缓存；
 *  UserDao属性注入， 需要UserService， 从三级缓存获取UserService， UserService从三级缓存移入二级缓存；
 *  UserDao执行其他生命周期过程， 最终成为一个完成Bean，存储到一级缓存，删除二三级缓存；
 *  UserService注入UserDao；
 *  UserService执行其他生命周期过程， 最终成为一个完成Bean，存储到一级缓存, 删除二三级缓存。

> **常用的Aware接口**

Aware接口是一种框架辅助属性注入的一种思想， 其他框架中也可以看到类似的接口。框架具备高度封装性， 我们接 触到的一般都是业务代码， 一个底层功能API不能轻易的获取到， 但是这不意味着永远用不到这些对象， 如果用到了 ， 就可以使用框架提供的类似Aware的接口， 让框架给我们注入该对象。

<table> 
 <thead> 
  <tr> 
   <th>Aware接口</th> 
   <th>回调方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ServletContextAware</td> 
   <td>setServletContext(ServletContext context)</td> 
   <td>Spring框架回调方法注入ServletContext对象，web环境下才生效</td> 
  </tr> 
  <tr> 
   <td>BeanFactoryAware</td> 
   <td>setBeanFactory(BeanFactory factory)</td> 
   <td>Spring框架回调方法注入beanFactory对象</td> 
  </tr> 
  <tr> 
   <td>BeanNameAware</td> 
   <td>setBeanName(String beanName)</td> 
   <td>Spring框架回调方法注入当前Bean在容器中的beanName</td> 
  </tr> 
  <tr> 
   <td>ApplicationContextAware</td> 
   <td>setApplicationContext(ApplicationContext applicationContext)</td> 
   <td>Spring框架回调方法注入applicationContext 对象</td> 
  </tr> 
 </tbody> 
</table>

## 7.Spring的get方法 ##

<table> 
 <thead> 
  <tr> 
   <th>方法定义</th> 
   <th>返回值和参数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Object getBean(String bean Name)</td> 
   <td>根据beanName从容器中获取Bean实例， 要求容器中Bean唯一， 返回值为Object， 需要强转</td> 
  </tr> 
  <tr> 
   <td>T getBean(Classtype)</td> 
   <td>根据Class类型从容器中获取Bean实例， 要求容器中Bean类型唯一， 返回值为Class类型实例， 无需强转</td> 
  </tr> 
  <tr> 
   <td>T get Bean(String beanName， Classtype)</td> 
   <td>根据bean Name从容器中获得Bean实例， 返回值为Class类型实例， 无需强转</td> 
  </tr> 
 </tbody> 
</table>

//根据beanName获取容器中的Bean实例， 需要手动强转
    UserService userService=(UserService)
    applicationContext.getBean("userService");
    //根据Bean类型去容器中匹配对应的Bean实例， 如存在多个匹配Bean则报错
    UserService userService2=applicationContext.getBean(UserService.class);
    //根据bean Name获取容器中的Bean实例， 指定Bean的Type类型
    UserService userService3=applicationContext.getBean("userService"，
    UserService.class);

## 8.Bean的延迟加载 ##

当lazy-init设置为true时为延迟加载， 也就是当Spring容器创建的时候， 不会立即创建Bean实例， 等待用到时在创建Bean实例并存储到单例池中去， 后续在使用该Bean直接从单例池获取即可， 本质上该Bean还是单例的

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

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

public class UserDaoImpl implements UserDao{
    
    public UserDaoImpl(){System.out.println("User Dao Impl创建了...")；}
    public void init() {System.out.println("初始化方法...") ；}
    public void destroy() {system.out.println("销毁方法...") ；}
    
    }

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

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

##  ##

## 10.Bean的依赖注入配置 ##

*  **思考：向一个类中传递数据的方式有几种？**
 *  普通方法(set方法)
 *  构造方法
 *  **思考：依赖注入描述了在容器中建立bean与bean之间依赖关系的过程，如果bean运行需要的是数字或字符串呢？**
 *  引用类型
 *  简单类型(基本数据类型与String)

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

*  setter注入
 *  构造器注入

<table> 
 <thead> 
  <tr> 
   <th>注入方式</th> 
   <th>配置方式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>通过Bean的set方法注入</td> 
   <td>&lt;property name="userDao"ref="userDao"/&gt; &lt;property name="userDao"value="秦始皇"/&gt;</td> 
  </tr> 
  <tr> 
   <td>通过构造Bean的方法进行注入</td> 
   <td>&lt;constructor-arg name="name"ref="userDao"/&gt; &lt;constructor-arg name="name"value="秦始皇"/&gt;</td> 
  </tr> 
 </tbody> 
</table>

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

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

*  普通数据类型， 例如：String、int、boolean等， 通过value属性指定。
 *  引用数据类型， 例如：User D aol mpl、DataSource等， 通过ref属性指定。
 *  集合数据类型， 例如：List、Map、Properties等。

**集合数据类型演示：**

\-------------------------------------------------------list集合----------------------------------------------------------------

1.创建list集合,并以String为基本类型，定义set方法

//注入List
        private List<String> list;
    
        //set方法
        public  void  setList(List<String> list) {
            this.list = list;
        }
      //输出list集合
        @Override
        public  void  show(){
            System.out.println(list);
        }

2.在xml文件中进行配置

<bean id="userService" class="com.tangyuan.service.impl.UserServiceImpl">
        
        <property name="list">
            
            <list>
                
                <value>秦始皇</value>
                <value>唐太宗</value>
                <value>唐玄宗</value>
            </list>
        </property>
    </bean>

3.测试

ClassPathXmlApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
     IUserService userService = (IUserService) applicationContext.getBean("userService");
    userService.show();//[秦始皇, 唐太宗, 唐玄宗]

1.创建list集合,并以对象为基本类型，定义set方法

//对象
        private List<UserDao> userDaoList;
        //set方法
        public void setUserDaoList(List<UserDao> userDaoList) {
            this.userDaoList = userDaoList;
        }
    
        //输出list集合
        @Override
        public  void  show(){
            System.out.println(userDaoList);
        }

2.在xml文件中进行配置

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

<bean id="userService" class="com.tangyuan.service.impl.UserServiceImpl">
                    
                    <ref bean="userDao1"></ref>
                    <ref bean="userDao2"></ref>
                    <ref bean="userDao3"></ref>
                </list>
            </property>
        </bean>
    
        
        <bean id="userDao1" class="com.tangyuan.dao.impl.UserDaoImpl"></bean>
        <bean id="userDao2" class="com.tangyuan.dao.impl.UserDaoImpl"></bean>
        <bean id="userDao3" class="com.tangyuan.dao.impl.UserDaoImpl"></bean>
       </beans>

\-----------------------------------------------------------------------set集合---------------------------------------------

1.创建set集合,并以String为基本类型，定义set方法

//set 基本数据类型
        private Set<String> set;
    
        public void setSet(Set<String> set) {
            this.set = set;
        }
        //输出集合
        @Override
        public  void  show(){  
            System.out.println(set);
        }

2.在xml文件中进行配置

<bean id="userService" class="com.tangyuan.service.impl.UserServiceImpl">      
            
            <property name="set">
                
                <set>
                    
                    <value>李太白</value>
                    <value>杨玉环</value>
                    <value>李隆基</value>
                </set>
            </property>
        </bean>

1.创建set集合,并以对象为数据类型，定义set方法

//set 对象数据类型
        private Set<UserDao> userDaoSet;
    
        public void setUserDaoSet(Set<UserDao> userDaoSet) {
            this.userDaoSet = userDaoSet;
        }
         //输出集合
        @Override
        public  void  show(){  
            System.out.println(userDaoSet);
        }

2.在xml文件中进行配置

<bean id="userService" class="com.tangyuan.service.impl.UserServiceImpl">
            
         <property name="userDaoSet">
             
             <set>
                 
                 
               
                 
                 <ref bean="userDao1"></ref>
                 <ref bean="userDao2"></ref>
                 <ref bean="userDao3"></ref>
             </set>
         </property>
       </bean>
    
     
     <bean id="userDao1" class="com.tangyuan.dao.impl.UserDaoImpl"></bean>
     <bean id="userDao2" class="com.tangyuan.dao.impl.UserDaoImpl"></bean>
     <bean id="userDao3" class="com.tangyuan.dao.impl.UserDaoImpl"></bean>

\-------------------------------------------------------------------------map集合--------------------------------------------

1.创建map集合

//map集合
    private Map<String,UserDao> map;
    public void setMap(Map<String, UserDao> map) {
        this.map = map;
    }
     //输出集合
        @Override
        public  void  show(){
            System.out.println(map);
        }

2.在xml文件中进行配置

<bean id="userService" class="com.tangyuan.service.impl.UserServiceImpl">
         
         <property name="map">
             <map>
                 <entry key="aa" value-ref="userDao2"></entry>
                 <entry key="bb" value-ref="userDao1"></entry>
             </map>
         </property>
     </bean>
    
     
     <bean id="userDao1" class="com.tangyuan.dao.impl.UserDaoImpl"></bean>
     <bean id="userDao2" class="com.tangyuan.dao.impl.UserDaoImpl"></bean>
     <bean id="userDao3" class="com.tangyuan.dao.impl.UserDaoImpl"></bean>

\----------------------------------------------------Properties---------------------------------------------------------------

1.创建Properties集合,定义set方法,并打印输出

//Java.util.Properties包,读取Java的properties配置文件,以<key（键）,value（值）>的格式来存储内容/参数配置
    private Properties properties;
    
    public void setProperties(Properties properties) {
        this.properties = properties;
    }
    
    //输出集合
    @Override
    public  void  show(){
        System.out.println(properties);
    }

2.在xml文件中进行配置

<bean id="userService" class="com.tangyuan.service.impl.UserServiceImpl">
              
            <property name="properties">
                <props>
                    <prop key="aa">王昭君</prop>
                    <prop key="bb">西施</prop>
                    <prop key="cc">貂蝉</prop>
                    <prop key="dd">杨玉环</prop>
                </props>
            </property>
        </bean>

![c636c00ea21a43369def67474d9f64b5.jpeg][]

[9359545d0ba34642bfe572409a7b2de8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/1922c3b68f0a4ce4a5b55203783ef7ed.png
[c636c00ea21a43369def67474d9f64b5.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/314209cf546d4095b56ce68774a162d0.jpeg