Java EE之SSM框架整合开发 -- (2) Spring IoC

本章主要讲解内容:Spring IoC的基本概念、Spring IoC容器、依赖注入的类型。

2.1 Spring IoC的基本概念

控制反转Inversion of Control,IoC)是一个比较抽象的概念,是Spring框架的核心,用来消减计算机程序的耦合问题。依赖注入(Dependency Injection,DI)是IoC的另外一种说法,只是从不同的角度,描述相同的概念。

    比如我们想吃面包了:我们以前只能是需要自己去买面粉自己做出来吃。
  但是现在都有实体店或者网店了,完全可以把自己想要的口味告诉店家,让店家来制作。
  此时,我们自己并没有动手做面包,而是由店家制作,但是这个面包完全符合我们的口味。
    这个例子非常生动的讲解了控制反转的思想,即把制作面包的主动权交给店家。

当某个Java对象(调用者,比如您)需要调用另一个Java对象(被调用者,即被依赖对象,比如面包)时,在传统编程模式下,调用者通常会采用“new 被调用者”的代码方式来创建对象(比如您自己制作面包)。这种方式会增加调用者与被调用者之间的耦合性,不利于后期代码的升级与维护。

当Spring框架出现后,对象的实例不再由调用者来创建,而是由Spring容器(比如面包店)来创建。Spring容器会负责控制程序之间的关系(比如面包店负责控制您与面包的关系),而不是由调用者的程序代码直接控制。这样,控制权由调用者转移到Spring容器,控制权发生了反转,这就是Spring的控制反转。

从Spring容器角度来看,Spring容器负责将被依赖对象赋值给调用者的成员变量,相当于为调用者注入它所依赖的实例,这就是Spring的依赖注入。

控制反转是一种通过描述(在Spring中可以是XML或注解)并通过第三方去产生或获取特定对象的方式。在Spring中实现控制反转的是IoC容器,其实现方法是依赖注入。

如果大家不太理解,还可以看看这种解释:

IOC(控制反转):全称为:Inverse of Control。从字面上理解就是控制反转了,将对在自身对象中的一个内置对象的控制反转,反转后不再由自己本身的对象进行控制这个内置对象的创建,而是由第三方系统去控制这个内置对象的创建。
DI(依赖注入):全称为Dependency Injection,意思自身对象中的内置对象是通过注入的方式进行创建。
那么IOC和DI这两者又是什么关系呢?
IOC就是一种软件设计思想,DI是这种软件设计思想的一个实现。而Spring中的核心机制就是DI。

2.2 Spring IoC容器

Spring IoC容器的设计主要是基于BeanFactory和ApplicationContext两个接口。

2.2.1 BeanFactory

BeanFactory提供了完整的IOC服务支持,是一个管理Bean的工厂,主要负责初始化各种Bean

创建BeanFactory实例时,需要提供XML文件的绝对路径。例如,可以将第一章ch1应用中main方法的代码修改如下:

//初始化Spring容器,加载配置文件
BeanFactory beanFac = new XmlBeanFactory(
new FileSystemResource("D:\\eclipse-workspace\\ch1\\src\\applicationContext.xml")
);
//通过容器获取test实例    
TestDao tt = (TestDao)beanFac.getBean("test");    
tt.sayHello();

使用BeanFactory实例加载Spring配置文件在实际开发中不多见,我们了解以下即可。

2.2.2 ApplicationContext

ApplicationContext是BeanFactory的子接口,也称为应用上下文,它除了包含BeanFactory的所有功能以外,还添加了对国际化、资源化、事件传播等内容的支持。

创建ApplicationContext接口实例通常有三种方法:

1.通过ClassPathXmlApplicationContext创建

ClassPathXmlApplicationContext将从类路径classPath目录(src根目录)寻找指定的XML配置文件,例如:

ApplicationContext appCon = new ClassPathXmlApplicationContext("applicationContext.xml");

2.通过FileSystemXmlApplicationContext创建

FileSystemXmlApplicationContext将从指定文件的绝对路径中寻找XML配置文件(不常用),找到并装载完成ApplicationContext的实例化工作。例如:

ApplicationContext appCon = 
new FileSystemXmlApplicationContext("D:\\eclipse-workspace\\ch1\\src\\applicationContext.xml");

3.通过Web服务器实例化ApplicationContext容器

Web服务器实例化ApplicationContext容器时,一般使用基于org.springframework.web.context.ContextLoaderListener的实现方式(需要将spring-web-5.0.2.RELEASE.jar复制到WEB-INF/lib目录中),此方法只需在web.xml中添加如下代码:

<context-param>
    <!-- 加载src目录下的applicationContext.xml文件 -->
    <param-name>contextConfigLocation</param-name>
    <param-value>
      classpath:applicationContext.xml
    </param-value>
  </context-param>
  <!-- 指定以ContextLoaderListener方式启动Spring容器 -->
  <listener>
    <listener-class>
      org.springframework.web.context.ContextLoaderListener
    </listener-class>
  </listener>

2.3 依赖注入的类型

在Spring中实现IoC容器的方法是依赖注入依赖注入的作用是在使用Spring框架创建对象时,动态地将其所依赖的对象(如属性值)注入Bean组件中。Spring框架的依赖注入通常有两种实现方式:一种是构造方法注入,另一种是属性setter方法注入

2.3.1 构造方法注入

Spring框架可以采用Java的反射机制,通过构造方法完成依赖注入。在ch2应用中,创建dao包,并在该包中创建TestDIDao接口和接口实现类TestDIDaoImpl。创建dao的目的是在service中使用构造方法依赖注入TestDIDao接口对象。

