Spring之IOC及XML配置方式

IOC(Inversion of Control)控制反转

控制反转就是对对象的控制权转移，从程序代码本身反转到了外部容器。把对象的创建、初始化、销毁等工作交给spring容器来做。由spring容器控制对象的生命周期。Spring 容器使用依赖注入（DI）来管理组成一个应用程序的组件。这些对象被称为 Spring Beans

通过阅读配置元数据提供的指令，容器知道对哪些对象进行实例化，配置和组装。配置元数据可以通过 XML，Java 注释或 Java 代码来表示。 Spring IoC 容器利用 Java 的 POJO 类和配置元数据来生成完全配置和可执行的系统或应用程序。

IOC 容器具有依赖注入功能的容器，它可以创建对象，IOC 容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。通常new一个实例，控制权由程序员控制，而"控制反转"是指new实例工作不由程序员来做而是交给Spring容器来做。在Spring中BeanFactory是IOC容器的实际代表者。
在这里插入图片描述
这里总结下使用非IOC方式与IOC方式的区别
非IOC方式
在MVC设计模式中，我们在controller层中要调用service层时，需要在controller层中要创建service对象，通过对象去调用service层的方法等，在service层中我们同样要创建dao层的对象，通过dao层对象去调用，这样随着项目的累积，controller层，service层，dao层之间的依赖性太大
IOC方式
我们把service层，dao层创建对象的过程交给spring容器去处理，我们只需要使用这个对象即可
具体实现如下
1、首先导入需要的jar包
在这里插入图片描述
2、创建一个普通的java类即可

package com.zhouym.service;

public class UserService {
	
	public void showContent() {
		System.out.println("测试IOC方式");
	}
}

3、我们需要创建一个xml文件，在src文件夹下面
在这里插入图片描述
内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd">
 
 	<!-- 注册bean -->
 	<bean class="com.zhouym.service.UserService" id="userService" name="serviceName"/> 	
 </beans>

做下介绍里面的参数
1.beans —— xml文件的根节点

2.xmlns ——类似于java中的package，是XML NameSpace的缩写，因为XML文件的标签名称都是自定义的，自己写的和其他人定义的标签很有可能会重复命名，而功能却不一样，所以需要加上一个namespace来区分这个xml文件和其他的xml文件，。

3.xmlns:xsi ——是指xml文件遵守xml规范，xsi全名：xml schema instance，是指具体用到的schema资源文件里定义的元素所准守的规范。即http://www.w3.org/2001/XMLSchema-instance这个文件里定义的元素遵守什么标准
4.xsi:schemaLocation——是指本文档里的xml元素所遵守的规范，这些规范都是由官方制定的，可以进你写的网址里面看版本的变动。xsd的网址还可以帮助你判断使用的代码是否合法。

在beans标签中加入bean标签，class属性中就是你需要交给spring容器处理的对象名，是全路径，即包名+类名，后面带上id，name属性可加可不加

我们在测试类中来看看代码实现，不创建service对象，也能调用service中的方法

package com.zhouym.junittest;

import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zhouym.service.UserService;

public class DemoTest {

	@Test
	public void test() {
		//创建spring容器对象，通过ApplicationContext这个接口
		ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
		//xml中，通过bean标签的id获取class对象
		UserService us = (UserService)ac.getBean("userService");
		us.showContent();
	}	
}

在这里插入图片描述
我们在使用ApplicationContext和BeanFactory创建对象时，要注意的是，使用ApplicationContext创建容器对象的同时，就初始化了，容器的所有bean被创建完毕。而BeanFactory创建容器对象，调用getBean方法获取响应对象时才创建对象，这也是使用ApplicationContext和BeanFactory创建容器对象的区别

输出结果：
在这里插入图片描述
上述是通过bean标签中的id属性值来创建对象，我们还可以通过name属性以及反射
通过name属性

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd">
 
 	<!-- 注册bean -->
 	<bean class="com.zhouym.service.UserService" name="serviceName"/> 	
 </beans>

