- 微信
- 微博
  
  分享文章到微博
- 复制链接
  
  复制链接到剪贴板

Spring-注入参数详解-[集合类型属性]

小工匠发表于 2021/09/10 00:44:35 2021/09/10

【摘要】概述常用集合 Set 实例 List 实例 Map 实例 Properties 实例强类型集合实例集合...

概述
常用集合
- Set
  - 实例
- List
  - 实例
- Map
  - 实例
- Properties
  - 实例
强类型集合
- - 实例
集合合并
- - 实例

概述

java.util包中的集合类型是最常用的结构数据类型，主要包括List、Set、Map、Properties。

Spring为这些集合类型属性提供了专属的配置标签

常用集合

代码已托管到Github—> https://github.com/yangshangwei/SpringMaster

Set

实例

POJO类

package com.xgj.ioc.inject.construct.jihe.set;

import java.util.Iterator;
import java.util.Set;

public class PetShop {

    private Pets pets;

    public void setPets(Pets pets) {
        this.pets = pets;
    }

    /**
     * 
     * 
     * @Title: petsInfo
     * 
     * @Description: 获取注入的set,遍历输出
     * 
     * 
     * @return: void
     */
    public void petsInfo() {
        Set<Object> set = pets.getSet();
        Iterator<Object> it = set.iterator();
        while (it.hasNext()) {
            System.out.println("PetShop has " + it.next());
        }
    }
}

  
 
  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

POJO类

package com.xgj.ioc.inject.construct.jihe.set;

import java.util.HashSet;
import java.util.Set;

public class Pets {

    private Set set = new HashSet();

    public Set getSet() {
        return set;
    }

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

}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19

配置文件

<?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="pets" class="com.xgj.ioc.inject.construct.jihe.set.Pets">
        <property name="set">
            <set>
                <value>bear</value>
                <value>dog</value>
                <value>cat</value>
                <value>snake</value>
                <value>pig</value>
            </set>
        </property>
    </bean>

    <bean id="petShop" class="com.xgj.ioc.inject.construct.jihe.set.PetShop">
        <property name="pets" ref="pets"/>
    </bean>

</beans>

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

测试类

package com.xgj.ioc.inject.construct.jihe.set;

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

public class InjectSetTest {
    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "classpath:com/xgj/ioc/inject/construct/jihe/set/beans.xml");

        PetShop shop = ctx.getBean("petShop", PetShop.class);

        shop.petsInfo();

    }
}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18

运行结果

List

List属性既可以通过注入字符串，也可以通过注入容器中其他的Bean

实例

POJO类

package com.xgj.ioc.inject.construct.jihe.list;

public class PetShop {

    private Pets pets;

    public void setPets(Pets pets) {
        this.pets = pets;
    }

    /**
     * 
     * 
     * @Title: petsInfo
     * 
     * @Description: 获取容器注入的List，遍历输出
     * 
     * 
     * @return: void
     */
    public void petsInfo() {
        for (int i = 0; i < pets.getPetsList().size(); i++) {
            System.out.println("PetShop has " + pets.getPetsList().get(i));
        }
    }

}

  
 
  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

POJO类

package com.xgj.ioc.inject.construct.jihe.list;

import java.util.ArrayList;
import java.util.List;

public class Pets {

    private List petsList = new ArrayList();

    public List getPetsList() {
        return petsList;
    }

    public void setPetsList(List petsList) {
        this.petsList = petsList;
    }

}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19

配置文件

<?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="pets" class="com.xgj.ioc.inject.construct.jihe.list.Pets">
        <property name="petsList">
            <list>
                <value>dog</value>
                <value>cat</value>
                <value>bear</value>
                <value>rabbit</value>
                <value>bird</value>
            </list>
        </property>
    </bean>

    <bean id="petShop" class="com.xgj.ioc.inject.construct.jihe.list.PetShop">
        <property name="pets">
            <ref bean="pets"/>
        </property>
    </bean>

</beans>

  
 
  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

测试类

package com.xgj.ioc.inject.construct.jihe.list;

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

public class InjectListTest {

    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "classpath:com/xgj/ioc/inject/construct/jihe/list/beans.xml");

        PetShop shop = ctx.getBean("petShop", PetShop.class);

        shop.petsInfo();

    }
}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19

运行结果

假设一个属性类型可以通过字符串字面值进行配置，那么该类型对应的数组类型的属性比入String[],int[]也可以采用<list>方式进行配置.

Map

实例

POJO类

package com.xgj.ioc.inject.construct.jihe.map;

import java.util.Map;

public class PetShop {

    private Pets pets;

    public void setPets(Pets pets) {
        this.pets = pets;
    }

