05_集合对象注入

【工程截图】

【Some.java】

package com.HigginCui;

public class Some {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String toString() {
        return "some [name=" + name + "]";
    }
}

【SomeBean.java】

package com.HigginCui;
import java.util.List;
import java.util.Map;

public class SomeBean {
    private String[] someStrArray; //字符串数组
    private Some[] someObjArray;   //类数组
    private List someList;           //List集合
    private Map someMap;           //Map集合
    public String[] getSomeStrArray() {
        return someStrArray;
    }
    public void setSomeStrArray(String[] someStrArray) {
        this.someStrArray = someStrArray;
    }
    public Some[] getSomeObjArray() {
        return someObjArray;
    }
    public void setSomeObjArray(Some[] someObjArray) {
        this.someObjArray = someObjArray;
    }
    public List getSomeList() {
        return someList;
    }
    public void setSomeList(List someList) {
        this.someList = someList;
    }
    public Map getSomeMap() {
        return someMap;
    }
    public void setSomeMap(Map someMap) {
        this.someMap = someMap;
    }
}

【applicationContext.xml】

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:aop="http://www.springframework.org/schema/aop"
       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-2.5.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

    <bean id="some1" class="com.HigginCui.Some">
        <property name="name">
            <value>HigginCui</value>
        </property>
    </bean>

    <bean id="some2" class="com.HigginCui.Some">
        <property name="name">
            <value>Jack</value>
        </property>
    </bean>
    <!--
        1.对于数组或List类型的依赖注入，在编写定义文件时，用<list>标签，并使用<value>标签指定字符串
             或是使用<ref>标签来参考至其它的bean实例
        2.对于Map类型的依赖关系注入则是使用<map>标签，map必须指定key-value
             所以要用<entry>标签来指定<key>,然后使用<value>标签指定字符串
             或是使用<ref>来参考至其它的bean实例
    -->
    <bean id="someBean" class="com.HigginCui.SomeBean">
        <!-- 字符串数组: String[] someStrArray;-->
        <property name="someStrArray">
            <list>
                <value>Hello</value>
                <value>world...</value>
            </list>
        </property>
        <!-- Some类数组:Some[] someObjArray; -->
        <property name="someObjArray">
            <list>
                <ref bean="some1"/>
                <ref bean="some2"/>
            </list>
        </property>
        <!-- List集合：List someList; -->
        <property name="someList">
            <list>
                <value>ListTest</value>
                <ref bean="some1"/>
                <ref bean="some2"/>
            </list>
        </property>
        <!-- Map集合：Map someMap; -->
        <property name="someMap">
            <map>
                <entry key="MapTest">
                    <value>Hello HigginCui!</value>
                </entry>
                <entry key="someKey1">
                    <ref bean="some1"/>
                </entry>
            </map>
        </property>
    </bean>
</beans>

【TestAll.java】

package com.HigginCui.test;

import java.util.List;
import java.util.Map;

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

import com.HigginCui.Some;
import com.HigginCui.SomeBean;

public class TestAll {
    @Test
    public void testSomeBean(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        SomeBean someBean=(SomeBean) context.getBean("someBean");
        //取得字符串数组类型依赖注入对象
        String[] strs=someBean.getSomeStrArray();
        for(int i=0;i<strs.length;i++){
            System.out.println("strs["+i+"]= "+strs[i]);
        }
        //取得Some类数组类型依赖注入对象
        Some[] somes=someBean.getSomeObjArray();
        for(int i=0;i<somes.length;i++){
            System.out.println("some["+i+"].name="+somes[i].getName());
        }
        //取得List类型依赖注入对象
        List someList=someBean.getSomeList();
        for(int i=0;i<someList.size();i++){
            System.out.println("someList.get("+i+")="+someList.get(i));
        }
        //取得Map类型依赖注入对象
        Map someMap=someBean.getSomeMap();
        System.out.println(someMap.get("MapTest"));
        System.out.println(someMap.get("someKey1"));

    }
}

【运行结果】

strs[0]= Hello
strs[1]= world...
some[0].name=HigginCui
some[1].name=Jack
someList.get(0)=ListTest
someList.get(1)=some [name=HigginCui]
someList.get(2)=some [name=Jack]
Hello HigginCui!
some [name=HigginCui]

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:aop="http://www.springframework.org/schema/aop"       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-2.5.xsd           http://www.springframework.org/schema/aop            http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">        <bean id="some1" class="com.HigginCui.Some">    <property name="name">    <value>HigginCui</value>    </property>    </bean>        <bean id="some2" class="com.HigginCui.Some">    <property name="name">    <value>Jack</value>    </property>    </bean>    <!--     1.对于数组或List类型的依赖注入，在编写定义文件时，用<list>标签，并使用<value>标签指定字符串        或是使用<ref>标签来参考至其它的bean实例    2.对于Map类型的依赖关系注入则是使用<map>标签，map必须指定key-value        所以要用<entry>标签来指定<key>,然后使用<value>标签指定字符串        或是使用<ref>来参考至其它的bean实例     -->    <bean id="someBean" class="com.HigginCui.SomeBean">    <!-- 字符串数组: String[] someStrArray;-->    <property name="someStrArray">    <list>    <value>Hello</value>    <value>world...</value>    </list>    </property>    <!-- Some类数组:Some[] someObjArray; -->    <property name="someObjArray">    <list>    <ref bean="some1"/>    <ref bean="some2"/>    </list>    </property>    <!-- List集合：List someList; -->    <property name="someList">    <list>    <value>ListTest</value>    <ref bean="some1"/>    <ref bean="some2"/>    </list>    </property>    <!-- Map集合：Map someMap; -->    <property name="someMap">    <map>    <entry key="MapTest">    <value>Hello HigginCui!</value>    </entry>    <entry key="someKey1">    <ref bean="some1"/>    </entry>    </map>    </property>    </bean></beans>

