一起学Spring之三种注入方式及集合类型注入
本文内容纲要：
- 概述- 前提准备
- 通过属性的方式进行注入
- 通过构造函数的方式进行注入
- 采用p标签的方式进行注入
- 集合类型的注入
- 特殊符号处理
- 备注
本文主要讲解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 prepareRefresh2 信息: 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封装，如下所示：
如字符串：
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中的非法字符如下：
只有千锤百炼，才能成为好钢。
本文内容总结：概述，前提准备，通过属性的方式进行注入，通过构造函数的方式进行注入，采用p标签的方式进行注入，集合类型的注入，特殊符号处理，备注，
原文链接：https://www.cnblogs.com/hsiang/p/11668372.html
以上是 一起学Spring之三种注入方式及集合类型注入 的全部内容， 来源链接： utcz.com/z/295999.html
