本文主要讲解Spring开发中三种不同的注入方式，以及集合数据类型的注入，仅供学习分享使用，如有不足之处，还请指正。
概述
Spring的注入方式一共有三种，如下所示：
- 通过set属性进行注入，即通过属性的geter,seter方法进入，如果没有对应的方法，就会报错。
- 通过构造函数进行注入，通过类的构造函数进行注入，如果参数个数和构造函数对应不上，也会跑异常。
- 通过p标签进行注入，通过引入p标签的方式进行注入。
前提准备
首先有一个Teacher类和Course类，课程需要有对应的教课老师，两个类代码如下：
Teacher类
1 package com.hex.first; 2 3 /** 4 * 老师类 5 * @author Administrator 6 * 7 */ 8 public class Teacher { 9 10 /** 11 * 姓名 12 */ 13 private String teacherName=""; 14 15 /** 16 * 年龄 17 */ 18 private int teacherAge=0; 19 20 21 22 public String getTeacherName() { 23 return teacherName; 24 } 25 26 public void setTeacherName(String teacherName) { 27 this.teacherName = teacherName; 28 } 29 30 public int getTeacherAge() { 31 return teacherAge; 32 } 33 34 public void setTeacherAge(int teacherAge) { 35 this.teacherAge = teacherAge; 36 } 37 38 39 40 /** 41 * 教师信息 42 */ 43 @Override 44 public String toString() { 45 return "Teacher [teacherName=" + teacherName + ", teacherAge=" + teacherAge + "]"; 46 } 47 48 49 /** 50 * 构造函数 51 */ 52 public Teacher() { 53 super(); 54 // TODO Auto-generated constructor stub 55 } 56 57 /** 58 * 构造函数 59 * @param teacherName 60 * @param teacherAge 61 */ 62 public Teacher(String teacherName, int teacherAge) { 63 this.teacherName = teacherName; 64 this.teacherAge = teacherAge; 65 } 66 67 }
Course类
1 package com.hex.first; 2 3 /** 4 * 课程 5 * @author Administrator 6 * 7 */ 8 public class Course { 9 10 /** 11 * 课程名 12 */ 13 private String courseName=""; 14 15 /** 16 * 课时长 17 */ 18 private int courseHour=0; 19 20 /** 21 * 课程老师 22 */ 23 private Teacher teacher; 24 25 public String getCourseName() { 26 return courseName; 27 } 28 29 public void setCourseName(String courseName) { 30 this.courseName = courseName; 31 } 32 33 public int getCourseHour() { 34 return courseHour; 35 } 36 public void setCourseHour(int courseHour) { 37 this.courseHour = courseHour; 38 } 39 40 public Teacher getTeacher() { 41 return teacher; 42 } 43 44 public void setTeacher(Teacher teacher) { 45 this.teacher = teacher; 46 } 47 48 49 /** 50 * 构造函数 51 */ 52 public Course() { 53 super(); 54 // TODO Auto-generated constructor stub 55 } 56 57 /** 58 * 构造函数 59 * @param courseName 60 * @param courseHour 61 */ 62 public Course(String courseName, int courseHour) { 63 this.courseName = courseName; 64 this.courseHour = courseHour; 65 } 66 67 68 /** 69 * 三个参数的构造函数 70 * @param courseName 71 * @param courseHour 72 * @param teacher 73 */ 74 public Course(String courseName, int courseHour, Teacher teacher) { 75 this.courseName = courseName; 76 this.courseHour = courseHour; 77 this.teacher = teacher; 78 } 79 80 /** 81 * 重写toString()方法 82 */ 83 @Override 84 public String toString() { 85 return "Course [courseName=" + courseName + ", courseHour=" + courseHour + ",teacher="+teacher+"]"; 86 } 87 88 89 }
通过属性的方式进行注入
在applicatonContext.xml中配置如下：
1 <!-- 第1种： 通过set 方法进行赋值，属性必须有对应的set+属性名，第一个字母大写的方法，才可以赋值 --> 2 <bean id="teacher1" class="com.hex.first.Teacher"> 3 <property name="teacherName" value="hex"></property> 4 <property name="teacherAge" value="20"></property> 5 </bean> 6 <!-- 7 如果是常规的数据类型，采用property name value进行赋值 8 如果是对象类型，采用property name ref 进行赋值 9 --> 10 <bean id="course1" class="com.hex.first.Course"> 11 <property name="courseName" value="Java"></property> 12 <property name="courseHour" value="120"></property> 13 <property name="teacher" ref="teacher1"></property> 14 </bean>
通过构造函数的方式进行注入
如果在采用构造函数的方式进行注入，则必须有对应的构造函数与之对应，在applicatonContext.xml中配置如下：
1 <!--第2种： 采用构造函数，进行赋值 --> 2 <!-- 3 如果构造参数的顺序，和构造函数中的参数顺序是一样的，则name（参数名称）,index（参数顺序号）,type（参数数据类型）均可以省略 4 如果不一样，则需要用name,index的其中一个来标识，如果参数的type不同，则也可以用type来区分 5 --> 6 <bean id="teacher2" class="com.hex.first.Teacher"> 7 <constructor-arg name="teacherName" value="hex" index="0" type="String"></constructor-arg> 8 <constructor-arg name="teacherAge" value="22" index="1" type="int"></constructor-arg> 9 </bean> 10 <!-- 11 如果是常规的数据类型，采用constructor-arg name value进行赋值 12 如果是对象类型，采用constructor-arg name ref 进行赋值 13 --> 14 <bean id="course2" class="com.hex.first.Course"> 15 <constructor-arg name="courseName" value=".Net C#" index="0" type="String"></constructor-arg> 16 <constructor-arg name="courseHour" value="110" index="1" type="int"></constructor-arg> 17 <constructor-arg name="teacher" ref="teacher2" index="2" type="com.hex.first.Teacher"></constructor-arg> 18 </bean>
采用p标签的方式进行注入
如果需要采用p标签进行注入，则需要引入命名空间，如下所示：
1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xmlns:p="http://www.springframework.org/schema/p" 5 xsi:schemaLocation="http://www.springframework.org/schema/beans 6 http://www.springframework.org/schema/beans/spring-beans.xsd">
配置如下：
1 <!-- 第3种：通过P标签实现 ，需要引入命名空间--> 2 <!-- 3 如果就常规数据类型，采用p:属性名="value"的方式进行赋值 4 如果是对象数据类型，采用p:属性名-ref=""的方式赋值 5 --> 6 <bean id="teacher3" class="com.hex.first.Teacher" p:teacherName="zs" p:teacherAge="21"> 7 </bean> 8 <bean id="course3" class="com.hex.first.Course" p:courseName="C++" p:courseHour="100" p:teacher-ref="teacher3"> 9 10 </bean>
以上三种方式，在创建对象时，都是一样的，如下所示：
1 //通过Spring进行注入，Spring上下文对象 2 ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml"); 3 //从Spring的IOC容器中获取id为course1的bean对象 4 Course course1 =(Course) context.getBean("course1"); 5 System.out.println(course1); 6 //从Spring的IOC容器中获取id为course2的bean对象 7 Course course2 =(Course) context.getBean("course2"); 8 System.out.println(course2); 9 //从Spring的IOC容器中获取id为course3的bean对象 10 Course course3 =(Course) context.getBean("course3"); 11 System.out.println(course3);
集合类型的注入
首先有一个类，属性为集合数据类型，代码如下：
1 package com.hex.first; 2 3 import java.util.Arrays; 4 import java.util.List; 5 import java.util.Map; 6 import java.util.Properties; 7 import java.util.Set; 8 9 /** 10 * 测试集合数据类型 11 * @author Administrator 12 * 13 */ 14 public class TestCollection { 15 /** 16 * 数组信息 17 */ 18 private String[] arrInfo; 19 20 /** 21 * 列表信息 22 */ 23 private List<String> lstInfo; 24 25 /** 26 * Map信息 27 */ 28 private Map<String,String> mapInfo; 29 30 /** 31 * Set信息 32 */ 33 private Set<String> setInfo; 34 35 private Properties propInfo; 36 37 public String[] getArrInfo() { 38 return arrInfo; 39 } 40 41 public void setArrInfo(String[] arrInfo) { 42 this.arrInfo = arrInfo; 43 } 44 45 public List<String> getLstInfo() { 46 return lstInfo; 47 } 48 49 public void setLstInfo(List<String> lstInfo) { 50 this.lstInfo = lstInfo; 51 } 52 53 public Map<String, String> getMapInfo() { 54 return mapInfo; 55 } 56 57 public void setMapInfo(Map<String, String> mapInfo) { 58 this.mapInfo = mapInfo; 59 } 60 61 public Set<String> getSetInfo() { 62 return setInfo; 63 } 64 65 public void setSetInfo(Set<String> setInfo) { 66 this.setInfo = setInfo; 67 } 68 69 public Properties getPropInfo() { 70 return propInfo; 71 } 72 73 public void setPropInfo(Properties propInfo) { 74 this.propInfo = propInfo; 75 } 76 77 @Override 78 public String toString() { 79 return "TestCollection [arrInfo=" + Arrays.toString(arrInfo) + ", lstInfo=" + lstInfo + ", mapInfo=" + mapInfo 80 + ", setInfo=" + setInfo + ", propInfo=" + propInfo + "]"; 81 } 82 83 }
通过Spring的配置文件进行注入，这里采用setters属性方式进行注入，如下所示：
1 <!-- 集合数据类型 --> 2 <bean id="test1" class="com.hex.first.TestCollection"> 3 <!-- 数组 --> 4 <property name="arrInfo"> 5 <array> 6 <value>篮球</value> 7 <value>足球</value> 8 <value>网球</value> 9 </array> 10 </property> 11 <!-- 列表 --> 12 <property name="lstInfo"> 13 <list> 14 <value>北京</value> 15 <value>上海</value> 16 <value>天津</value> 17 </list> 18 </property> 19 <!-- 键值对，每一个键值对为一个entry,有key,value两个属性 --> 20 <property name="mapInfo"> 21 <map> 22 <entry> 23 <key> 24 <value>football</value> 25 </key> 26 <value>足球</value> 27 </entry> 28 <entry> 29 <key> 30 <value>basketball</value> 31 </key> 32 <value>篮球</value> 33 </entry> 34 <entry> 35 <key> 36 <value>ping</value> 37 </key> 38 <value>乒乓球</value> 39 </entry> 40 </map> 41 </property> 42 <!-- 数据集 --> 43 <property name="setInfo"> 44 <set> 45 <value>AA</value> 46 <value>BB</value> 47 <value>CC</value> 48 </set> 49 </property> 50 <!-- props也是一个键值对 --> 51 <property name="propInfo"> 52 <props> 53 <prop key="boy">男孩</prop> 54 <prop key="girl">女孩</prop> 55 </props> 56 </property> 57 </bean>
以上测试信息如下所示：
1 十月 13, 2019 9:51:09 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh 2 信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@1f17ae12: startup date [Sun Oct 13 21:51:09 CST 2019]; root of context hierarchy 3 十月 13, 2019 9:51:10 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions 4 信息: Loading XML bean definitions from class path resource [applicationContext.xml] 5 Course [courseName=Java, courseHour=120,teacher=Teacher [teacherName=hex, teacherAge=20]] 6 Course [courseName=.Net C#, courseHour=110,teacher=Teacher [teacherName=hex, teacherAge=22]] 7 Course [courseName=C++, courseHour=100,teacher=Teacher [teacherName=zs, teacherAge=21]] 8 TestClass [arrInfo=[篮球, 足球, 网球], lstInfo=[北京, 上海, 天津], mapInfo={football=足球, basketball=篮球, ping=乒乓球}, setInfo=[AA, BB, CC], propInfo={boy=男孩, girl=女孩}]
特殊符号处理
在配置applicationContext.xml实现注入时，如果遇到特殊字符，则需要进行转义，或者进行CDATA封装，如下所示：
如字符串：<Java> ，则需要配置成：
1 <bean id="course1" class="com.hex.first.Course"> 2 <property name="courseName" value="<Java>"></property> 3 <property name="courseHour" value="120"></property> 4 <property name="teacher" ref="teacher1"></property> 5 </bean>
或者采用CDATA方式，如下所示：
1 <bean id="teacher1" class="com.hex.first.Teacher"> 2 <property name="teacherName"> 3 <value><![CDATA[<hex>]]></value> 4 </property> 5 <property name="teacherAge" value="20"></property> 6 </bean>
把代码在CDATA中不需要转义：解析器会忽略 CDATA 部分中的所有内容
备注
XML中的非法字符如下：
只有千锤百炼，才能成为好钢。