sprinboot redisearch 复杂 spring太复杂

复杂类型注入,刚才都是属性,这个叫注入方式,下面再来一个复杂类型注入,来看一下复杂类型注入行为,

复杂类型注入呢,指的是,咱们刚才的注入类型,无非就是值或者对象,假设遇到数组,List,Map,Properties,

遇到这种属性,咱们该如何来完成注入,那这个比较简单,就是看人家写法怎么写的,咱们直接看例子,这个例子就

不需要新建包了,在这里再新建一个class,叫做CollectionBean,然后在这个Bean当中,声明四个属性,String数组,

Object数组,这个叫arr,用这个属性来测试,数组类型值怎么注入,数组类型注入,咱们再来一个List,咱们再来看看

List是如何来注入,自然也少不了Map,大家看,map类型注入,这里我说一下,list和set注入方式是一样的,然后再往下,

最后一个就是咱们的Properties,这个类大家都用过吧,肯定用过,用过propertie文件,肯定那这个Properties类读取过,

Properties说白了就是一个Map,键值对都是String,因为配置文件中只有文本信息,properties类型的注入,四个类型如何

注入,生成get/set方法,那这个对象准备好之后,我们到配置文件当中

package com.learn.c_injection;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;

public class CollectionBean {
	
	/**
	 * 数组类型注入
	 */
	private Object[] arr;
	
	/**
	 * List/set类型注入
	 */
	private List list;
	
	/**
	 * map类型注入
	 */
	private Map map;
	
	private Properties prop;

	public Object[] getArr() {
		return arr;
	}

	public void setArr(Object[] arr) {
		this.arr = arr;
	}

	public List getList() {
		return list;
	}

	public void setList(List list) {
		this.list = list;
	}

	public Map getMap() {
		return map;
	}

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

	public Properties getProp() {
		return prop;
	}

	public void setProp(Properties prop) {
		this.prop = prop;
	}

	@Override
	public String toString() {
		return "CollectionBean [arr=" + Arrays.toString(arr) + ", list=" + list + ", map=" + map + ", prop=" + prop
				+ "]";
	}

}

然后分隔线下边咱们来看一下,复杂类型注入,那第一个,array就是数组,来一个bean,然后有name,还有class,

必须的,class咱们叫CollectionBean,咱们叫做cb,接下来我们给bean当中,注入属性,咱们使用Property来做,

然后name先找arr,到这开始看好,这个arr这个属性,就像Object数组,所以,普通类型值可能只有一个,不管是引用

还是对象,而咱们数组的话,这里面是可以放多个值或者多个对象,那这里面先说,如果你真的只有一个值或者一个对象的

话,那么你可以像注入普通属性一样,使用value,或者ref来注入,这是数组只有一个属性的情况,比如这里咱们来一个tom,

在这写一下,如果数组中只准备注入一个值,或者对象,那么直接使用咱们的value或ref即可

<?xml version="1.0" encoding="UTF-8"?>
<beans  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
		xmlns="http://www.springframework.org/schema/beans" 
		xmlns:p="http://www.springframework.org/schema/p"
		xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">

	<!-- set方式注入 -->
	<bean name="user" class="com.learn.bean.User">
		<!-- 为User对象中名为name的属性注入tom作为值 -->
		<property name="name" value="tom"></property>
		<property name="age" value="18"></property>
		<!-- 为car属性注入下方配置的car对象 -->
		<property name="car" ref="car"></property>
	</bean>
	
	<!-- 将car对象配置到容器中 -->
	<bean name="car" class="com.learn.bean.Car">
		<property name="name" value="兰博基尼"></property>
		<property name="color" value="黄色"></property>
	</bean>
	
	<!--  =============================================================  -->
	
	<!-- 构造函数注入 -->
	<bean name="user2" class="com.learn.bean.User">
		<!-- name属性:构造函数的参数名 -->
		<!-- index属性:构造函数的参数索引 -->
		<!-- type属性:构造函数的参数类型 -->
		<constructor-arg name="name" value="999" index="0" type="java.lang.Integer"></constructor-arg>
		<constructor-arg name="car" ref="car" index="1"></constructor-arg>
	</bean>
	
	<!-- ============================================================= -->
	
	<!-- p名称空间注入 
		1.导入p名称空间 xmlns:p="http://www.springframework.org/schema/p"
		2.使用p:属性完成注入
			|-值类型: p:属性名="值"
			|-对象类型: p:属性名-ref="bean名称"
	-->
	<bean name="user3" class="com.learn.bean.User" p:name="jack" p:age="20" p:car-ref="car">
	</bean>
	
	<!-- ============================================================= -->
	<!-- spel注入:spring Expression Language spring表达式语言 -->
	<bean name="user4" class="com.learn.bean.User" >
		<property name="name" value="#{user.name}"></property>
		<property name="age" value="#{user3.age}"></property>
		<property name="car" ref="car"></property>
	</bean>
	
	<!-- ============================================================= -->
	<!-- 复杂类型注入 -->
	<!-- array注入 -->
	<bean name="cb" class="com.learn.c_injection.CollectionBean">
		<!-- 如果数组中只准备注入一个值(对象),直接使用value|ref即可 -->
		<property name="arr" value="tom"></property>
	</bean>