    /**
     * 
     * 
     * @Title: petsInfo
     * 
     * @Description: 获取容器注入的Map，遍历输出
     * 
     * 
     * @return: void
     */
    public void petsInfo() {

        Map<Object, Object> map = pets.getMap();

        for (Map.Entry<Object, Object> entry : map.entrySet()) {

            System.out.println("编号Key = " + entry.getKey() + ",品种Value = "
                    + entry.getValue());

        }
    }
}

  
 
  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

POJO类

package com.xgj.ioc.inject.construct.jihe.map;

import java.util.HashMap;
import java.util.Map;

public class Pets {

    private Map map = new HashMap();

    public Map getMap() {
        return map;
    }

    public void setMap(Map map) {
        this.map = map;
    }

}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19

配置文件

<?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="pets" class="com.xgj.ioc.inject.construct.jihe.map.Pets">
        <property name="map">
            <map>
                <entry>
                    <key>
                        <value>135</value>
                    </key>
                    <value>cat</value>
                </entry>
                <entry>
                    <key>
                        <value>137</value>
                    </key>
                    <value>bird</value>
                </entry>
                <entry>
                    <key>
                        <value>139</value>
                    </key>
                    <value>dog</value>
                </entry>
            </map>
        </property>
    </bean>

    <bean id="petShop" class="com.xgj.ioc.inject.construct.jihe.map.PetShop">
        <property name="pets" ref="pets" />
    </bean>

</beans>

  
 
  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

测试类

package com.xgj.ioc.inject.construct.jihe.map;

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

public class InjectMapTest {

    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "classpath:com/xgj/ioc/inject/construct/jihe/map/beans.xml");

        PetShop shop = ctx.getBean("petShop", PetShop.class);

        shop.petsInfo();

    }
}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19

运行结果：

如果Map元素的key和value都是对象，这可以采用以下配置方式

<entry>
    <key>
        <ref bean="keyBbean"/>
    </key>
    <ref bean="valueBean">
</entry>
  
 
  1
  2
  3
  4
  5
  6

Properties

Propertites键值对可以看做Map类型的特例， Map的键值对可以是任何类型，Properties的键值对只能是字符串，因此配置简单一些，注意Value的配置没有<value>子元素标签

实例

POJO类

package com.xgj.ioc.inject.construct.jihe.properties;

import java.util.Map;

public class PetShop {

    private Pets pets;

    public void setPets(Pets pets) {
        this.pets = pets;
    }

    /**
     * 
     * 
     * @Title: petsInfo
     * 
     * @Description: 获取容器注入的Map，遍历输出
     * 
     * 
     * @return: void
     */
    public void petsInfo() {

        Map<Object, Object> map = pets.getProperties();

        for (Map.Entry<Object, Object> entry : map.entrySet()) {

            System.out.println("编号Key = " + entry.getKey() + ",品种Value = "
                    + entry.getValue());

        }
    }
}

  
 
  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

POJO类

package com.xgj.ioc.inject.construct.jihe.properties;

import java.util.Properties;

public class Pets {

    private Properties properties;

    public Properties getProperties() {
        return properties;
    }

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

}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18

配置文件

<?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="pets" class="com.xgj.ioc.inject.construct.jihe.properties.Pets">
        <property name="properties">
            <props>
                <prop key="101">cat</prop>
                <prop key="103">dog</prop>
                <prop key="105">bird</prop>
            </props>
        </property>
    </bean>

    <bean id="petShop" class="com.xgj.ioc.inject.construct.jihe.properties.PetShop">
        <property name="pets" ref="pets" />
    </bean>

</beans>

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

测试类

package com.xgj.ioc.inject.construct.jihe.properties;

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

public class InjectPropertiesTest {

    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "classpath:com/xgj/ioc/inject/construct/jihe/properties/beans.xml");

        PetShop shop = ctx.getBean("petShop", PetShop.class);

        shop.petsInfo();

    }
}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19

运行结果

强类型集合

Java5.0提供了强类型集合的新功能，允许为集合元素指定特定类型。

实例

POJO类

package com.xgj.ioc.inject.construct.jihe.strongType;

import java.util.Map;

public class PetShop {

    private Pets pets;

    public void setPets(Pets pets) {
        this.pets = pets;
    }

    /**
     * 
     * 
     * @Title: petsInfo
     * 
     * @Description: 获取容器注入的Map，遍历输出
     * 
     * 
     * @return: void
     */
    public void petsInfo() {

        Map<Integer, String> map = pets.getMap();

        for (Map.Entry<Integer, String> entry : map.entrySet()) {

            System.out.println("编号Key = " + entry.getKey() + ",品种Value = "
                    + entry.getValue());

        }
    }
}

  
 
  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

POJO类

package com.xgj.ioc.inject.construct.jihe.strongType;

import java.util.HashMap;
import java.util.Map;

public class Pets {

    private Map<Integer, String> map = new HashMap<Integer, String>();

    public Map<Integer, String> getMap() {
        return map;
    }

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

}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19

配置文件

