Java开发工程师(Web方向) - 04.Spring框架 - 第2章.IoC容器

Posted FudgeBear

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java开发工程师(Web方向) - 04.Spring框架 - 第2章.IoC容器相关的知识,希望对你有一定的参考价值。

第2章.IoC容器

IoC容器概述

abstract: 介绍IoC和bean的用处和使用

IoC容器处于整个Spring框架中比较核心的位置:Core Container: Beans, Core, Context, SpEL

为上层AOP/Aspects/Instrumentation/Messaging提供支持

IoC容器的用途:

创建对象的依赖,最后组装成所需的业务对象

容器通过业务对象和配置(application-context.xml; xxxController.java)-->生成可用对象

在Spring场景下,把对象A/B/C都称作Bean

从代码角度看,一个ApplicationContext (org.springframework.context包下,属于spring-context依赖中)对象就是一个IoC容器

初始化IoC容器:

在web项目的web.xml中,用

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:application-context.xml</param-value>

</context-param>

ApplicationContext context = new ClassPathXmlApplicationContext("application-context.xml");

(文件系统中:ApplicationContext context = new FileSystemXmlApplicationContext("/home/user/conf/application-context.xml");)

来初始化。

定义一个Bean:

在application-context.xml中

<beans>

...

<bean id="screwDriver" class="package_url"></bean>

</beans>

使用Bean:

1. 初始化容器:ApplicationContext context = new ClassPathXmlApplicationContext("application-context.xml");

2. 通过getBean()获取对象:ScrewDriver screwDriver = context.getBean("screwDriver", ScrewDriver.class);

3. 使用对象:screwDriver.use();

实例演练: 

1. New Maven Project -> Create a simple project (skip archetype selection)

GroupId: com.netease.nanodegree

ArtifactId: spring-container

2. 将所需依赖加入pom.xml

<dependencies>
     <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.2.1.RELEASE</version>
    </dependency>
</dependencies> 

发现依赖的jar包自动被加入

3. 在src/main/resources/下新建application-context.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"
    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
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
    
</beans>

此时,还未定义任何bean,因此还不能从容器中获取任何bean

4. 在src/main/java/下新建类ScrewDriver.java

package: com.netease.nanodegree;

package com.netease.nanodegree;

public class ScrewDriver {
    public void ues () {
        System.out.println("Use screw driver");
    }
}

5. 此时有了bean,在application-context.xml中加入相关bean的定义

<bean id = "screwDriver" class = "com.netease.nanodegree.ScrewDriver"></bean>

6. 在src/main/java/com.netease.nanodegree下新建测试类TestContainer.java

7. Run as -> Java Application

Bean的作用域:Bean的有效范围

singleton:与设计模式中的singleton有点像

保证对象在整个容器中最多只能有一个单例,也保证在整个生命周期中只会创建一个实例

上例中bean定义的默认作用域就是singleton

也可以显式定义<bean id="screwDriver" class="com.netease.nanodegree.ScrewDriver" scope="singleton"></bean>

例子Test:

ScrewDriver.java 

public class ScrewDriver {    
    private String color = "red";
    public void use () {
        //System.out.println("Use screw driver");
        System.out.println("Use " + color + " screw driver");
    }
    
    public void setColor (String color) {
        this.color = color;
    }
}

TestContainer.java

public class TestContainer {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("application-context.xml");

        ScrewDriver screwDriver = context.getBean("screwDriver", ScrewDriver.class);
        screwDriver.setColor("green");
        screwDriver.use();
        
        ScrewDriver screwDriver2 = context.getBean("screwDriver", ScrewDriver.class);
        screwDriver2.use();
    }
}

要想测试是不是单例对象,使用getBean()得到两个对象并设置属性为"green",如果是单例,则两个对象的属性均为"green"

应用:大部分场景下使用singleton模式就能满足业务需求,比如Servlet实例,开始时创建实例,结束时销毁实例,在中间时只需这一个实例来处理即可。

prototype:每次引用时都需要创建一个新的对象/实例,比如每次使用时不希望保留上一次的属性值/状态

<bean id=... class=... scope="prototype"></bean>

例子Test:

将bean screwDriver的scope改为prototype;

此时打印出来的结果应该是第一次为green(因为使用setColor()改了),第二次为red(因为初始为red且并未无改动)

在web应用场景下才出现的作用域:

request:在每个request中分别创建和销毁bean

比如在request1开始时创建了若干个beans,结束时这些beans就被销毁了;而另一个request中又是一个request scope,有它自己的bean的创建和销毁

session:在每个session中的作用域

每个用户对应一个session,在session中可能若干个requests,但是sessionBean在这些request之间是可以共享的

而多个session会有各自的session scope

global session:在此不做介绍

application:每个session之间需要共享的信息

Bean的生命周期回调:

有了Bean的作用域后,我们知道/控制bean的创建/销毁,但是我们不能控制创建/销毁时可以做哪些事情(比如申请/释放资源、创建线程池)--生命周期回调的功能可以支持实现这些功能

Spring提供了两种回调:

InitializingBean接口中的afterPropertiesSet()函数:

public interface InitializingBean {
    void afterPropertiesSet() throws Exception;
}

当一个bean创建完成后调用

例子:

<bean id=... class=... init-method="init"></bean>

public class ScrewDriver {
    public void init() {
        Syso("Init screw driver");
    }
}

 

DisposableBean接口中的destroy()函数:

public interface DisposableBean {
    void destroy() throws Exception;
}

当一个bean被销毁之后调用

例子:

<bean id=... class=... destroy-method="cleanup"></bean>

public class ScrewDriver {
    public void cleanup() {
        Syso("Clean up screw driver");
    }
}

 

测试Test结果:

<bean id = "screwDriver" class = "com.netease.nanodegree.ScrewDriver" scope="prototype" init-method="init" destroy-method="cleanup"></bean>

output:

发现没有进行cleanup的回调:因为bean没有被销毁

手动关闭:

((ConfigurableApplicationContext) context).close();

output:还是相同

将bean定义中的scope="prototype"改为默认的singleton后

成功执行cleanup()回调函数

 

依赖注入

第一章中举的例子:在ScrewDriver中声明变量private Header header = new StraightHeader();

虽然有抽象类header的想法,但是直接用new StraightHeader()创建实例,并没有将抽象的想法实施到位。

如果需要一个带有CrossHeader的screwDriver呢?需要修改ScrewDriver的代码:

private Header header = new CrossHeader();

如果要修改一字刀口螺丝刀的属性,比如颜色等,则需要修改constructor:

private Header header = new StraightHeader("green", 15);

此时:ScrewDriver和StraightHeader的关系是强依赖关系

在第一章中的IoC解决方法是在ScrewDriver的constructor中传入一个Header(抽象接口对象)作为参数

public ScrewDriver(Header header) { this.header = header; }

1. 定义接口:抽象接口Header

2. 实现接口:如StraightHeader和CrossHeader

3. 以接口为基础来进行依赖的注入

基于构造函数的依赖注入方式:如上例中的在constructor中传入接口对象的方法

基于Setter方法的依赖注入方式:和基于构造函数的方式很相近

public class ScrewDriver {
    private Header header;
    
    public setHeader(Header header) {
        this.header = header;
    }
}

那...究竟是选择哪一种方法呢?

实际开发中的原则:

如果关系是强依赖的,则基于构造函数(比如ScrewDriver必须有一个Header)

如果关系是可选依赖的,则基于Setter方法(可有可无的依赖)

实际开发中可能注入的是基本类型、集合、Bean,或通过配置文件注入等等

例子(只演示基于构造函数的依赖注入):

定义Header接口:Header.java

package com.netease.nanodegree;

public interface Header {
    public void doWork();
    public String getInfo();
}

定义实现类StraightHeader.java

package com.netease.nanodegree;

public class StraightHeader implements Header {
    private String color;
    private int size;

    public StraightHeader(String color, int size) {
        this.color = color;
        this.size = size;
    }

    @Override
    public void doWork() {
        System.out.println("Do work with straight header");
    }

    @Override
    public String getInfo() {
        return "Straight Header: " + this.color + ", " + this.size;
    }
} 

定义实现类CrossHeader.java(相似)

定义StraightHeader bean和CrossHeader bean

<bean id = "header" class = "com.netease.nanodegree.StraightHeader">
    <constructor-arg index="0" type="java.lang.String" value="red"></constructor-arg>
    <constructor-arg index="1" type="int" value="15"></constructor-arg>
</bean>

可以通过constructor-arg中的index来说明param的顺序;如index="0"; index="1";

可以通过type来说明param的类型;如type="int"; type="java.lang.String";

可以通过name来说明param的对应的变量名;如name="size"; name="color";

(index/type/name都不是必要的)

Test.java

public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("application-context.xml");

    Header header = context.getBean("header", StraightHeader.class);
    System.out.println(header.getInfo());
    header.doWork();
}

output:

如何注入集合呢?

通过map的方式注入

假设StraightHeader的构造函数为:

public StraightHeader(Map<String, String> params) {
    this.color = params.get("color");
    this.size = Integer.parseInt(params.get("size"));
}

此时,定义bean为(使用map的方法)

<bean id = "header" class = "com.netease.nanodegree.StraightHeader">
    <constructor-arg>
        <map>
            <entry key="color" value="red"></entry>
            <entry key="size" value="15"></entry>
        </map>
    </constructor-arg>
</bean> 

也可以注入List/Set之类的集合,配置也相似

<bean id = "header" class = "com.netease.nanodegree.StraightHeader">
    <constructor-arg>
        <list>
            <value>red</value>
            <value>14</value>
        </list>
    </constructor-arg>
</bean>

 

也可以通过配置文件加载一些配置项:比如注入Property的一些属性

<bean id = "header" class = "com.netease.nanodegree.StraightHeader">
    <constructor-arg>
        <props>
            <prop key="color">red</prop>
            <prop key="size">14</prop>
        </props>
    </props>
</bean>

对应的构造函数:

public StraightHeader(Properties props) {
    this.color = props.xxx;
    this.size = props.xxx;
}

 