输出结果：
在这里插入图片描述
显然也是可以的，我们在来看看通过反射实现

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd">
 
 	<!-- 注册bean -->
 	<bean class="com.zhouym.service.UserService"/> 	
 </beans>

测试类

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zhouym.service.UserService;

public class DemoTest {

	@Test
	public void test() {
		//创建spring容器对象，spring容器的两个接口ApplicationContext、BeanFactory
		ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
		//通过反射，类.class创建一个UserService对象
		UserService us = ac.getBean(UserService.class);
		us.showContent();
	}
}

结果如下：
在这里插入图片描述
也是可以的，那么我们想象，当我们在xml中写了多个bean标签，当然它的id和name属性值是不同的，这时我们怎么创建呢

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd">
 
 	<!-- 注册bean -->
 	<bean class="com.zhouym.service.UserService" id="userServiceid" name="userServiceNmae"/>
 	<bean class="com.zhouym.service.UserService" id="userServiceid2" name="userServiceName2"/> 	
 </beans>

测试类

package com.zhouym.junittest;

import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zhouym.service.UserService;

public class DemoTest {

	@Test
	public void test() {
		//创建spring容器对象，spring容器的两个接口ApplicationContext、BeanFactory
		ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
		//通过传递id属性值以及类.class参数
		UserService us = ac.getBean("userServiceid",UserService.class);
		us.showContent();
	}
}

结果如下：
在这里插入图片描述
但是我们在xml中书写多个bean，对象一样的，这样并没有多大的实际意义，因为spring容器一加载时只会创建一个，就类似于单例模式中只有一个对象存在
这里值得注意的是，id和name的使用，在id中不能使用“,”连接多个id，name可以使用“,”连接多个name

DI依赖注入：Dependency Injection。

依赖注入DI是指程序运行过程中，若需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部容器，由外部容器创建后传递给程序。依赖注入是目前最优秀的解耦方式。依赖注入让Spring的Bean之间以配置文件的方式组织在一起，而不是以硬编码的方式耦合在一起的。

IoC与DI的关系
IoC是一个概念，是一种思想，其实现方式多种多样。当前比较流行的实现方式之一是DI。

IOC:控制反转：将new 的过程交给spring容器去处理

XML的配置方式

1、普通构造注入

package com.zhouym.javabean;

public class UserBean {
	private int id;
	private String name;
	private int age;
	
	
	/**
	 * 无参构造方法
	 */
	public UserBean() {
		System.out.println("无参构造方法");
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public void run(){
		system.out.println("run方法")；
	}
		
}

在xml中声明UserBean

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd">
 
	<!-- 注册User对象-->
	<bean class="com.zhouym.javabean.UserBean" name="userName" id="userId"/>

 </beans>

所谓的声明，就是将自己的信息告诉Spring容器，例如id和class，Spring容器根据class，通过反射（默认使用的是无参构造方法）就可以创建一个名为user1的User对象
结果如下：
在这里插入图片描述
我们在UserBean中如果没有无参构造方法，此时就会报错。

2、静态工厂注入

静态工厂类

package com.zhouym.factory;

import com.zhouym.javabean.UserBean;

public class UserFactory {
	
	/**必须是静态方法
	 * @return
	 */
	public static UserBean getInstance() {
		return new UserBean();
	}
}

xml文件配置

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd">
 
	<!-- 注册静态工厂对象 增加工厂方法属性-->
	<bean class="com.zhouym.factory.UserFactory" factory-method="getInstance" id="userId"/>

 </beans>

测试类

package com.zhouym.JunitTest;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zhouym.javabean.UserBean;

public class TestIoc {