</beans>

给他这个CollectionBean生成一个toString方法,刚才咱们声明的cb,类型是不是CollectionBean,

这块咱们cb,转换的话也是CollectionBean,然后打印cb,是不是就把tom注入到数组当中了

@Test
	public void fun5() {
		
		/**
		 * 1.创建容器
		 */
		ApplicationContext ac = new ClassPathXmlApplicationContext("com/learn/c_injection/applicationContext.xml");
		
		CollectionBean cb = (CollectionBean)ac.getBean("cb");
		
		System.out.println(cb);
		
	}

User空参构造方法
User(Integer name, Car car)
User空参构造方法
User空参构造方法
CollectionBean [arr=[tom], list=null, map=null, prop=null]

arr是一个数组,接下来咱们再来看,如果一个值不够,然后咱们再来一个property,name等于arr,

然后看好,多个值怎么办呢,就需要使用array的子元素,就表示要为数组注入值了,那数组注入值的话,

value元素来注入值类型的,咱们有tom,jerry,那arr就有值类型的,那对象怎么注入,ref属性的,ref使用

一个Bean属性,比如咱们把user4放到数组中来,这样就数组有三个元素,两个值类型的,和一个user,那这个还是

array注入,还是array注入,这个是多个元素注入,那接下来咱们在Demo里面测试一下

<?xml version="1.0" encoding="UTF-8"?>
<beans  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
		xmlns="http://www.springframework.org/schema/beans" 
		xmlns:p="http://www.springframework.org/schema/p"
		xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">

	<!-- set方式注入 -->
	<bean name="user" class="com.learn.bean.User">
		<!-- 为User对象中名为name的属性注入tom作为值 -->
		<property name="name" value="tom"></property>
		<property name="age" value="18"></property>
		<!-- 为car属性注入下方配置的car对象 -->
		<property name="car" ref="car"></property>
	</bean>
	
	<!-- 将car对象配置到容器中 -->
	<bean name="car" class="com.learn.bean.Car">
		<property name="name" value="兰博基尼"></property>
		<property name="color" value="黄色"></property>
	</bean>
	
	<!--  =============================================================  -->
	
	<!-- 构造函数注入 -->
	<bean name="user2" class="com.learn.bean.User">
		<!-- name属性:构造函数的参数名 -->
		<!-- index属性:构造函数的参数索引 -->
		<!-- type属性:构造函数的参数类型 -->
		<constructor-arg name="name" value="999" index="0" type="java.lang.Integer"></constructor-arg>
		<constructor-arg name="car" ref="car" index="1"></constructor-arg>
	</bean>
	
	<!-- ============================================================= -->
	
	<!-- p名称空间注入 
		1.导入p名称空间 xmlns:p="http://www.springframework.org/schema/p"
		2.使用p:属性完成注入
			|-值类型: p:属性名="值"
			|-对象类型: p:属性名-ref="bean名称"
	-->
	<bean name="user3" class="com.learn.bean.User" p:name="jack" p:age="20" p:car-ref="car">
	</bean>
	
	<!-- ============================================================= -->
	<!-- spel注入:spring Expression Language spring表达式语言 -->
	<bean name="user4" class="com.learn.bean.User" >
		<property name="name" value="#{user.name}"></property>
		<property name="age" value="#{user3.age}"></property>
		<property name="car" ref="car"></property>
	</bean>
	
	<!-- ============================================================= -->
	<!-- 复杂类型注入 -->
	<bean name="cb" class="com.learn.c_injection.CollectionBean">
		<!-- 如果数组中只准备注入一个值(对象),直接使用value|ref即可 -->
		<!-- <property name="arr" value="tom"></property> -->
		<property name="arr">
		
			<!-- array注入 -->
			<array>
				<value>tom</value>
				<value>jerry</value>
				<ref bean="user4"/>
			</array>
		</property>
	</bean>