package dao;
import org.springframework.stereotype.Service;
@Service
public class TestDIDaoImpl implements TestDIDao{
  @Override
  public void sayHello() {
    System.out.println("TestDIDao say: Hello, Study hard!");
  }
}
package dao;
public interface TestDIDao {
  public void sayHello();
}

在ch2应用中,创建service包,并在该包中创建TestDIService接口和接口实现类TestDIServiceImpl在TestDIServiceImpl中使用构造方法依赖注入TestDIDao接口对象。

package service;
import dao.TestDIDao;
public class TestDIServiceImpl implements TestDIService{
  private TestDIDao testDIDao;
  //构造方法,用于实现依赖注入
  public TestDIServiceImpl(TestDIDao testDIDao) {
    super();
    this.testDIDao = testDIDao;
  }
  @Override
  public void sayHello() {
    //调用testDIDao中的sayHello方法
    testDIDao.sayHello();
    System.out.println("TestDIService 构造方法 注入  say: Hello, Study hard!");
  }
}

在src根目录下,创建Spring配置文件applicationContext.xml。在配置文件中,首先,将dao.TestDIDaoImpl类托管给Spring,让Spring创建其对象。其次,将service.TestDIServiceImpl类托管给Spring,让Spring创建其对象,同时给构造方法传递实参

<?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">
  <!-- 将指定类TestDIDaoImpl配置给Spring,让Spring创建其实例 -->
  <bean id="myTestDIDao" class="dao.TestDIDaoImpl" />
  <!-- 使用构造方法注入 -->
  <bean id="testDIService" class="service.TestDIServiceImpl">
    <!-- 将myTestDIDao注入到TestDIServiceImpl类的属性 testDIDao上-->
    <constructor-arg index="0" ref="myTestDIDao"/>
  </bean>
  <!-- 使用setter方法注入 -->
  <bean id="testDIService1" class="service.TestDIServiceImpl1">
    <!-- 调用TestDIServiceImpl1类的setter方法,将myTestDIDao注入到 TestDIServiceImpl1类的属性testDIDao上-->
    <property name="testDIDao" ref="myTestDIDao"/>
  </bean>
</beans>

在ch2应用中,创建test包,并在该包中创建测试类TestDI,具体代码如下:

package test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.TestDIService;
public class TestDI {
  public static void main(String[] args) {
    //初始化Spring容器ApplicationContext,加载配置文件
    ApplicationContext appCon = new ClassPathXmlApplicationContext("applicationContext.xml");
    //通过容器获取testDIService实例,测试构造方法 注入
    TestDIService ts = (TestDIService)appCon.getBean("testDIService");
    ts.sayHello();
    //通过容器获取testDIService实例,测试setter方法注入 
    TestDIService ts1 = (TestDIService)appCon.getBean("testDIService1");
    ts1.sayHello();
  }
}

2.3.2 属性setter方法注入

setter方法注入是Spring框架中最主流的注入方式,它利用Java Bean规范所定义的setter方法来完成注入,灵活且可读性高。setter方法注入,Spring框架也是使用Java的反射机制实现的。

在service包中,创建接口实现类TestDIServiceImpl1,在TestDIServiceImpl1中使用属性setter方法依赖注入TestDIDao接口对象。

package service;
import dao.TestDIDao;
public class TestDIServiceImpl1 implements TestDIService{
  private TestDIDao testDIDao;
  //添加testDIDao属性的setter方法,用于实现依赖注入
  public void setTestDIDao(TestDIDao testDIDao) {
    this.testDIDao = testDIDao;
  }
  @Override
  public void sayHello() {
    //调用testDIDao中的sayHello方法
    testDIDao.sayHello();
    System.out.println("TestDIService setter方法注入  say: Hello, Study hard!");
  }
}

将service.TestDIServiceImpl1类托管给Spring,让Spring创建其对象。同时,调用TestDIServiceImpl1类的setter方法完成依赖注入。在配置文件添加如下代码:

<!-- 使用setter方法注入 -->
<bean id="testDIService1" class="service.TestDIServiceImpl1">
<!-- 调用TestDIServiceImpl1类的setter方法,将myTestDIDao注入到 TestDIServiceImpl1类的属性testDIDao上-->  
  <property name="testDIDao" ref="myTestDIDao"/>
</bean>

在主类中,添加如下代码测试setter方法注入:

//通过容器获取testDIService实例,测试setter方法注入 
    TestDIService ts1 = (TestDIService)appCon.getBean("testDIService1");
    ts1.sayHello();

最后,测试截图:

本章总结

一 为什么要使用Spring:

  1. 使用Spring框架主要是为了简化Java开发(大多数框架都是为了简化开发),它帮我们封装好了很多完善的功能,而且Spring的生态圈也非常庞大。
  2. 基于XML的配置是Spring提供的最原始的依赖注入配置方式,从Spring诞生之时就有了,功能也是最完善的(但是貌似有更好的配置方法,明天看看!)。

二 为什么要使用依赖注入:

  1. 传统的代码,每个对象负责管理与自己需要依赖的对象,导致如果需要切换依赖对象的实现类时,需要修改多处地方。同时,过度耦合也使得对象难以进行单元测试。
  2. 依赖注入把对象的创造交给外部去管理,很好的解决了代码紧耦合(tight couple)的问题,是一种让代码实现松耦合(loose couple)的机制。
  3. 松耦合让代码更具灵活性,能更好地应对需求变动,以及方便单元测试

参考链接:

IOC和DI到底是什么?

https://www.cnblogs.com/huangweikun/p/5187356.html

https://blog.csdn.net/hzy38324/article/details/78013136

原文发布于微信公众号 - 浩Coding(gh_c4a2e63d2ca7)

原文发表时间:2019-03-13

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券