一起学Spring之三种注入方式及集合类型注入

本文主要讲解Spring开发中三种不同的注入方式，以及集合数据类型的注入，仅供学习分享使用，如有不足之处，还请指正。

概述

Spring的注入方式一共有三种，如下所示：

1. 通过set属性进行注入，即通过属性的geter,seter方法进入，如果没有对应的方法，就会报错。
2. 通过构造函数进行注入，通过类的构造函数进行注入，如果参数个数和构造函数对应不上，也会跑异常。
3. 通过p标签进行注入，通过引入p标签的方式进行注入。

前提准备

首先有一个Teacher类和Course类，课程需要有对应的教课老师，两个类代码如下：

Teacher类

 package com.hex.first;

 /**
  * 老师类
  * @author Administrator
  *
  */
 public class Teacher {

     /**
      * 姓名
      */
     private String teacherName="";

     /**
      * 年龄
      */
     private int teacherAge=0;

     public String getTeacherName() {
         return teacherName;
     }

     public void setTeacherName(String teacherName) {
         this.teacherName = teacherName;
     }

     public int getTeacherAge() {
         return teacherAge;
     }

     public void setTeacherAge(int teacherAge) {
         this.teacherAge = teacherAge;
     }

     /**
      * 教师信息
      */
     @Override
     public String toString() {
         return "Teacher [teacherName=" + teacherName + ", teacherAge=" + teacherAge + "]";
     }

     /**
      * 构造函数
      */
     public Teacher() {
         super();
         // TODO Auto-generated constructor stub
     }

     /**
      * 构造函数
      * @param teacherName
      * @param teacherAge
      */
     public Teacher(String teacherName, int teacherAge) {
         this.teacherName = teacherName;
         this.teacherAge = teacherAge;
     }

 }

Course类

 package com.hex.first;

 /**
  * 课程
  * @author Administrator
  *
  */
 public class Course {

     /**
      * 课程名
      */
     private String courseName="";

     /**
      * 课时长
      */
     private int courseHour=0;

     /**
      * 课程老师
      */
     private Teacher teacher;

     public String getCourseName() {
         return courseName;
     }

     public void setCourseName(String courseName) {
         this.courseName = courseName;
     }

     public int getCourseHour() {
         return courseHour;
     }
     public void setCourseHour(int courseHour) {
         this.courseHour = courseHour;
     }

     public Teacher getTeacher() {
         return teacher;
     }

     public void setTeacher(Teacher teacher) {
         this.teacher = teacher;
     }

     /**
      * 构造函数
      */
     public Course() {
         super();
         // TODO Auto-generated constructor stub
     }

     /**
      * 构造函数
      * @param courseName
      * @param courseHour
      */
     public Course(String courseName, int courseHour) {
         this.courseName = courseName;
         this.courseHour = courseHour;
     }

     /**
      * 三个参数的构造函数
      * @param courseName
      * @param courseHour
      * @param teacher
      */
     public Course(String courseName, int courseHour, Teacher teacher) {
         this.courseName = courseName;
         this.courseHour = courseHour;
         this.teacher = teacher;
     }

     /**
      * 重写toString()方法
      */
     @Override
     public String toString() {
         return "Course [courseName=" + courseName + ", courseHour=" + courseHour + ",teacher="+teacher+"]";
     }

 }

通过属性的方式进行注入

在applicatonContext.xml中配置如下：

 <!-- 第1种： 通过set 方法进行赋值，属性必须有对应的set+属性名，第一个字母大写的方法，才可以赋值 -->
     <bean id="teacher1" class="com.hex.first.Teacher">
         <property name="teacherName" value="hex"></property>
         <property name="teacherAge" value="20"></property>
     </bean>
     <!--
         如果是常规的数据类型，采用property name value进行赋值
         如果是对象类型，采用property name ref 进行赋值
      -->
     <bean id="course1" class="com.hex.first.Course">
         <property name="courseName" value="Java"></property>
         <property name="courseHour" value="120"></property>
         <property name="teacher" ref="teacher1"></property>
     </bean>

通过构造函数的方式进行注入

如果在采用构造函数的方式进行注入，则必须有对应的构造函数与之对应，在applicatonContext.xml中配置如下：

 <!--第2种： 采用构造函数，进行赋值 -->
     <!--
         如果构造参数的顺序，和构造函数中的参数顺序是一样的，则name（参数名称）,index（参数顺序号）,type（参数数据类型）均可以省略
         如果不一样，则需要用name,index的其中一个来标识，如果参数的type不同，则也可以用type来区分
      -->
     <bean id="teacher2" class="com.hex.first.Teacher">
         <constructor-arg name="teacherName" value="hex" index="0" type="String"></constructor-arg>
         <constructor-arg name="teacherAge" value="22" index="1" type="int"></constructor-arg>
     </bean>
     <!--
         如果是常规的数据类型，采用constructor-arg name value进行赋值
         如果是对象类型，采用constructor-arg name ref 进行赋值
      -->
     <bean id="course2" class="com.hex.first.Course">
         <constructor-arg name="courseName" value=".Net C#" index="0" type="String"></constructor-arg>
         <constructor-arg name="courseHour" value="110" index="1" type="int"></constructor-arg>
         <constructor-arg name="teacher"  ref="teacher2" index="2" type="com.hex.first.Teacher"></constructor-arg>
     </bean>

采用p标签的方式进行注入

如果需要采用p标签进行注入，则需要引入命名空间，如下所示：

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

配置如下：

 <!-- 第3种：通过P标签实现 ，需要引入命名空间-->
     <!--
         如果就常规数据类型，采用p:属性名="value"的方式进行赋值
         如果是对象数据类型，采用p:属性名-ref=""的方式赋值
      -->
     <bean id="teacher3" class="com.hex.first.Teacher" p:teacherName="zs" p:teacherAge="21">
     </bean>
     <bean id="course3" class="com.hex.first.Course" p:courseName="C++" p:courseHour="100" p:teacher-ref="teacher3">

     </bean>

