首页 > > 程序设计 > Java技术 >

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

2019-10-16 07:58:32来源：博客园阅读 ()

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

本文主要讲解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 }

View Code

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 }

View Code

通过属性的方式进行注入

在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);

View Code

集合类型的注入

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

 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 }

View Code

通过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=女孩}]

View Code

特殊符号处理

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

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

1 <bean id="course1" class="com.hex.first.Course">
2     <property name="courseName" value="&lt;Java&gt;"></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>