</beans>

@Test
	public void fun5() {
		
		/**
		 * 1.创建容器
		 */
		ApplicationContext ac = new ClassPathXmlApplicationContext("com/learn/c_injection/applicationContext.xml");
		
		CollectionBean cb = (CollectionBean)ac.getBean("cb");
		
		System.out.println(cb);
		
	}

User空参构造方法
User(Integer name, Car car)
User空参构造方法
User空参构造方法
CollectionBean [arr=[tom, jerry, User [name=tom, age=20, car=Car [name=兰博基尼, color=黄色]]], list=null, map=null, prop=null]

你看看arr里面,也是tom,jerry,是不是这两个字符串,这user是咱们注入的一个对象,这样的话咱们的array就

研究完了,List还是在这个bean当中,然后再书写property,property再给list赋一个值,list其实和array是一样的,

如果你这个list当中只有一个值,那你可以同样使用value或者ref注入,这里我们要把它变成ref,这个名字我们换一下

叫做jack

<?xml version="1.0" encoding="UTF-8"?>
<beans  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
		xmlns="http://www.springframework.org/schema/beans" 
		xmlns:p="http://www.springframework.org/schema/p"
		xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">

	<!-- set方式注入 -->
	<bean name="user" class="com.learn.bean.User">
		<!-- 为User对象中名为name的属性注入tom作为值 -->
		<property name="name" value="tom"></property>
		<property name="age" value="18"></property>
		<!-- 为car属性注入下方配置的car对象 -->
		<property name="car" ref="car"></property>
	</bean>
	
	<!-- 将car对象配置到容器中 -->
	<bean name="car" class="com.learn.bean.Car">
		<property name="name" value="兰博基尼"></property>
		<property name="color" value="黄色"></property>
	</bean>
	
	<!--  =============================================================  -->
	
	<!-- 构造函数注入 -->
	<bean name="user2" class="com.learn.bean.User">
		<!-- name属性:构造函数的参数名 -->
		<!-- index属性:构造函数的参数索引 -->
		<!-- type属性:构造函数的参数类型 -->
		<constructor-arg name="name" value="999" index="0" type="java.lang.Integer"></constructor-arg>
		<constructor-arg name="car" ref="car" index="1"></constructor-arg>
	</bean>
	
	<!-- ============================================================= -->
	
	<!-- p名称空间注入 
		1.导入p名称空间 xmlns:p="http://www.springframework.org/schema/p"
		2.使用p:属性完成注入
			|-值类型: p:属性名="值"
			|-对象类型: p:属性名-ref="bean名称"
	-->
	<bean name="user3" class="com.learn.bean.User" p:name="jack" p:age="20" p:car-ref="car">
	</bean>
	
	<!-- ============================================================= -->
	<!-- spel注入:spring Expression Language spring表达式语言 -->
	<bean name="user4" class="com.learn.bean.User" >
		<property name="name" value="#{user.name}"></property>
		<property name="age" value="#{user3.age}"></property>
		<property name="car" ref="car"></property>
	</bean>
	
	<!-- ============================================================= -->
	<!-- 复杂类型注入 -->
	<bean name="cb" class="com.learn.c_injection.CollectionBean">
		<!-- 如果数组中只准备注入一个值(对象),直接使用value|ref即可 -->
		<!-- <property name="arr" value="tom"></property> -->
		<property name="arr">
		
			<!-- array注入 -->
			<array>
				<value>tom</value>
				<value>jerry</value>
				<ref bean="user4"/>
			</array>
		</property>
		
		<property name="list" value="jack"></property>
		
	</bean>
</beans>

再来执行一下Demo5,你看看list当中是不是只有一个jack

@Test
	public void fun5() {
		
		/**
		 * 1.创建容器
		 */
		ApplicationContext ac = new ClassPathXmlApplicationContext("com/learn/c_injection/applicationContext.xml");
		
		CollectionBean cb = (CollectionBean)ac.getBean("cb");
		
		System.out.println(cb);
		
	}

CollectionBean [arr=[tom, jerry, User [name=tom, age=20, car=Car [name=兰博基尼, color=黄色]]], list=[jack], map=null, prop=null]

