spring 注入集合类型 List、Set、Map

首先先看用到的类:

Class1,Class2

代码:

package my.spring.fuck;

public class Class1 implements Interface1{
    private String a;

    public String getA() {
        return a;
    }

    public void setA(String a) {
        this.a = a;
    }
    public void eat(String s){
        System.out.println(s+a);
    }
}
package my.spring.fuck;

import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

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

public class Class2 {
    private List<Class1> fuckList1;//集合统一装入Class1
    private List fuckList2;

    private Set<Class1> fuckSet1;
    private Set fuckSet2;

    private Map<String,String> fuckMap1;
    private Map<String,Class1> fuckMap2;

    public static void main(String[] args){
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        //Class2 c2=(Class2)ac.getBean("c2");
        Class2 c2=ac.getBean(Class2.class);
        c2.print();
    }

    public void print(){
        System.out.println("this is fuckList1");
        for(Class1 c1:fuckList1){
            c1.eat("");
        }

        System.out.println("this is fuckList2");
        for(int i=0;i<fuckList2.size();i++){
            ((Class1)fuckList2.get(i)).eat("");
        }

        System.out.println("this is fuckSet1");
        for(Class1 c1:fuckSet1){
            c1.eat("");
        }

        System.out.println("this is fuckSet2");
        Iterator<Class1> iterator=fuckSet2.iterator();
        while(iterator.hasNext()){
            (iterator.next()).eat("");
        }

        System.out.println("this is fuckMap1");
        System.out.println(fuckMap1.get("mapKey1"));

        System.out.println("this is fuckMap2");
        Class1 c1=fuckMap2.get("mapKey1");
        c1.eat("");
    }

    public List<Class1> getFuckList1() {
        return fuckList1;
    }

    public void setFuckList1(List<Class1> fuckList1) {
        this.fuckList1 = fuckList1;
    }

    public List getFuckList2() {
        return fuckList2;
    }

    public void setFuckList2(List fuckList2) {
        this.fuckList2 = fuckList2;
    }

    public Set<Class1> getFuckSet1() {
        return fuckSet1;
    }

    public void setFuckSet1(Set<Class1> fuckSet1) {
        this.fuckSet1 = fuckSet1;
    }

    public Set getFuckSet2() {
        return fuckSet2;
    }

    public void setFuckSet2(Set fuckSet2) {
        this.fuckSet2 = fuckSet2;
    }

    public Map<String, String> getFuckMap1() {
        return fuckMap1;
    }

    public void setFuckMap1(Map<String, String> fuckMap1) {
        this.fuckMap1 = fuckMap1;
    }

    public Map<String, Class1> getFuckMap2() {
        return fuckMap2;
    }

    public void setFuckMap2(Map<String, Class1> fuckMap2) {
        this.fuckMap2 = fuckMap2;
    }

}

application.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">

<beans>
    <bean id="c2" class="my.spring.fuck.Class2">
        <property name="fuckList1">
            <list>
                <ref bean="c1"/>
                <ref bean="c1"/>
            </list>
        </property>
        <property name="fuckList2">
            <list>
                <ref bean="c1"/>
                <ref bean="c1"/>
            </list>
        </property>
        <property name="fuckSet1">
            <set>
                <ref bean="c1"/>
                <ref bean="c1"/>
            </set>
        </property>
        <property name="fuckSet2">
            <set>
                <ref bean="c1"/>
                <ref bean="c1"/>
            </set>
        </property>
        <property name="fuckMap1">
            <map>
                <entry key="mapKey1" value="mapValue1"/>
            </map>
        </property>
        <property name="fuckMap2">
            <map>
                <entry key="mapKey1">
                    <ref bean="c1"/>
                </entry>
            </map>
        </property>
    </bean>
    <bean id="c1" class="my.spring.fuck.Class1">
        <property name="a" value="i am a">
        </property>
    </bean>
</beans>

运行Class2,控制台输出如下:

