• 【Spring（二）】java对象属性的配置（Bean的配置）

     有关Spring的所有文章都收录于我的专栏：👉Spring👈

    目录
    一、前言
    二、通过Setter方法配置Bean
    三、通过构造器配置Bean
      1. 通过属性名配置
      2. 通过索引配置
      3. 通过属性类型配置
    四、通过p命名空间配置bean
    五、引用/注入其他bean对象
    六、引用/注入内部bean对象
    七、引入/注入集合/数组类型
    八、使用util名称空间
    九、级联赋值

    相关文章

    【Spring（一）】如何获取对象（Bean）【Spring（一）】如何获取对象（Bean）

    一、前言

     上一篇文章中，我们对Spring做了一些基本的了解，以及在Spring中如何获取Bean。我们在XML配置文件中，只是写了那些标签和属性，但它们都各自代表什么、如何配置一个Bean、Bean的配置方式等，这些都是我们接下来需要了解和学习的。

     在配置Bean的时候，我们首先得知道需要配置的那个类是什么。这就和我们用传统方式创建对象一样，通过类来创建一个对象。我们在下边的示例中都使用这个Monster类讲解。

    package com.jl.spring.bean;

/**
 * @author long
 * @date 2022/8/30
 */
public class Monster {
    private Integer monsterId;
    private String name;
    private String skill;
    public Monster(){}
    public Monster(Integer monsterId, String name, String skill) {
        this.monsterId = monsterId;
        this.name = name;
        this.skill = skill;
    }

    public Integer getMonsterId() {
        return monsterId;
    }

    public void setMonsterId(Integer monsterId) {
        this.monsterId = monsterId;
    }