如果list当中你想放入多个值,那该怎么写,把这个property复制一个新的,跟这个array是不是一样啊,

只不过你这里面的元素不使用array了,使用list了,而剩下的一样的,把这三个复制一下,给他换个名,jack,

rose,然后,比如user3,这样的话再来执行一下

<?xml version="1.0" encoding="UTF-8"?>
<beans  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
		xmlns="http://www.springframework.org/schema/beans" 
		xmlns:p="http://www.springframework.org/schema/p"
		xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">

	<!-- set方式注入 -->
	<bean name="user" class="com.learn.bean.User">
		<!-- 为User对象中名为name的属性注入tom作为值 -->
		<property name="name" value="tom"></property>
		<property name="age" value="18"></property>
		<!-- 为car属性注入下方配置的car对象 -->
		<property name="car" ref="car"></property>
	</bean>
	
	<!-- 将car对象配置到容器中 -->
	<bean name="car" class="com.learn.bean.Car">
		<property name="name" value="兰博基尼"></property>
		<property name="color" value="黄色"></property>
	</bean>
	
	<!--  =============================================================  -->
	
	<!-- 构造函数注入 -->
	<bean name="user2" class="com.learn.bean.User">
		<!-- name属性:构造函数的参数名 -->
		<!-- index属性:构造函数的参数索引 -->
		<!-- type属性:构造函数的参数类型 -->
		<constructor-arg name="name" value="999" index="0" type="java.lang.Integer"></constructor-arg>
		<constructor-arg name="car" ref="car" index="1"></constructor-arg>
	</bean>
	
	<!-- ============================================================= -->
	
	<!-- p名称空间注入 
		1.导入p名称空间 xmlns:p="http://www.springframework.org/schema/p"
		2.使用p:属性完成注入
			|-值类型: p:属性名="值"
			|-对象类型: p:属性名-ref="bean名称"
	-->
	<bean name="user3" class="com.learn.bean.User" p:name="jack" p:age="20" p:car-ref="car">
	</bean>
	
	<!-- ============================================================= -->
	<!-- spel注入:spring Expression Language spring表达式语言 -->
	<bean name="user4" class="com.learn.bean.User" >
		<property name="name" value="#{user.name}"></property>
		<property name="age" value="#{user3.age}"></property>
		<property name="car" ref="car"></property>
	</bean>
	
	<!-- ============================================================= -->
	<!-- 复杂类型注入 -->
	<bean name="cb" class="com.learn.c_injection.CollectionBean">
		<!-- 如果数组中只准备注入一个值(对象),直接使用value|ref即可 -->
		<!-- <property name="arr" value="tom"></property> -->
		<property name="arr">
		
			<!-- array注入 -->
			<array>
				<value>tom</value>
				<value>jerry</value>
				<ref bean="user4"/>
			</array>
		</property>
		
		<!-- <property name="list" value="jack"></property> -->
		
		<property name="list" >
			<list>
				<value>jack</value>
				<value>rose</value>
				<ref bean="user3"/>
			</list>
		</property>
		
	</bean>
</beans>

list当中是不是三个元素,这是不是list,jack,rose,这里是不是还有个对象类型的

CollectionBean [arr=[tom, jerry, User [name=tom, age=20, car=Car [name=兰博基尼, color=黄色]]], 
list=[jack, rose, User [name=jack, age=20, car=Car [name=兰博基尼, color=黄色]]], map=null, prop=null]

这是咱们的List,然后接下来再来看一下咱们的Map,Map的话复制一个Property,Map类型注入,

变量名咱们改成一个map,换乘map,然后map大家知道他是键值对,所以这块使用entry对象,

其中entry对象这里面一共提供了两个属性,分别是key属性,还有他的value属性,其中key填写键的

名称,来一个url,等于jdbc:mysql:///crm,看懂啥意思,我随便写的,接下来再来一个其他的,比如键咱们叫成

driverName,这是咱们驱动名称,咱们叫car,因为我要来一个对象类型,我来一个car,然后value-ref等于,你应该

知道是啥意思了,咱们好像没有car,那咱们来一个user4,键是user4,这里是不是两个键值对,一个键是url,对应的

是不是字符串,一个键是user,对应的是user4对象,还有一个特殊情况,这里还有一个key-ref,比如key-ref咱们来

一个什么对象啊,比如user3作为咱们的key-ref键,然后value就是user2,map有点诡异,一共三个键值对,咱们分别