以上三种方式，在创建对象时，都是一样的，如下所示：

 //通过Spring进行注入，Spring上下文对象
 ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
 //从Spring的IOC容器中获取id为course1的bean对象
 Course course1 =(Course) context.getBean("course1");
 System.out.println(course1);
 //从Spring的IOC容器中获取id为course2的bean对象
 Course course2 =(Course) context.getBean("course2");
 System.out.println(course2);
 //从Spring的IOC容器中获取id为course3的bean对象
 Course course3 =(Course) context.getBean("course3");
 System.out.println(course3);

集合类型的注入

首先有一个类，属性为集合数据类型，代码如下：

 package com.hex.first;

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

 /**
  * 测试集合数据类型
  * @author Administrator
  *
  */
 public class TestCollection {
     /**
      * 数组信息
      */
     private String[] arrInfo;

     /**
      * 列表信息
      */
     private List<String> lstInfo;

     /**
      * Map信息
      */
     private Map<String,String> mapInfo;

     /**
      * Set信息
      */
     private Set<String> setInfo;

     private Properties propInfo;

     public String[] getArrInfo() {
         return arrInfo;
     }

     public void setArrInfo(String[] arrInfo) {
         this.arrInfo = arrInfo;
     }

     public List<String> getLstInfo() {
         return lstInfo;
     }

     public void setLstInfo(List<String> lstInfo) {
         this.lstInfo = lstInfo;
     }

     public Map<String, String> getMapInfo() {
         return mapInfo;
     }

     public void setMapInfo(Map<String, String> mapInfo) {
         this.mapInfo = mapInfo;
     }

     public Set<String> getSetInfo() {
         return setInfo;
     }

     public void setSetInfo(Set<String> setInfo) {
         this.setInfo = setInfo;
     }

     public Properties getPropInfo() {
         return propInfo;
     }

     public void setPropInfo(Properties propInfo) {
         this.propInfo = propInfo;
     }

     @Override
     public String toString() {
         return "TestCollection [arrInfo=" + Arrays.toString(arrInfo) + ", lstInfo=" + lstInfo + ", mapInfo=" + mapInfo
                 + ", setInfo=" + setInfo + ", propInfo=" + propInfo + "]";
     }

 }

通过Spring的配置文件进行注入，这里采用setters属性方式进行注入，如下所示：

 <!-- 集合数据类型 -->
     <bean id="test1" class="com.hex.first.TestCollection">
         <!-- 数组 -->
         <property name="arrInfo">
             <array>
                 <value>篮球</value>
                 <value>足球</value>
                 <value>网球</value>
             </array>
         </property>
         <!-- 列表 -->
         <property name="lstInfo">
             <list>
                 <value>北京</value>
                 <value>上海</value>
                 <value>天津</value>
             </list>
         </property>
         <!-- 键值对，每一个键值对为一个entry,有key,value两个属性 -->
         <property name="mapInfo">
             <map>
                 <entry>
                     <key>
                         <value>football</value>
                     </key>
                     <value>足球</value>
                 </entry>
                 <entry>
                     <key>
                         <value>basketball</value>
                     </key>
                     <value>篮球</value>
                 </entry>
                 <entry>
                     <key>
                         <value>ping</value>
                     </key>
                     <value>乒乓球</value>
                 </entry>
             </map>
         </property>
         <!-- 数据集 -->
         <property name="setInfo">
             <set>
                 <value>AA</value>
                 <value>BB</value>
                 <value>CC</value>
             </set>
         </property>
         <!-- props也是一个键值对 -->
         <property name="propInfo">
             <props>
                 <prop key="boy">男孩</prop>
                 <prop key="girl">女孩</prop>
             </props>
         </property>
     </bean>

以上测试信息如下所示：

 十月 13, 2019 9:51:09 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
 信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@1f17ae12: startup date [Sun Oct 13 21:51:09 CST 2019]; root of context hierarchy
 十月 13, 2019 9:51:10 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
 信息: Loading XML bean definitions from class path resource [applicationContext.xml]
 Course [courseName=Java, courseHour=120,teacher=Teacher [teacherName=hex, teacherAge=20]]
 Course [courseName=.Net C#, courseHour=110,teacher=Teacher [teacherName=hex, teacherAge=22]]
 Course [courseName=C++, courseHour=100,teacher=Teacher [teacherName=zs, teacherAge=21]]
 TestClass [arrInfo=[篮球, 足球, 网球], lstInfo=[北京, 上海, 天津], mapInfo={football=足球, basketball=篮球, ping=乒乓球}, setInfo=[AA, BB, CC], propInfo={boy=男孩, girl=女孩}]

特殊符号处理

在配置applicationContext.xml实现注入时，如果遇到特殊字符，则需要进行转义，或者进行CDATA封装，如下所示：

如字符串：<Java> ，则需要配置成：

 <bean id="course1" class="com.hex.first.Course">
     <property name="courseName" value="&lt;Java&gt;"></property>
     <property name="courseHour" value="120"></property>
     <property name="teacher" ref="teacher1"></property>
 </bean>

或者采用CDATA方式，如下所示：

 <bean id="teacher1" class="com.hex.first.Teacher">
     <property name="teacherName">
         <value><![CDATA[<hex>]]></value>
     </property>
     <property name="teacherAge" value="20"></property>
 </bean>

把代码在CDATA中不需要转义：解析器会忽略 CDATA 部分中的所有内容

备注

XML中的非法字符如下：

只有千锤百炼，才能成为好钢。