    public String getName() {
        return name;
    }

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

    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }

    @Override
    public String toString() {
        return "Monster{" +
                "monsterId=" + monsterId +
                ", name='" + name + '\'' +
                ", skill='" + skill + '\'' +
                '}';
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50

    二、通过Setter方法配置Bean

    <bean class="com.jl.spring.bean.Monster" id="monster01">
    <property name="monsterId" value="100"/>
    <property name="name" value="牛魔王"/>
    <property name="skill" value="芭蕉扇"/>
bean>

    • 1
    • 2
    • 3
    • 4
    • 5
    1. class是类的全路径，通过类的全路径我们的Spring容器才可以创建Bean对象。
    2. id是Bean的名称，我们可以通过id值来获取到这个Bean对象。
    3. property这个标签用来标识这是一个属性。
    4. name是属性的名称（我们的name值必须要和对象中的属性名一致）。
    5. value是属性的值。

    在上边的配置中，我们属性配置用的都是property这个标签，而这个使用这个标签装配属性的前提是：我们的类必须提供相应的setter方法和无参构造方法。

    ⚠如果我们不提供属性相应的setter()，那么就会出现下边的错误：
    在这里插入图片描述
    ⚠如果不提供无参构造方法就会出现如下的错误：
    在这里插入图片描述

    三、通过构造器配置Bean

    通过构造器配置器的一个前提就是：提供有参构造。不提供就会报错。
    通过构造器来配置Bean，一共有三种配置方式：通过属性名配置、通过索引来配置、通过类型来配置。

    1. 通过属性名配置

    <bean class="com.jl.spring.bean.Monster" id="monster02">
		<constructor-arg name="monsterId" value="100"/>
		<constructor-arg name="name" value="牛魔王"/>
		<constructor-arg name="skill" value="芭蕉扇"/>
bean>

    • 1
    • 2
    • 3
    • 4
    • 5

    这种方式和使用Setter()方式来配置差不多，唯一的区别就是：我们使用有参构造来配置Bean使用的标签是。

    2. 通过索引配置

    <bean class="com.jl.spring.bean.Monster" id="monster02">
      <constructor-arg value="200" index="0"/>
      <constructor-arg value="白骨精" index="1"/>
      <constructor-arg value="九阴白骨爪" index="2"/>
bean>

    • 1
    • 2
    • 3
    • 4
    • 5

    使用索引配置Bean需要在使用index属性，index从0开始，对应我们有参构造函数中参数的顺序。

    3. 通过属性类型配置

    <bean class="com.jl.spring.bean.Monster"  id="monster02">
    <constructor-arg value="200" type="java.lang.Integer"/>
    <constructor-arg value="白骨精" type="java.lang.String"/>
    <constructor-arg value="九阴白骨爪" type="java.lang.String"/>
bean>

    • 1
    • 2
    • 3
    • 4
    • 5

    之所以可以使用类型配置Bean，是因为Java中的重载中规定：不能有完全相同的属性类型。

    四、通过p命名空间配置bean

    这种方式，同样也要求类必须具备Setter()和无参构造这两个条件。
    在使用P命名空间前还需要再XML配置文件的头部添加相关的声明。xmlns:p="http://www.springframework.org/schema/p
    在这里插入图片描述

    
<bean id="monster03" class="com.jl.spring.bean.Monster"
     p:monsterId="500"
     p:name="红孩儿"
     p:skill="喷火"
/>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    我们的这种方式，配置的时候是写在标签内的，而不是在标签体中。

    五、引用/注入其他bean对象

    我们在上边的学习的过程，属性都是基本数据类型的。但我们的使用过程中，一个对象的属性还有可能是其他我们自定义的对象类型。例如：Service调用Dao的时候，需要在Service层创建一个Dao对象。我们这里就讲解这种情况如何取解决。

    当然，开始之前我们也得有两个类，来演示。

    package com.jl.spring.dao;

/**
 * @author long
 * @date 2022/8/31
 */
public class MemberDAOImpl {
    public MemberDAOImpl(){
        System.out.println("MemberDAOImpl构造器被调用....");
    }
    public void add(){
        System.out.println("add方法被调用....");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    package com.jl.spring.service;

import com.jl.spring.dao.MemberDAOImpl;

/**
 * @author long
 * @date 2022/8/31
 */
public class MemberServiceImpl {
    private MemberDAOImpl memberDAO;
    public MemberDAOImpl getMemberDAO(){
        return memberDAO;
    }

    public void setMemberDAO(MemberDAOImpl memberDAO) {
        this.memberDAO = memberDAO;
    }

    public void add(){
        System.out.println("MemberServiceImpl add() 被调用....");
        memberDAO.add();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    测试类

    @Test
public void setBeanByRef(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
    MemberServiceImpl memberService = ioc.getBean("memberService", MemberServiceImpl.class);
    memberService.add();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    	
<bean class="com.jl.spring.dao.MemberDAOImpl" id="memberDAO"/>
    
<bean class="com.jl.spring.service.MemberServiceImpl" id="memberService">
      <property name="memberDAO" ref="memberDAO"/>
bean>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    property标签中的name和我们前边一样，都是属性的名称。但因为属性值是对象，所以我们这里使用rel，rel的值是引用的对象，而且这个值是引用的对象的id值。
     这里说明的一点：我们没有要求必须要将引用对象的配置写到前边，因为Spring是在创建好对象之后才进行属性装配的。不知道我这里有没有说清楚，贴一张图吧：
    在这里插入图片描述
    最后的运行结果：
    在这里插入图片描述

    六、引用/注入内部bean对象

     这里的内容和【五】一样都是属性为对象的时候的一种处理。但这里使用的是内部注入的方式。

    类全部都一样，不同的就是配置方式的区别。

     
<bean class="com.jl.spring.service.MemberServiceImpl" id="memberService">
   <property name="memberDAO">
       <bean class="com.jl.spring.dao.MemberDAOImpl">bean>
   property>
bean>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    这种内部注入的方式，是在property 标签体内，直接使用bean标签来配置的。因为只是内部使用这个对象，所以可以只写个class全类名就行。

    七、引入/注入集合/数组类型

     到这里我们已经可以解决，属性是：基本数据类型、对象。这两种情况，下边我们继续介绍，当我们的属性是集合类型的时候，该如何解决。我们这里通过一个Master来讲解不同的集合类型。

    package com.jl.spring.bean;

import java.util.*;

/**
 * @author long
 * @date 2022/8/31
 */
public class Master {
    private String name;
    private List<Monster> monsterList;
    private Map<String,Monster> monsterMap;
    private Set<Monster> monsterSet;
    private String[] monsterName;
    private Properties pros;

    @Override
    public String toString() {
        return "Master{" +
                "name='" + name + '\'' +
                ", monsterList=" + monsterList +
                ", monsterMap=" + monsterMap +
                ", monsterSet=" + monsterSet +
                ", monsterName=" + Arrays.toString(monsterName) +
                ", pros=" + pros +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public List<Monster> getMonsterList() {
        return monsterList;
    }

    public void setMonsterList(List<Monster> monsterList) {
        this.monsterList = monsterList;
    }

    public Map<String, Monster> getMonsterMap() {
        return monsterMap;
    }

    public void setMonsterMap(Map<String, Monster> monsterMap) {
        this.monsterMap = monsterMap;
    }

    public Set<Monster> getMonsterSet() {
        return monsterSet;
    }

    public void setMonsterSet(Set<Monster> monsterSet) {
        this.monsterSet = monsterSet;
    }

    public String[] getMonsterName() {
        return monsterName;
    }

    public void setMonsterName(String[] monsterName) {
        this.monsterName = monsterName;
    }

    public Properties getPros() {
        return pros;
    }

    public void setPros(Properties pros) {
        this.pros = pros;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    
<bean class="com.jl.spring.bean.Master" id="master">
   <property name="name" value="太上老君"/>
   
   <property name="monsterList">
       <list>
           
           <ref bean="monster01"/>
           <ref bean="monster02"/>
           
           <bean class="com.jl.spring.bean.Monster">
               <property name="name" value="葫芦娃"/>
               <property name="skill" value="喷水"/>
               <property name="monsterId" value="111"/>
           bean>
       list>
   property>
   
   <property name="monsterMap">
       <map>
           <entry>
               <key>
                   <value>monster02value>
               key>
               <ref bean="monster02">ref>
           entry>
           <entry>
               <key>
                   <value>monster03value>
               key>
               <ref bean="monster03"/>
           entry>
       map>
   property>
   
   <property name="monsterSet">
       <set>
           <ref bean="monster01"/>
           <ref bean="monster02"/>
           <bean class="com.jl.spring.bean.Monster">
               <property name="monsterId" value="123"/>
               <property name="name" value="银角大王"/>
               <property name="skill" value="扔葫芦"/>
           bean>
       set>
   property>
   
   <property name="monsterName">
       <array>
           <value>123value>
           <value>321value>
           <value>456value>
           <value>654value>
       array>
   property>
   
   <property name="pros">
       <props>
           <prop key="key01">oneprop>
           <prop key="key02">twoprop>
           <prop key="key03">threeprop>
       props>
   property>
bean>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64

    这里面的Properties是Hashtable的子类 , 是 key-value 的形式（key和value都是String）。

    测试类

    @Test
public void setBeanByCollection(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
    Master master = ioc.getBean("master", Master.class);
    System.out.println(master);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    结果截图
    在这里插入图片描述

    八、使用util名称空间

    和p命名空间一样我们同样需要在XML文件的头部添加声明xmlns:util="http://www.springframework.org/schema/util"
    在这里插入图片描述
    我们这里同样使用Matser类说明。

     
<util:list id="myList">
    <ref bean="monster01"/>
    <ref bean="monster02"/>
    <ref bean="monster03"/>
util:list>
<bean id="monster07" class="com.jl.spring.bean.Master">
    <property name="monsterList" ref="myList"/>
bean>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    测试代码

    @Test
public void  setBeanByUtil(){
     ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
     Master master = ioc.getBean("monster07", Master.class);
     System.out.println(master);
 }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    运行截图
    在这里插入图片描述
    因为我们这里只注入了monsterList属性，所以其他的属性都为null。

    当然util除了可以注入List，还可以注入其他的集合属性。在这里插入图片描述

    九、级联赋值

    级联赋值，从他这个名字就可以看出：它是属性的多级关联赋值。不懂也没有关系，我们下边会举例说明。

    首先我们的准备两个类：Dept、Emp

    package com.jl.spring.bean;

/**
 * @author Long
 * @date 2022/11/19
 * @CSDN https://blog.csdn.net/qq_35947021
 **/
public class Emp {
    private String name;
    private Dept dept;

    public Emp() {
    }

    public Emp(String name, Dept dept) {
        this.name = name;
        this.dept = dept;
    }

    public String getName() {
        return name;
    }

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

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "name='" + name + '\'' +
                ", dept=" + dept +
                '}';
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    package com.jl.spring.bean;

/**
 * @author Long
 * @date 2022/11/19
 * @CSDN https://blog.csdn.net/qq_35947021
 **/
public class Dept {
    private String name;
    public Dept() {
    }
    public Dept(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Dept{" +
                "name='" + name + '\'' +
                '}';
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    <bean id="emp" class="com.jl.spring.bean.Emp">
    <property name="name" value="jack"/>
    <property name="dept" ref="dept"/>
    <property name="dept.name" value="Java 开发部"/>
bean>
<bean id="dept" class="com.jl.spring.beans.Dept"/>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    我们可以通过在引用对象之后给引用的对象的属性进行赋值。这样方式就叫级联赋值。

    测试类

     @Test
public void  setBeanByCascadingValues(){
   ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
   Emp emp = ioc.getBean("emp", Emp.class);
   System.out.println(emp);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    结果截图
    在这里插入图片描述

     以上就是有关Spring中配置属性的内容，下一节我们继续讲解剩下的内容。如果文章中有描述不准确或者错误的地方，还望指正。您可以留言📫或者私信我。🙏
    最后希望大家多多 关注+点赞+收藏^_^，你们的鼓励是我不断前进的动力！！！
    感谢感谢~~~🙏🙏🙏

  • 相关阅读:
    2023数维杯国际赛数学建模竞赛选题建议及D题思路讲解
    号称年薪30万占比最多的专业，你知道是啥嘛？
    网页下拉菜单
    c#设计模式-结构型模式 之装饰者模式
    数独程序求解世界最难数独——JAVA版
    LeetCode每日一题——1822. 数组元素积的符号
    十天学前端之JS篇(四)
    RTX3090+win10+CUDA11.6+cudnn8.5.0+pytorch1.12.1 环境——个人配置经验
    3.NVIDIA Deepstream开发指南中文版--Deepstream 环境配置
    Using Set Processing Effectively 有效地使用集合处理
  • 原文地址：https://blog.csdn.net/qq_35947021/article/details/127937340