演示,键为字符串,值为字符串,键为字符串,值为对象,键为对象,值为对象

<?xml version="1.0" encoding="UTF-8"?>
<beans  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
		xmlns="http://www.springframework.org/schema/beans" 
		xmlns:p="http://www.springframework.org/schema/p"
		xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">

	<!-- set方式注入 -->
	<bean name="user" class="com.learn.bean.User">
		<!-- 为User对象中名为name的属性注入tom作为值 -->
		<property name="name" value="tom"></property>
		<property name="age" value="18"></property>
		<!-- 为car属性注入下方配置的car对象 -->
		<property name="car" ref="car"></property>
	</bean>
	
	<!-- 将car对象配置到容器中 -->
	<bean name="car" class="com.learn.bean.Car">
		<property name="name" value="兰博基尼"></property>
		<property name="color" value="黄色"></property>
	</bean>
	
	<!--  =============================================================  -->
	
	<!-- 构造函数注入 -->
	<bean name="user2" class="com.learn.bean.User">
		<!-- name属性:构造函数的参数名 -->
		<!-- index属性:构造函数的参数索引 -->
		<!-- type属性:构造函数的参数类型 -->
		<constructor-arg name="name" value="999" index="0" type="java.lang.Integer"></constructor-arg>
		<constructor-arg name="car" ref="car" index="1"></constructor-arg>
	</bean>
	
	<!-- ============================================================= -->
	
	<!-- p名称空间注入 
		1.导入p名称空间 xmlns:p="http://www.springframework.org/schema/p"
		2.使用p:属性完成注入
			|-值类型: p:属性名="值"
			|-对象类型: p:属性名-ref="bean名称"
	-->
	<bean name="user3" class="com.learn.bean.User" p:name="jack" p:age="20" p:car-ref="car">
	</bean>
	
	<!-- ============================================================= -->
	<!-- spel注入:spring Expression Language spring表达式语言 -->
	<bean name="user4" class="com.learn.bean.User" >
		<property name="name" value="#{user.name}"></property>
		<property name="age" value="#{user3.age}"></property>
		<property name="car" ref="car"></property>
	</bean>
	
	<!-- ============================================================= -->
	<!-- 复杂类型注入 -->
	<bean name="cb" class="com.learn.c_injection.CollectionBean">
		<!-- 如果数组中只准备注入一个值(对象),直接使用value|ref即可 -->
		<!-- <property name="arr" value="tom"></property> -->
		<property name="arr">
		
			<!-- array注入 -->
			<array>
				<value>tom</value>
				<value>jerry</value>
				<ref bean="user4"/>
			</array>
		</property>
		
		<!-- <property name="list" value="jack"></property> -->
		
		<property name="list" >
			<list>
				<value>jack</value>
				<value>rose</value>
				<ref bean="user3"/>
			</list>
		</property>
		
		<!-- map类型注入 -->
		<property name="map" >
			<map>
				<entry key="url" value="jdbc:mysql:///crm"></entry>
				<entry key="user4" value-ref="user4"></entry>
				<entry key-ref="user3" value-ref="user2"></entry>
			</map>
		</property>
		
	</bean>
	
</beans>

打印一下,看看这个map