	@Test
	public void test() {
		ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
		//通过id，类文件对象参数获取UserBean对象
		UserBean ub = ac.getBean("userId",UserBean.class);
		ub.run();
			
	}

}

测试结果：
在这里插入图片描述

3、动态工厂注入

创建一个动态的工厂类

package com.zhouym.factory;

import com.zhouym.javabean.UserBean;

public class DynamicFactory {
	
	/**普通的方法
	 * @return
	 */
	public UserBean getInstance() {
		return new UserBean();
	}
}

xml配置

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- 注册动态工厂类 -->
	<bean class="com.zhouym.factory.DynamicFactory" id="userid"/>
	<!-- 通过动态工厂获取UserBean对象，传递id属性值 -->
	<bean id="dynamicid" factory-method="getInstance" factory-bean="userid"/>
 </beans>

测试类

package com.zhouym.JunitTest;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zhouym.javabean.UserBean;

public class TestIoc {

	@Test
	public void test() {
		ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
		UserBean ub = ac.getBean("dynamicid",UserBean.class);
		ub.run();
			
	}

}

测试结果如下：
在这里插入图片描述

4、属性注入

属性注入主要是指如何给对象中的属性赋值
基于构造函数的注入
创建有参构造方法，同时必须提供无参构造方法
UserBean类

package com.zhouym.javabean;


public class UserBean {
	private int id;
	private String name;
	private int age;
	
	
	/**
	 * 无参构造方法
	 */
	public UserBean() {
		System.out.println("无参构造方法");
	}
	
	
	/**
	 * 带参构造方法
	 * @param id
	 * @param name
	 * @param age
	 */
	public UserBean(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}


	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public void run() {
		System.out.println("run方法");
	}


	@Override
	public String toString() {
		return "UserBean [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
			
}

xml文件配置

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd">
	<!-- 创建UserBean对象 -->
	<bean class="com.zhouym.javabean.UserBean" id="userBean">
		<constructor-arg name="id" value="1"/>
		<constructor-arg name="age" value="18"/>
		<constructor-arg name="name" value="zhangsan" />
	</bean>
 </beans>

也可以通过index下标，从0开始

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd">
	<bean class="com.zhouym.javabean.UserBean" id="userBean2">
		<constructor-arg index="0" value="1"/>
		<constructor-arg index="1" value="lisi"/>
		<constructor-arg index="2" value="27"/>
	</bean>
 </beans>

这里需要注意的是，无论是通过name、还是通过index，要与对应的javabean中的带参构造方法中的参数个数、类型要一致，否则报错
参数类型错误
在这里插入图片描述
测试结果如下

基于设值注入
需要提供无参构造方法，有参方法可以提供也可以不提供
通过set方法注入就是利用对象属性的set方法给属性赋值，实际上，相当于首先使用无参构造方法创建一个Book对象，然后调用对象中的set方法给各个属性赋值。

UserBean类

package com.zhouym.javabean;

public class UserBean {
	private int id;
	private String name;
	private int age;
	
	
	/**
	 * 设值注入必须要提供一个无参构造方法
	 */
	public UserBean() {
		System.out.println("无参构造方法");
	}


	public int getId() {
		return id;
	}

	
	/**通过set方法为bean对象赋值
	 * @param id
	 */
	public void setId(int id) {
		this.id = id;
	}


	public String getName() {
		return name;
	}


	public void setName(String name) {
		this.name = name;
	}


	public int getAge() {
		return age;
	}


	public void setAge(int age) {
		this.age = age;
	}


	@Override
	public String toString() {
		return "UserBean [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
	
	public void say() {
		System.out.println("say方法");
	}
	
	
}

xml配置

<?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:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd">
 	<!-- 注册UserBean对象 -->
 	<bean class="com.zhouym.javabean.UserBean" id="userBean">
 		<!-- 通过设置注入 -->
 		<property name="id" value="1" />
 		<property name="name" value="张三" />
 		<property name="age" value="18" />
 	</bean>
	