时间： 2024-10-03 14:55:31

05_集合对象注入的相关文章

Spring系列【08】为JavaBean的集合对象注入属性值

TestUtil.java 1 package com.lh.util; 2 3 import java.util.List; 4 import java.util.Map; 5 import java.util.Set; 6 7 public class TestUtil { 8 @Override 9 public String toString() { 10 return "TestUtil [list=" + list + ", set=" + set +

spring学习之集合属性注入

spring中对象之间的相互依赖关系是通过applicationContext.xml来管理的,因此集合属性注入的重点也放在applicationContext.xml的配置之中. 下面是一个完整的各种集合属性注入的例子 目录结构: 实体类 public class Students { private String sid; private String sname; private int age; public Students() { super(); } public Students

转载---Java集合对象的深度复制与普通复制

原博文:http://blog.csdn.net/qq_29329775/article/details/49516247 最近在做算法作业时出现了错误,原因是没有弄清楚java集合的深度复制和浅度复制的区别. 1.首先是对Java集合对象得浅复制与深度复制的理解 普通的集合复制只是将内存中栈的地址快拷贝一份,使得一个新的集合对象指向这个地址块,但是集合中的对象变量却是指向堆中的同一块区域.所以当拷贝的集合修改了集合对象内的数据,那么源集合对象也就随之改变了,这样的效果我们称之为Java集合对象

解析PHP对象注入漏洞

 0.前言 逛乌云知识库的时候看到一篇有趣的译文:http://drops.wooyun.org/papers/4820. 说的是一种注入方式,叫对象注入.对象也能注入? 是的,只要是存在污染数据,没有什么是不可能注入的,但是这个漏洞有点太古怪了,所以我觉得有趣. 1.原理 在程序编写的时候,往往需要序列化一些运行时数据,所谓序列化就是按照一定的格式将运行时数据写入本地文件.这样做可以对数据进行本地保存,用的时候直接读文件就可以把运行时产生的数据读出.在PHP中就是serialize和uns

struts2将servlet对象注入到Action中

在struts2框架中,可以通过IoC方式将servlet对象注入到Action中,通常需要Action实现以下接口: a. ServletRequestAware: 实现该接口的Action可以直接访问Request对象,该接口中提供void setServletRequest(HttpServletRequest request) 方法,实现此接口的Action控制类通过setServletRequestHttpServlet(HttpServlet request)方法将request对象

java集合对象区别二

集合包是Java中最常用的包,它最常用的有Collection和Map两个接口的实现类,Collection用于存放多个单对象,Map用于存放Key-Value形式的键值对. Collection中常用的又分为两种类型的接口:List和Set,两者最明显的差别为List支持放入重复的对象,而Set不支持.List接口常用的实现类有:ArrayList,LinkedList,Vector和Stack:Set接口常用的实现有HashSet,TreeSet.而Map的常用实现有TreeMap和Hash

.net集合对象解惑篇

.Net中大量的集合对象是否曾让你头痛,那么现在就让我作为你的"导游"带着你走出来.帮助你在System.Collections名域中找到自己的方向. 集合提供了一种将任意对象格式化存储的方法,我们都知道在日常的程序设计中,它们是多么有帮助.接下来就随我找到它并认识它. 一.定义    从.NET的角度来看,一个集合可以被定义为一个实现了一个或多个System.Collections.ICollection.System.Collections.IDictionary和System.C

从头认识Spring-1.7 怎样通过属性注入Bean？（2）-怎样通过属性向对象注入另一个对象的引用？

这一章节我们继续上面的话题. 2.怎样通过属性向对象注入另一个对象的引用? (1)domain 我们除了蛋糕类,还需要引用前面的厨师类 package com.raylee.my_new_spring.my_new_spring.ch01.topic_1_7; public class Cake { private final int id = index++; private static int index = 0; private String name = ""; privat

从头认识Spring-1.7 怎样通过属性注入Bean？（1）-怎样通过属性向对象注入值？

这一章节我们来讨论一下怎样通过属性注入Bean? 这一章节分为两部分,第一部分我们通过属性向对象注入值,第二部分我们通过属性向对象注入另一个对象的引用. 1.怎样通过属性向对象注入值? (1)domain package com.raylee.my_new_spring.my_new_spring.ch01.topic_1_7; public class Cake { private final int id = index++; private static int index = 0; pr