<?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="pets" class="com.xgj.ioc.inject.construct.jihe.strongType.Pets">
        <property name="map">
            <map>
                <entry>
                    <key>
                        <!-- 为Integer提供值,spring在设置值时，会转换为定义的Integer类型 -->
                        <value>111</value>
                    </key>
                    <value>cat</value>
                </entry>
                <entry>
                    <key>
                        <value>113</value>
                    </key>
                    <value>bird</value>
                </entry>
                <entry>
                    <key>
                        <value>115</value>
                    </key>
                    <value>dog</value>
                </entry>
            </map>
        </property>
    </bean>

    <bean id="petShop" class="com.xgj.ioc.inject.construct.jihe.strongType.PetShop">
        <property name="pets" ref="pets" />
    </bean>

</beans>

  
 
  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

测试类

package com.xgj.ioc.inject.construct.jihe.strongType;

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

public class InjectStrongTypeTest {

    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "classpath:com/xgj/ioc/inject/construct/jihe/strongType/beans.xml");

        PetShop shop = ctx.getBean("petShop", PetShop.class);

        shop.petsInfo();

    }
}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19

运行结果

集合合并

Spring支持集合合并的功能，允许子bean继承父bean的同名属性集合元素，并将子bean和父bean中配置的集合属性组合并起来作为最终的bean的属性值。

实例

POJO类

package com.xgj.ioc.inject.construct.jihe.merge;

import java.util.Map;

public class PetShop {

    private Pets pets;

    public void setPets(Pets pets) {
        this.pets = pets;
    }

    /**
     * 
     * 
     * @Title: petsInfo
     * 
     * @Description: 获取容器注入的Map，遍历输出
     * 
     * 
     * @return: void
     */
    public void petsInfo() {

        Map<Integer, String> map = pets.getMap();

        for (Map.Entry<Integer, String> entry : map.entrySet()) {

            System.out.println("编号Key = " + entry.getKey() + ",品种Value = "
                    + entry.getValue());

        }
    }
}

  
 
  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

POJO类

package com.xgj.ioc.inject.construct.jihe.merge;

import java.util.HashMap;
import java.util.Map;

public class Pets {

    private Map<Integer, String> map = new HashMap<Integer, String>();

    public Map<Integer, String> getMap() {
        return map;
    }

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

}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19

配置文件

<?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 abstract="true" -->
    <bean id="parentPets"   abstract="true" class="com.xgj.ioc.inject.construct.jihe.merge.Pets">
        <property name="map">
            <map>
                <entry>
                    <key>
                        <!-- 为Integer提供值,spring在设置值时，会转换为定义的Integer类型 -->
                        <value>111</value>
                    </key>
                    <value>cat</value>
                </entry>
                <entry>
                    <key>
                        <value>113</value>
                    </key>
                    <value>bird</value>
                </entry>
                <entry>
                    <key>
                        <value>115</value>
                    </key>
                    <value>dog</value>
                </entry>
            </map>
        </property>
    </bean>

    <bean id="pets" parent="parentPets"> <!-- 指定父Bean -->
        <property name="map">
            <!-- 设置merge="true" 和父bean的同名集合属性合并 -->
            <map merge="true"> 
                <entry>
                    <key>
                        <value>117</value>
                    </key>
                    <value>monkey</value>
                </entry>
            </map>
        </property>
    </bean>

    <bean id="petShop" class="com.xgj.ioc.inject.construct.jihe.merge.PetShop">
        <property name="pets" ref="pets" />
    </bean>

</beans>

  
 
  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

测试类

package com.xgj.ioc.inject.construct.jihe.merge;

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

public class InjectStrongTypeTest {

    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "classpath:com/xgj/ioc/inject/construct/jihe/merge/beans.xml");

        PetShop shop = ctx.getBean("petShop", PetShop.class);

        shop.petsInfo();

    }
}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19

运行结果

文章来源: artisan.blog.csdn.net，作者：小小工匠，版权归原作者所有，如需转载，请联系作者。

原文链接：artisan.blog.csdn.net/article/details/75515029

点赞
收藏
关注作者

0/1000

抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认取消

加入云驻计划，成为创作者

华为云周边好礼
免费体验产品
特殊身份标识
线下官方门票
内部专家零距离
与10000+优质创作者共同成长

立即加入

Spring-注入参数详解-[集合类型属性]

概述

常用集合

Set

实例

List

实例

Map

实例

Properties

实例

强类型集合

实例

集合合并

实例

全部回复

设置昵称

关于作者

目录

加入云驻计划，成为创作者

Spring-注入参数详解-[集合类型属性]

概述

常用集合

Set

实例

List

实例

Map

实例

Properties

实例

强类型集合

实例

集合合并

实例

全部回复

设置昵称

关于作者

目录

加入云驻计划，成为创作者

推荐阅读

相关产品