那怎么通过配置文件注入呢?

在src/main/resources/下创建一个配置文件header.properties

color=green
size=16

在application-context.xml中加载该配置文件:

<bean id="headerProperties"
    class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location" value="classpath:header.properties"/>
</bean>

 property->value为配置文件所在地址

读取配置文件中的信息: 

<bean id = "header" class = "com.netease.nanodegree.StraightHeader">
    <constructor-arg name="color" value="${color}"></constructor-arg>
    <constructor-arg name="size" value="${size}"></constructor-arg>
</bean> 

上例注入的都是一些基础类型,如果是ScrewDriver需要注入一个Header类型(bean)的参数呢?

ScrewDriver.java

public class ScrewDriver {
    private Header header;
    
    public ScrewDriver(Header header) {
        this.header = header;
    }
    
    public void use () {
        System.out.println("Use screw driver with header " + header.getInfo());
    }
}

注入:

<bean id = "screwDriver" class = "com.netease.nanodegree.ScrewDriver">
    <constructor-arg>
        <ref bean="header"/>
    </constructor-arg>
</bean>

Test.java

ScrewDriver screwDriver = context.getBean("screwDriver", ScrewDriver.class);
screwDriver.use(); 

输出:

 

通过Setter实现注入:

需要删除constructor

加上Setter()

public void setColor(String color) { 
    this.color = color; 
}

public void setSize(int size) { 
    this.size = size;
}
<!-- setter方法注入 -->
<bean id = "header" class = "com.netease.nanodegree.StraightHeader">
    <property name="color" value="${color}"></property>
    <property name="size" value="${size}"></property>
</bean>
<bean id="headerProperties" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location" value="classpath:header.properties"/>
</bean>

 

如果一个bean有很多依赖呢?使用一个依赖添加一个配置的方法吗?

Spring提供了自动装配(Autowiring)的机制(三种)

byName: 根据Bean的名称 (Setter方法)

byType: 根据Bean的类型 (Setter方法)

constructor: 构造函数,根据类型

例子:

<!-- autowiring自动装配的方式 -->

<bean id = "screwDriver" class = "com.netease.nanodegree.ScrewDriver" autowire="byName"></bean>

<bean id = "screwDriver" class = "com.netease.nanodegree.ScrewDriver" autowire="byType"></bean> 

在ScrewDriver.java中,不再需要setter,只需在private Header header;前加上@Autowired即可

或使用@Resource(@Autowired和@Resource是存在不同包中的,前者在springframework中,后者在javax.annotation中,相对标准一些)

 

通过Annotation的方式

@Component:定义Bean

@Value:properties注入

@Autowired (Spring)/ @Resource (Java):自动装配依赖

@PostConstruct & @PreDestroy:生命周期回调

例子:

application-context.xml中:

<context:component-scan base-package="com.netease.nanodegree" />

表示支持通过Annotation来定义bean或其他属性。扫描/搜索com.netease.nanodegree包,使用Annotation的方式进行配置 

<?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"
    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
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
    
    <context:component-scan base-package="com.netease.nanodegree" />
    
    <bean id="headerProperties"
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:header.properties"/>
    </bean>
    
    <bean id = "screwDriver" class = "com.netease.nanodegree.ScrewDriver" autowire="byName"></bean>
</beans> 

StraightHeader.java中:

删除setters;

添加Annotation:

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Componentpublic class StraightHeader implements Header {
    @Value("${color}")
    private String color;
    @Value("${size}")
    private int size;

    @Override
    public void doWork() {...}

    @Override
    public String getInfo() {...}
}

报错:No bean named \'header\' is defined

因为写@Component时,默认name为StraightHeader而不是header,因此需要specify

@Component("header")

与生命周期有关的Annotation:

@PostConstruct
public void init() {
    System.out.println("init the header");
}
    
@PreDestroy
public void destroy() {
    System.out.println("destroy the header");
}

 

利弊:

XML文件:繁琐,但是代码独立(代码和配置分离);实际开发中有些东西需要XML文件来配置

Annotation:简洁,但是配置和代码耦合,配置位置分散,不好管理;实际开发中用于controller/service等

 

IoC容器单元测试

本次得分为:12.50/14.00, 本次测试的提交时间为:2017-09-11
1单选(2分)

下列关于IoC容器的描述错误的是:

  • A.容器必须由应用代码主动创建;2.00/2.00
  • B.应用可以从容器中获取所配置的对象;
  • C.容器负责所管理对象的生命周期管理;
  • D.根据会根据依赖关系组装对象;
2单选(2分)

如下关于自动装配(Autowiring)说法中,错误的是:

  • A.可以根据Bean名称自动注入;
  • B.可以根据Bean的类型通过Setter方法注入;
  • C.不可以根据Bean的类型通过构建函数注入;2.00/2.00
  • D.可以根据Bean的类型自动注入;
3单选(2分)

关于依赖注入方式,说法错误的是:

  • A.可选依赖可以通过构造函数注入;
  • B.可以通过构造函数注入;
  • C.强依赖必须通过构造函数注入;2.00/2.00
  • D.可以通过Setter方法注入;