 </beans>

测试类

package com.zhouym.junitTest;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zhouym.javabean.UserBean;

public class JunitTest {

	@Test
	public void test() {
		ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
		UserBean ub = ac.getBean(UserBean.class);
		System.out.println(ub);
	}

}

测试结果
在这里插入图片描述
基于P名称空间注入
其实p名称空间注入本质上还是set方法注入，只是写法不同（注意：p名称空间注入，需要有无参构造方法）。

Person类

package com.zhouym.javabean;

public class Person {
	private int id;
	private String name;
	private String address;
	public Person() {
		System.out.println("无参构造方法");
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	@Override
	public String toString() {
		return "Person [id=" + id + ", name=" + name + ", address=" + address + "]";
	}
	
	public void say() {
		System.out.println("say方法");
	}
}

xml配置

<?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">
 	<!-- 注册Person对象 -->
 	<bean class="com.zhouym.javabean.Person" id="person" p:id="1" p:name="张三" p:address="深圳"/>
 </beans>

测试类

package com.zhouym.junitTest;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zhouym.javabean.Person;
public class JunitTest {

	@Test
	public void test() {
		ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
		Person ub = ac.getBean(Person.class);
		System.out.println(ub);
	}

}

测试结果
在这里插入图片描述

基于对象注入
对象可以通过构造方法、set方法或者p名称空间注入
teacher类和student类
teacher类

package com.zhouym.javabean;

public class Teacher {
	private int id;
	private String name;
	private Student student;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Student getStudent() {
		return student;
	}
	public void setStudent(Student student) {
		this.student = student;
	}
	@Override
	public String toString() {
		return "Teacher [id=" + id + ", name=" + name + ", student=" + student + "]";
	}
	
	
	
}

student类

package com.zhouym.javabean;

public class Student {
	private int id;
	private String name;
	private int age;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
	
	
}

xml文件配置

<?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">
 	<!-- 注册Student对象 -->	
	<bean class="com.zhouym.javabean.Student" id="studentid">
		<property name="id" value="1"/>
		<property name="name" value="张三"/>
		<property name="age" value="18"/>
	</bean>
	<!-- 注册Teacher对象 -->
	<bean class="com.zhouym.javabean.Teacher">
		<property name="id" value="11"/>
		<property name="name" value="王老师"/>
		<property name="Student" ref="studentid"></property>
	</bean>
 </beans>

测试类

package com.zhouym.junitTest;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zhouym.javabean.Teacher;
public class JunitTest {

	@Test
	public void test() {
		ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
		
		Teacher ub = ac.getBean(Teacher.class);
		System.out.println(ub);
	}

}

测试结果
在这里插入图片描述
基于数组和集合注入
数组和集合的注入方式是一致的，无论是基本数据类型还是一个引用，注入方式都是一样。首先声明一个对象，对象中包含集合和数组。

Teacherlei

package com.zhouym.javabean;

import java.util.Arrays;
import java.util.List;

public class Teacher {
	private int id;
	private String name;
	private Student student;	
	private List<String> games;
	private Book[] books;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Student getStudent() {
		return student;
	}
	public void setStudent(Student student) {
		this.student = student;
	}
	public List<String> getGames() {
		return games;
	}
	public void setGames(List<String> games) {
		this.games = games;
	}
	public Book[] getBooks() {
		return books;
	}
	public void setBooks(Book[] books) {
		this.books = books;
	}
	@Override
	public String toString() {
		return "Teacher [id=" + id + ", name=" + name + ", student=" + student + ", games=" + games + ", books="
				+ Arrays.toString(books) + "]";
	}
	
	
	
	
	
	
}

Student类

package com.zhouym.javabean;

public class Student {
	private int id;
	private String name;
	private int age;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
	
	
}

xml配置文件

<?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">
 	<!-- 注册Student对象 -->	
	<bean class="com.zhouym.javabean.Student" id="studentid">
		<property name="id" value="1"/>
		<property name="name" value="张三"/>
		<property name="age" value="18"/>
	</bean>
	<!-- 注册Teacher对象 -->
	<bean class="com.zhouym.javabean.Teacher">
		<property name="id" value="11"/>
		<property name="name" value="王老师"/>
		<property name="Student" ref="studentid"></property>
		<!-- list集合注入 -->
		<property name="games">
			<list>
				<value>张三</value>
				<value>李四</value>
				<value>王五</value>
			</list>
		</property>
		<!-- 数组注入 -->
		<property name="books">
			<list>
				<bean class="com.zhouym.javabean.Book">
					<property name="id" value="1"/>
					<property name="bookName" value="权利的利与弊"/>
				</bean>
				<bean class="com.zhouym.javabean.Book">
					<property name="id" value="2"/>
					<property name="bookName" value="优秀的演说家"/>
				</bean>
			</list>
		</property>
	</bean>
	
