Spring 的控制反转/依赖注入
Posted tea_year
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring 的控制反转/依赖注入相关的知识，希望对你有一定的参考价值。
第一章 Spring 的控制反转/依赖注入
回顾
增删改查。
课前测：
本章内容
spring:春天 IOC：将创建对象的权力交给 spring 核心容器去控制。工厂模式
BeanFactory: 懒汉
ApplicationContext: 饿汉
< bean id="" name="" class="" scope="" >
getBean的三种方式： id 类型 id+类型
创建对象的三种方式：1.默认使用无参构造创建 2.使用工厂静态方 3.实例方法
生命周期：
单例对象：关闭容器时，销毁对象
多利对象：GC垃圾回收机制 (守护线程)
第一节：Spring 春天
控制：对象的创建。
控制反转：将创建对象的权力交给 spring 核心容器去控制。
1.简介
框架：半成品软件，由美国技术大拿开发.
spring 生态圈,spring全家桶（spring MVC boot cloud data security)
SSM : spring springMVC Mybatis
srpringboot cloud
Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IOC（Inverse Of Control:控制反转）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 SpringMVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的 Java EE 企业应用开源框架。
MVC model view controller=====>三层架构 service
模型(实体和dao) 视图(jsp) 控制器(servlet)—>
三层架构：
展现层web：controller（页面的跳转）,jsp（页面）
持久层：dao （数据操作）
业务层：service (业务逻辑)
2.Spring的发展历程
1997 年 IBM 提出了 EJB 的思想
1998 年，SUN 制定开发标准规范 EJB1.0
1999 年，EJB1.1 发布
2001 年，EJB2.0 发布
2003 年，EJB2.1 发布
2006 年，EJB3.0 发布
Rod Johnson（spring 之父）
Expert One-to-One J2EE Design and Development(2002)
阐述了 J2EE 使用 EJB 开发设计的优点及解决方案
Expert One-to-One J2EE Development without EJB(2004)
阐述了 J2EE 开发不使用 EJB 的解决方式（Spring 雏形）
2017 年 9 月份发布了 spring 的最新版本 spring 5.0 通用版（GA）
3. Spring的优点
servlet调用dao
BookDao bookdao = new BookDaoImpl();
- 方便解耦，简化开发
通过 Spring 提供的 IoC 容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造
成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可
以更专注于上层的应用。
- AOP 编程的支持
通过 Spring 的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以
通过 AOP 轻松应付。
- 声明式事务的支持
可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，
提高开发效率和质量。
- 方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可
做的事情。
-
方便集成各种优秀框架
Spring 可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接支持。
微软（邪教) J++ SunPK(正教人多，分散，谁都听谁的,Spring第三方框架，IBM HP EMC 通用 宇通等)
Spring崛起把微软干趴下了
- 降低 JavaEE API 的使用难度
Spring 对 JavaEE API（如 JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些 API 的
使用难度大为降低。
- Spring 源码是经典学习范例
Spring 的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对 Java 设计模式灵活运用以
及对 Java 技术的高深造诣。它的源代码无疑是 Java 技术的最佳实践的范例。
4.Spring的体系结构
javaBean
模块
Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图 1 所示。
ORM 持久层框架
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bRxjDwbz-1645885880916)(assets/HemWeNoCPcQvsarJ.png!thumbnail)]
组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：
-
核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是
BeanFactory，它是工厂模式的实现。BeanFactory使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。 -
Spring 上下文：Spring 上下文是一个配置文件xml，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
-
Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
-
Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
-
Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
-
Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
-
Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。
Spring 框架的功能可以用在任何 J2EE 服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同 J2EE 环境 （Web 或 EJB）、独立应用程序、测试环境之间重用。
第二节：Spring的IOC控制反转
1.为什么要用 Spring
目的：降低耦合：对象与对象之间的耦合。
举个栗子：
如何解决这个问题呢？使用工厂模式解决。
代码改过后并没有完成我们的目的。此时如果将Food变成了Food1还是要一个一个修改。
如何解决？使用接口的多态。
2.程序的耦合 (课下自己看)
耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。
它有如下分类：
（1）内容耦合。当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。
（2）公共耦合。两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。
（3） 外部耦合 。一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合。
（4） 控制耦合 。一个模块通过接口向另一个模块传递一个控制信号，接受信号的模块根据信号值而进行适当的动作，这种耦合被称为控制耦合。
（5）标记耦合 。若一个模块 A 通过接口向两个模块 B 和 C 传递一个公共参数，那么称模块 B 和 C 之间存在一个标记耦合。
（6） 数据耦合。模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的一种耦合形式，系统中一般都存在这种类型的耦合，因为为了完成一些有意义的功能，往往需要将某些模块的输出数据作为另一些模块的输入数据。
（7） 非直接耦合 。两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的。
**总结：**耦合是影响软件复杂程度和设计质量的一个重要因素，在设计上我们应采用以下原则：如果模块间必须存在耦合，就尽量使用数据耦合，少用控制耦合，限制公共耦合的范围，尽量避免使用内容耦合。
内聚与耦合：内聚标志一个模块内各个元素彼此结合的紧密程度，它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。 程序讲究的是低耦合，高内聚。就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却要不那么紧密。内聚和耦合是密切相关的，同其他模块存在高耦合的模块意味着低内聚，而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时，应力争做到高内聚，低耦合。
3. 解决方案（IOC控制反转）
什么是IOC ?
控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。使用对象的时候不再是我们直接new，而是将创建对象的权利交给框架中的核心容器，需要使用对象的时候直接从容器中获取。
IoC的思想早就出现了，但是没有一个具体的实现，大家都是各自根据这个思想去写代码(自己去创建工厂)。后来有一个大师 Rod Johnson（Spring Framework创始人，著名作者。 Rod在悉尼大学不仅获得了计算机学位，同时还获得了音乐学位。更令人吃惊的是在回到软件开发领域之前，他还获得了音乐学的博士学位。），写了一个框架，将IoC思想具体的实现了，这个框架后来起了个名字叫做 Spring。（因为在这之前 大家都是用hibernate这个框架，这个框架中文名字叫做冬眠，并且这个框架比较笨重，耦合比较高。Rod Johnson写的框架就是用来解决类似于hibernate高耦合的问题 ，所以他将自己框架的名字命名为 Spring 告诉全世界 冬天过去了 春天来了）。
第三节：spring项目的搭建
1.1 下载jar包
官网：http://spring.io/
下载地址：https://repo.springsource.org/libs-release-local/org/springframework/spring
现在Spring–>生态圈（全家桶）
解压:
(Spring 目录结构:)
* docs :API 和开发规范。
* libs :jar 包和源码。
*schema :约束。
创建项目并导入jar包
1.2 配置bean.xml文件
1.3 编写测试代码并运行
测试类中可以通过两种方式获取Bean对象的创建。
参考以下，两个接口的区别：
输出结果，可以观察到对象的创建,方法的调用
2.spring对Bean对象的管理细节
spring的核心组件：BeanFactory 接口 和 ApplicationContext接口
两者功能类似。
2.1 ApplicationContext 和BeanFactory 两个接口的区别
spring工厂中类的结构图。
BeanFactory接口
Spring容器顶层接口：获取Bean对象;管理类和类之间的关系(依赖关系)BeanFactory由org.springframework.beans.factory.BeanFactory接口定义 BeanFactory是工厂模式（Factory pattern）的实现，是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。
BeanFactory接口包含以下基本方法——ApplicationContext肯定都有，因为他是子接口，加强版
boolean containsBean(String beanName) 判断工厂中是否包含给定名称的bean定义，若有则返回true。
Object getBean(String str)返回给定名称注册的bean实例。根据bean的配置情况，如果是singleton模式将返回一个共享实例，否则将返回一个新建的实例，如果没有找到指定bean,该方法可能会抛出异常。
Object getBean(String, Class) 返回以给定名称注册的bean实例，并转换为给定class类型
Class getType(String name) 返回给定名称的bean的Class,如果没有找到指定的bean实例，则排除NoSuchBeanDefinitionException异常
boolean isSingleton(String) 判断给定名称的bean定义是否为单例模式
String[] getAliases(String name) 返回给定bean名称的所有别名
ApplicationContext接口
是基于BeanFactory之上的，提供了应用程序框架服务，扩展的新功能如下：提供国际化的支持资源访问，如URL和文件 事件传递载入多个配置文件等 实现类常见有三个
ClassPathXmlApplicationContext：-classpath路径加载xml文件的
FileSystemXmlApplicationContext：基于项目根路径进行加载xml文件的
AnnotationConfigApplicationContext：基于注解的配置。基于类书写的配置。
package com.aaa.qy127.controller;
import com.aaa.qy127.service.SpringService;
import com.aaa.qy127.service.impl.SpringServiceImpl;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
/**
* @ClassName SpringTest
* @Description ToDo
* @Auther teacher Bai
* @Date 2020/12/19 10:31
*/
public class SpringTest
public static void main(String[] args)
//这是使用自己new 对象的方式创建对象
//SpringService service = new SpringServiceImpl();
/*
使用读取bean.xml的方式 创建对象
首先需要读取bean.xml文件
怎么读？
1.使用BeanFactory（spring核心容器的顶层接口）
2.使用BeanFactory的子接口 ApplicationContext(自接口功能更加强大) 常用！
*/
/**
* 1.使用BeanFactory（spring核心容器的顶层接口）
* ① 读取bean.xml配置文件
* ClassPathResource resource = new ClassPathResource("bean.xml");
* ② 读取第①步中bean.xml文件中的信息
* XmlBeanFactory factory = new XmlBeanFactory(resource);
* ③ 通过获取到的factory取出bean对象
* Object service1 = factory.getBean("service1");
*/
ClassPathResource resource = new ClassPathResource("bean.xml");
XmlBeanFactory factory = new XmlBeanFactory(resource);
Object service1 = factory.getBean("service1");
SpringService service = (SpringServiceImpl) service1;
service.print1();
/**
* 2.使用BeanFactory的子接口 ApplicationContext(自接口功能更加强大) 常用！
* ① 读取bean.xml配置文件
* 使用ClassPathXmlApplicationContext实现类 （类路径下的bean.xml）
* ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
* 使用FileSystemXmlApplicationContext实现类 读取文件 （文件系统路径下的bean.xml）
* ApplicationContext context = new FileSystemXmlApplicationContext("E:\\\\课堂笔记\\\\QY127\\\\spring\\\\Spring01-IOC和DI\\\\spring-02\\\\src\\\\bean.xml");
* ② 通过获取到的context取出bean对象
* SpringService service1 = (SpringServiceImpl)context.getBean("service1");
*
*/
//ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
ApplicationContext context = new FileSystemXmlApplicationContext("E:\\\\课堂笔记\\\\QY127\\\\spring\\\\Spring01-IOC和DI\\\\spring-02\\\\src\\\\bean.xml");
SpringService service1 = (SpringServiceImpl)context.getBean("service1");
service1.print1();
面试题：BeanFactory 和 ApplicationContext 的区别：
BeanFactory 才是 Spring 容器中的顶层接口。
ApplicationContext 是它的子接口。
单例模式下创建对象的时间点不一样：
ApplicationContext：(饿汉模式)只要一读取配置文件，马上就会创建配置文件中配置的对象。
BeanFactory：(懒加载/懒汉模式)什么时候getBean("id")，也就是说当根据id获取对象时，才会创建。
2.1.1 Spring中的测试函数使用
@Test
public void test01()
ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
People bean = context.getBean(People.class);
System.out.println(bean);
我们使用 Junit测试 每次都需要创建 ApplicationContext 对象 非常麻烦，所以使用Spring的测试 性能更好 而且方便。
A 导入测试包
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.Springframework</groupId>
<artifactId>Spring-test</artifactId>
<version>5.3.7</version>
</dependency>
B 在测试类中 添加注解
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:Spring.xml")
public class JavaTest
@Autowired
private ApplicationContext context;
@Autowired
private People p1;
@Test
public void test()
People bean = context.getBean(People.class);
System.out.println(bean);
@Test
public void test01()
System.out.println(p1);
2.2 getBean()的三种方式
A 通过bean.xml文件中bean标签的id的值获取bean(使用默认构造方法)
Object p1 = context.getBean("唯一标识id");//此处获取的是一个Object类型，可以转换成我们需要的类型。
B 通过类型去获取
People bean = context.getBean(类名.class);
确保bean的类型是唯一的 不然会报错：org.springframework.beans.factory.NoUniqueBeanDefinitionException
C 通过 id + 类型去获取
People bean = context.getBean("p1",People.class);
2.3 创建Bean对象的方式
bean的属性配置
id ： 当前bean的唯一标识符
class：配置类的全限定名/全路径
name：配置当前bean的名字，并且可以配置多个。
-
第一种方式：使用默认构造创建（常用）直接去调用 bean对象中的无参空构造方法来创建对象
在spring的bean.xml文件中配置过bean标签，并且设置id和class属性后，会自动的调用默认构造创建对象，如果没有默认的空构造，则对象无法创建。
<bean id="唯一标识id" class="类的全限定名"></bean> -
第二种方式：使用普通工厂中的方法创建对象(使用某个类中的方法创建对象，并存入spring容器)
ServiceFactory factory = new ServiceFactory(); <bean id="普通工厂类的唯一标识" class="工厂类的全限定名"></bean> factory.getService(); <bean id="需要通过工厂创建的对象" factory-bean="上边bean的id" factory-method="工厂中的方法名"></bean> -
第三种方式：使用普通工厂的静态方法创建对象
<!--使用静态工厂的方式创建bean对象--> <bean id="accountService" class="工厂类的全类名" factory-method="生产对象的静态方法"></bean>
2.4 bean对象的作用范围
bean对象的作用范围调整需要配置scope属性，设置单例还是多例（只针对ApplicationContext接口来说，默认是单例的）
scope：常用 singleton,prototype
singleton：单例的（默认值）当加载配置文件时，就会创建对象。
prototype：多例的（当getBean时才会创建对象）
request：作用于请求范围
session：作用于会话范围
global-session: 全局，作用于分布式集群环境。如果不是集群环境，就是session
<bean id="唯一标识" class="全类名" scope="singleton/prototype"></bean>
默认为singleton单例的：整个程序运行期间对象只会被创建一次。
prototype 多例的，在程序运行期将，用了几次就创建几次对象。
多例对象java的GC垃圾回收机制，在检测到对象长时间不用时，会自动回收/销毁。
2.5 bean对象的生命周期
有的类 对象被创建的时候需要调用初始化函数，对象被回收的时候需要调用销毁函数。现在对象时由spring核心容器去管理的。所以这些函数的调用应该由spring负责。我们只需要通过配置告诉spring初始化函数是谁，销毁函数是谁。bean的生命周期函数。可以同过配置两个方法测试。
init-method：对象的初始化方法
destroy-method：销毁对象的方法（main方法测试时，不会调用销毁方法，是因为还没来得及，速度太快，可以手动销毁，调用close()；方法，但是此时ApplicationContext对象应该是子类类型，不能再是ApplicationContext类型了)；
-
单例对象：
出生：当容器创建时，对象出生
活着：只要容器还在，对象一直存在
死亡：容器销毁，对象也销毁
初始化方法会被调用，但是销毁方法如果是使用ApplicationContext接口类型，销毁方法无法被调用，需要使用子接口类型，才可以看到销毁方法被调用。context.close();
-
多例对象
出生：当使用对象时，才会创建
活着：只要使用，一直活着
死亡：java垃圾回收机制，当对象长时间不用时，GC垃圾回收机制，自动回收。
作业：
1. 复习 servlet所有知识点
2. 掌握今天讲解的知识点
3. 预习 依赖注入和springMVC
4. 增删改查不行的，接着搞！
第四节：依赖注入DI
相当于你请对象去吃饭、买衣服、送礼物啊
IOC:控制反转 创建对象！
依赖注入：目的就是给对象中的属性赋值。
对象中的属性都可以是哪些数据类型：基本类型，String , Date, List<?>----->基本，引用
1.简介
依赖注入(Dependency Injection)
IOC控制反转的最终目的就是降低程序的耦合，也就是削减依赖关系。
依赖关系的管理以后都交给spring维护，依赖关系的管理就称之为依赖注入。也就是说在当前类需要用到其它类的对象时，由spring为我们提供，我们只需要在配置文件中说明依赖关系的维护就可以了。
依赖注入的方式：
依赖注入的数据：三种类型
1. 基本数据类型和String
2. 其它bean实体对象类型(在配置文件中或者注解配置过的bean)
3. 复杂类型/集合类型(集合类型只能通过配置文件注入)
什么时候使用IOC和DI创建对象？
如果是单例对象，可以使用IOC和DI。整个程序运行期间只会创建一个对象，我们不用考虑对象中数据的改变。
但是，如果我们要创建的对象中的属性值，一直在改变，此时就不推荐使用DI和IOC了。
2.第一种：使用构造函数提供注入
argument
如果使用构造函数注入，需要在bean.xml文件的bean标签中添加constructor-arg标签
标签中的属性：
type : 用于指定要注入的数据的类型，该数据类型也是构造函数中某个或某些参数的类型。
index: 用指定给构造函数中指定索引位置的参数赋值，索引从0开始。
name: 用于给构造函数的参数赋值，指定参数的名称直接赋值 （常用）
value : 用于提供基本类型和String类型的数据
ref : 用于指定其它的bean类型数据，它指的就是在spring的IOC核心容器中出现过的bean
注意：在获取bean对象时，必须要注入数据，否则对象无法创建成功。
缺点：改变了bean对象的实例化方式，就算我们在创建对象时，用不到这些数据，也必须提供。
<!--构造注入-->
<bean id="p1" class="com.bai.demo2.entity.Person">
<constructor-arg name="age" value="18"></constructor-arg>
<constructor-arg name="name" value="张三"></constructor-arg>
<constructor-arg name="date" ref="d1"></constructor-arg>
</bean>
<!--日期对象的bean-->
<bean id="d1" class="java.util.Date"></bean>
3.第二种：使用set方法注入(常用)
如果使用set函数注入，需要在bean.xml文件的bean标签中添加 property 标签
需要属性：
name: 用于给无参空构造函数的参数赋值，指定设值的set方法（将set方法的set去掉把大写字母变小写 setAge()====>age）
value : 用于提供基本类型和String类型的数据
ref : 用于指定其它的bean类型数据，它指的就是在spring的IOC核心容器中出现过的bean
**优点：**解决了构造注入时的问题，可以选择性的注入值，不是必须注入全部了。
<!--注入java提供的Date类-->
<bean id="date" class="java.util.Date"></bean>
<!--set方法注入-->
<bean id="person" class="com.aaa.ioc.Person">
<property name="name" value="李四"></property>
<property name="age" value="29"></property>
<property name="birthday" ref="date"></property>
</bean>
3.复杂数据类型的注入
数组、集合（LIst、Set、Map、Properties）
<!-- 配置bean，放在spring的IOC容器-->
<bean id="depart" class="com.aaa.entity.Depart">
<property name="id" value="1"/>
<property name="name" value="腾讯战略投研部"/>
<!-- 集合的注入;array n个子标签value -->
<property name="emps">
<array>
<value>马化腾</value>
<value>刘治平</value>
<value>江二涛</value>
<value>以上是关于Spring 的控制反转/依赖注入的主要内容，如果未能解决你的问题，请参考以下文章