CollectionBean [
arr=[tom, jerry, User [name=tom, age=20, car=Car [name=兰博基尼, color=黄色]]], 
list=[jack, rose, User [name=jack, age=20, car=Car [name=兰博基尼, color=黄色]]], 
map={url=jdbc:mysql:///crm, user4=User [name=tom, age=20, car=Car [name=兰博基尼, color=黄色]], User [name=jack, age=20, car=Car [name=兰博基尼, color=黄色]]=User [name=999, age=null, car=Car [name=兰博基尼, color=黄色]]}, 
prop=null]

这个map你看,这是第一个,是不是字符串字符串,下边这个是字符串对象,第三个,第四个,是不是对象对象,

等于是一个对象,最后一个两个都是对象,那这个就是map类型的注入,之后还剩最后一个,properties类型注入,

properties类型注入的话,咱们还是property元素,name等于prop,然后里面的子元素不用map了,换成props,

然后大家知道其实properties也是键值对,只不过他都是字符串,值就放到标签体里面去了,这个来一个drvierClass,

com.jdbc.mysql.Driver,咱们的userName等于root,咱们再来一个password,然后密码等于1234,我这不是连接数据库,

我是随便来一个场景

<?xml version="1.0" encoding="UTF-8"?>
<beans  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
		xmlns="http://www.springframework.org/schema/beans" 
		xmlns:p="http://www.springframework.org/schema/p"
		xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">

	<!-- set方式注入 -->
	<bean name="user" class="com.learn.bean.User">
		<!-- 为User对象中名为name的属性注入tom作为值 -->
		<property name="name" value="tom"></property>
		<property name="age" value="18"></property>
		<!-- 为car属性注入下方配置的car对象 -->
		<property name="car" ref="car"></property>
	</bean>
	
	<!-- 将car对象配置到容器中 -->
	<bean name="car" class="com.learn.bean.Car">
		<property name="name" value="兰博基尼"></property>
		<property name="color" value="黄色"></property>
	</bean>
	
	<!--  =============================================================  -->
	
	<!-- 构造函数注入 -->
	<bean name="user2" class="com.learn.bean.User">
		<!-- name属性:构造函数的参数名 -->
		<!-- index属性:构造函数的参数索引 -->
		<!-- type属性:构造函数的参数类型 -->
		<constructor-arg name="name" value="999" index="0" type="java.lang.Integer"></constructor-arg>
		<constructor-arg name="car" ref="car" index="1"></constructor-arg>
	</bean>
	
	<!-- ============================================================= -->
	
	<!-- p名称空间注入 
		1.导入p名称空间 xmlns:p="http://www.springframework.org/schema/p"
		2.使用p:属性完成注入
			|-值类型: p:属性名="值"
			|-对象类型: p:属性名-ref="bean名称"
	-->
	<bean name="user3" class="com.learn.bean.User" p:name="jack" p:age="20" p:car-ref="car">
	</bean>
	
	<!-- ============================================================= -->
	<!-- spel注入:spring Expression Language spring表达式语言 -->
	<bean name="user4" class="com.learn.bean.User" >
		<property name="name" value="#{user.name}"></property>
		<property name="age" value="#{user3.age}"></property>
		<property name="car" ref="car"></property>
	</bean>
	
	<!-- ============================================================= -->
	<!-- 复杂类型注入 -->
	<bean name="cb" class="com.learn.c_injection.CollectionBean">
		<!-- 如果数组中只准备注入一个值(对象),直接使用value|ref即可 -->
		<!-- <property name="arr" value="tom"></property> -->
		<property name="arr">
		
			<!-- array注入 -->
			<array>
				<value>tom</value>
				<value>jerry</value>
				<ref bean="user4"/>
			</array>
		</property>
		
		<!-- <property name="list" value="jack"></property> -->
		
		<property name="list" >
			<list>
				<value>jack</value>
				<value>rose</value>
				<ref bean="user3"/>
			</list>
		</property>
		
		<!-- map类型注入 -->
		<property name="map" >
			<map>
				<entry key="url" value="jdbc:mysql:///crm"></entry>
				<entry key="user4" value-ref="user4"></entry>
				<entry key-ref="user3" value-ref="user2"></entry>
			</map>
		</property>
		
		<!-- properties类型注入 -->
		<property name="prop" >
			<props>
				<prop key="driverClass">com.jdbc.mysql.Driver</prop>
				<prop key="userName">root</prop>
				<prop key="password">1234</prop>
			</props>
		</property>
		
	</bean>
</beans>

然后接下来最后打印一下

CollectionBean [
arr=[tom, jerry, User [name=tom, age=20, car=Car [name=兰博基尼, color=黄色]]], 
list=[jack, rose, User [name=jack, age=20, car=Car [name=兰博基尼, color=黄色]]], 
map={url=jdbc:mysql:///crm, user4=User [name=tom, age=20, car=Car [name=兰博基尼, color=黄色]], User [name=jack, age=20, car=Car [name=兰博基尼, color=黄色]]=User [name=999, age=null, car=Car [name=兰博基尼, color=黄色]]}, 
prop={driverClass=com.jdbc.mysql.Driver, password=1234, userName=root}]

你们看看prop属性,用户名密码,这样复杂性注入就演示完了,数组,List,Map,Properties,

数组的话分两种情况,一种是只有一个值,还有一种是多个值,然后List也是分为这两种情况,List只有一个值,

如果List只有一个值,这么写,然后有多个值,这么写,然后Map没有一个值多个值的情况,一个多个都得这么写,

然后Properties也是,也不分一个值多个值,复杂类型注入这个知识点,今天的内容差不多就完事了