 </beans>

测试类

package com.zhouym.junitTest;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zhouym.javabean.Book;
import com.zhouym.javabean.Teacher;
public class JunitTest {

	@Test
	public void test() {
		ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
		
		Teacher ub = ac.getBean(Teacher.class);
		System.out.println(ub);
		System.out.println(ub.getGames());
		Book[] books = ub.getBooks();
		for (Book book : books) {
			System.out.println(book.getId()+":"+book.getBookName());
		}
	}

}

测试结果
在这里插入图片描述

基于Map注入
声明Map属性，注意属性的key和value的数据类型需要提前定义好，然后在xml文件中直接使用（xml文件中配置时，key和属性的值必须要满足声明的要求，否则就会出错）。

Teacher类


package com.zhouym.javabean;

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

public class Teacher {	
	private Map<String, Object> score;
	
	

	public Map<String, Object> getScore() {
		return score;
	}


	public void setScore(Map<String, Object> score) {
		this.score = score;
	}

}

xml文件配置

<?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">
	<!-- 注册Teacher对象 -->
	<bean class="com.zhouym.javabean.Teacher">
		<!-- Map注入 -->
		<property name="score">
			<map>
				<entry key="语文" value="85"/>
				<entry key="数学" value="95"/>
				<entry key="英语" value="100"/>
			</map>
		</property>
		
		
	</bean>
	
 </beans>

测试类

package com.zhouym.junitTest;

import java.util.Map;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.zhouym.javabean.Teacher;
public class JunitTest {

	@Test
	public void test() {
		ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
		
		Teacher ub = ac.getBean(Teacher.class);
		Map<String, Object> score = ub.getScore();
		Set<String> key = score.keySet();
		for (String k : key) {
			System.out.println(k+"="+score.get(k));
		}
	}

}

测试结果
在这里插入图片描述
基于props注入
properties注入与map注入类似

Teacher类

package com.zhouym.javabean;

import java.util.Properties;

public class Teacher {
	
	private Properties properties;

	
	
	public Properties getProperties() {
		return properties;
	}

	public void setProperties(Properties properties) {
		this.properties = properties;
	}
	
	
}

xml文件配置

<?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">

	<!-- 注册Teacher对象 -->
	<bean class="com.zhouym.javabean.Teacher">		
		<property name="properties">
			<props>
				<prop key="id">1</prop>
				<prop key="name">张三</prop>
			</props>
		</property>
	</bean>	
 </beans>

测试类

package com.zhouym.junitTest;
import java.util.Properties;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.zhouym.javabean.Teacher;
public class JunitTest {

	@Test
	public void test() {
		ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");		
		Teacher ub = ac.getBean(Teacher.class);	
		Properties p = ub.getProperties();
		System.out.println(p.getProperty("id"));
		System.out.println(p.getProperty("name"));
	}

}

测试结果
在这里插入图片描述

原文链接：https://blog.csdn.net/zhouym_/article/details/94407231