this is fuckList1
i am a
i am a
this is fuckList2
i am a
i am a
this is fuckSet1
i am a
this is fuckSet2
i am a
this is fuckMap1
mapValue1
this is fuckMap2
i am a
时间: 2024-10-19 04:49:53

spring 注入集合类型 List、Set、Map的相关文章

Spring 注入集合类型

定义了一个类: Java代码   @Service public class StringTest implements CachedRowSet,SortedSet<String>,Cloneable Java代码   @Controller public class HomeController { @Autowired CachedRowSet message; @Autowired CachedRowSet message1; } 这里CachedRowSet , 等其他接口都是可以注

Spring中集合类型属性注入

我们都知道如何去注入普通属性的值,非常简单,那么我们如何去注入开发中常见的集合类型的属性了,别急,往下看. 这里将介绍如何给Map list set Array Properties 这些属性注入值. 1.创建一个类:员工类Employee package cn.entity; /** * 员工类 * * @author hyj * */ public class Employee { //员工年龄 private Integer age; //员工姓名 private String name;

spring注入对象类型的属性

一.1.创建service类和Dao类 (1)在service中得到dao对象 2.具体实现过程 (1)在service里边把dao作为类型属性 (2)生成dao类型属性的set方法 public class UserDao { public void add(){ System.out.println("dao--------------"); } } public class UserService { private UserDao userDao; public void se

注入集合类型数据

Person: package com.ly.spring; import java.util.*; public class Person { private String[] strArr; private List<String> strList; private Map<String,String> strMap; private Set<String> strSet; private Properties prop; public void setStrArr

【spring set注入 注入集合】 使用set注入的方式注入List集合和Map集合/将一个bean注入另一个Bean

Dao层代码: 1 package com.it.dao; 2 3 public interface SayHell { 4 public void sayHello(); 5 } Dao的Impl实现层: 1 package com.it.dao.impl; 2 3 import java.util.List; 4 import java.util.Map; 5 6 import com.it.dao.SayHell; 7 8 /** 9 * Spring如何知道setter方法?如何将值注入

注入不同类型的值

1 注入直接量(基本数据类型+字符串) <value></value> 注意:特殊字符&,>,<的实体&,<,> 或者使用<![CDATA[ 内容 ]]> 2 注入bean <ref bean="bean的id值"/> 注意:bean属性可以引用配置文件引入的文件的bean的配置. local属性只能引用本配置文件的bean配置. 3 使用内部bean <property name="

springmvc:请求参数绑定集合类型

一.请求参数绑定实体类 domain: 1 private String username; 2 private String password; 3 private Double money; 4 5 private User user; 1 <%--把数据封装到Account类中--%> 2 <form action="param/saveAccount" method="post"> 3 姓名:<input type="

【Spring实战】—— 7 复杂集合类型的注入

之前讲解了Spring的基本类型和bean引用的注入,接下来学习一下复杂集合类型的注入,例如:List.Set.Map等. 对于程序员来说,掌握多种语言是基本的技能. 我们这里做了一个小例子,程序员们是一个Bean实例,而掌握的编程语言则是放入一个集合类型中进行注入. 简单的来说: List是一种按照序号标识的集合, Set与List相似但是元素不允许重复, Map则是一种自定的键值对,键值都可以是任意的类型. Bean的实现类 public class Programmer { public

spring心得4--setter注入集合(set、list、map、properties等多种集合,配有案例解析)@基本装(引用)

spring心得4--setter注入集合(set.list.map.properties等多种集合,配有案例解析)@基本装 1. 基本装配 在spring容器内拼凑bean叫做装配.装配bean的时候,需要告诉容器哪些bean以及容器如何使用依赖注入将它们配合在一起.    使用XML装配(xml是最常见的spring应用系统配置源.) 几种spring容器都支持使用xml装配bean,包括: 1).XmlBeanFactory:调用InputStream载入上下文定义文件. 2).Class