Spring MVC -- Spring框架入门(IoC和DI)

时间:2024-01-17 19:07:56

Spring MVC是Spring框架中用于Web应用开发的一个模块。Spring MVC的MVC是Model-View-Controller的缩写。它是一个广泛应用于图像化用户交互开发中的设计模式,不仅常见于Web开发,也广泛应用于如Swing和JavaFX等桌面开发。

Spring MVC基于Spring框架、Servlet和JSP(JavaServer Page),在掌握这3门技术的基础上学习Spring MVC将非常容易。

Spring框架是一个开源的企业应用开发框架,作为一个轻量级的解决方案,它包含20多个不同的解决方法。我们主要关注Core、Spring Bean、Spring MVC和Spring MVC Test模块。

一 下载Spring

1、Spring下载

Spring框架下载官网:http://spring.io/projects,具体可以参考博客Spring框架下载方法

也可以直接下载:URL为最Spring最新5.1.6版本地址,获取其他版本只需修改下面链接的5.1.6的版本号信息成想要的版本即可:https://repo.spring.io/webapp/#/artifacts/browse/tree/General/libs-release-local/org/springframework/spring/5.1.6.RELEASE

将下载好的zip解压到任意目录,在解压的目录中,包含相应的文档和Java源代码,其中libs文件下为基于Spring框架开发应用所需要的jar文件。

Spring MVC -- Spring框架入门(IoC和DI)

2、Spring依赖包下载

关于spring的spring-framework-3.0.2.RELEASE-dependencies.zip包的下载:http://s3.amazonaws.com/dist.springframework.org/release/SPR/spring-framework-3.0.2.RELEASE-dependencies.zip

3、下载Spring源码

Spring框架是一个开源项目,如果你想要尚未发布的最新版本的Spring,可以使用在github上下载源代码:https://github.com/spring-projects/spring-framework

二 IoC和DI

Spring框架有两个重要的概念:控制翻转、依赖注入。 

1、IoC是什么

Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想。在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。如何理解好Ioc呢?理解好Ioc的关键是要明确“谁控制谁,控制什么,为何是反转(有反转就应该有正转了),哪些方面反转了”,那我们来深入分析一下:

  • 谁控制谁,控制什么:传统Java SE程序设计,我们直接在对象内部通过new进行创建对象,是程序主动去创建依赖对象;而IoC是有专门一个容器来创建这些对象,即由Ioc容器来控制对象的创建;谁控制谁?当然是IoC 容器控制了对象;控制什么?那就是主要控制了外部资源获取(不只是对象包括比如文件等);
  • 为何是反转,哪些方面反转了:有反转就有正转,传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象,也就是正转;而反转则是由容器来帮忙创建及注入依赖对象;为何是反转?因为由容器帮我们查找及注入依赖对象,对象只是被动的接受依赖对象,所以是反转;哪些方面反转了?依赖对象的获取被反转了。

用图例说明一下,传统程序设计如图,都是主动去创建相关对象然后再组合起来:

Spring MVC -- Spring框架入门(IoC和DI)

当有了IoC/DI的容器后,在客户端类中不再主动去创建这些对象了:

Spring MVC -- Spring框架入门(IoC和DI)

2  IoC能做什么

IoC不是一种技术,只是一种思想,一个重要的面向对象编程的法则,它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象,从而导致类与类之间高耦合,难于测试;有了IoC容器后,把创建和查找依赖对象的控制权交给了容器,由容器进行注入组合对象,所以对象与对象之间是松散耦合,这样也方便测试,利于功能复用,更重要的是使得程序的整个体系结构变得非常灵活。

其实IoC对编程带来的最大改变不是从代码上,而是从思想上,发生了“主从换位”的变化。应用程序原本是老大,要获取什么资源都是主动出击,但是在IoC/DI思想中,应用程序就变成被动的了,被动的等待IoC容器来创建并注入它所需要的资源了。

IoC很好的体现了面向对象设计法则之一—— 好莱坞法则:“别找我们,我们找你”;即由IoC容器帮对象找相应的依赖对象并注入,而不是由对象主动去找。

3、IoC和DI

DI—Dependency Injection,即“依赖注入”:是组件之间依赖关系由容器在运行期决定,形象的说,即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能,而是为了提升组件重用的频率,并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制,我们只需要通过简单的配置,而无需任何代码就可指定目标需要的资源,完成自身的业务逻辑,而不需要关心具体的资源来自何处,由谁实现。

理解DI的关键是:“谁依赖谁,为什么需要依赖,谁注入谁,注入了什么”,那我们来深入分析一下:

  • 谁依赖于谁:当然是应用程序依赖于IoC容器;
  • 为什么需要依赖:应用程序需要IoC容器来提供对象需要的外部资源;
  • 谁注入谁:很明显是IoC容器注入应用程序某个对象,应用程序依赖的对象;
  • 注入了什么:就是注入某个对象所需要的外部资源(包括对象、资源、常量数据)。

IoC和DI由什么关系呢?其实它们是同一个概念的不同角度描述,由于控制反转概念比较含糊(可能只是理解为容器控制对象这一个层面,很难让人想到谁来维护对象关系),所以2004年大师级人物Martin Fowler又给出了一个新的名字:“依赖注入”,相对IoC 而言,依赖注入”明确描述了“被注入对象依赖IoC容器配置依赖对象”。

注:如果想要更加深入的了解IoC和DI,请参考大师级人物Martin Fowler的一篇经典文章《Inversion of Control Containers and the Dependency Injection pattern》,原文地址:http://www.martinfowler.com/articles/injection.html

4、依赖注入具体案例

有两个组件A和B,A依赖于B。假设A是一个类,且A有一个方法importantMethod用到了B,如下:

class B{
public void usefulMethod() {}
} public class A{
public void importantMethod() {
//get an instance of B
B b = new B();
b.usefulMethod();
}
}

要使用B,类A必须先获得组件B的实例引用。若B是一个具体类,则可通过new 关键字之间创建组件B的实例。但是,如果B是接口,且有多个实现,则问题就变得复杂了。我们固然可以任意选择接口B的一个实现类,但是这意味着A的可重用性大大降低了,因为无法采用B的其他实现。

依赖注入是这样处理此类情景的:接管对象的创建工作,并将该对象的引用注入到需要该对象的组件中。以上述情况为例,依赖注入框架会分别创建对象A和对象B,然后将对象B注入到对象A中。

为了能让框架进行依赖注入,程序员需要编写特定的set方法或者构造方法。例如,为了能将B注入到A中,类A会被修改成如下形式:

public class A{
private B b;
public void importantMethod() {
b.usefulMethod();
} public void setB(B b) {
this.b = b;
}
}

修改后的类A新增了一个set方法,该方法将会被框架调用,以注入B的一个实例。由于对象依赖由依赖注入,类A的importantMethod()方法不再需要在调用B的usefulMethod()方法前去创建B的一个实例。

当然,也可以采用构造器方式注入,如下所示:

public class A{
private B b; public A(B b) {
this.b = b;
} public void importantMethod() {
b.usefulMethod();
}
}

本例中,Spring会先创建B的实例,再创建A的实例,然后把B注入到实例中。

注:Spring管理的对象称为beans。

通过提供一个Ioc容器(或者说DI容器),Spring为我们提供一种可以“聪明”的管理Java对象依赖关系的方法。其优雅之处在于,程序员无需了解Spring框架的存在,更不需要引入任何Spring类型。

5、ApplicationContext接口

使用Spring,程序几乎将所有重要对象的创建工作移交给Spring,并配置如何注入依赖。Spring支持XML或注解两种配置方式。此外,还需要创建一个ApplicationContext对象,代表一个Spring IoC容器,org.springframework.context.ApplicationContext接口有很多实现类,包括ClassPathXmlApplicationContext和FileSystemXmlApplicationContext。这两个实现都需要至少一个包含beans信息的XML文件。

  • ClassPathXmlApplicationContext:尝试在类加载路径中加载配置文件;
  • FileSystemXmlApplicationContext:从文件系统中加载配置路径。
/*
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/ package org.springframework.context; import org.springframework.beans.factory.HierarchicalBeanFactory;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.core.env.EnvironmentCapable;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.lang.Nullable; /**
* Central interface to provide configuration for an application.
* This is read-only while the application is running, but may be
* reloaded if the implementation supports this.
*
* <p>An ApplicationContext provides:
* <ul>
* <li>Bean factory methods for accessing application components.
* Inherited from {@link org.springframework.beans.factory.ListableBeanFactory}.
* <li>The ability to load file resources in a generic fashion.
* Inherited from the {@link org.springframework.core.io.ResourceLoader} interface.
* <li>The ability to publish events to registered listeners.
* Inherited from the {@link ApplicationEventPublisher} interface.
* <li>The ability to resolve messages, supporting internationalization.
* Inherited from the {@link MessageSource} interface.
* <li>Inheritance from a parent context. Definitions in a descendant context
* will always take priority. This means, for example, that a single parent
* context can be used by an entire web application, while each servlet has
* its own child context that is independent of that of any other servlet.
* </ul>
*
* <p>In addition to standard {@link org.springframework.beans.factory.BeanFactory}
* lifecycle capabilities, ApplicationContext implementations detect and invoke
* {@link ApplicationContextAware} beans as well as {@link ResourceLoaderAware},
* {@link ApplicationEventPublisherAware} and {@link MessageSourceAware} beans.
*
* @author Rod Johnson
* @author Juergen Hoeller
* @see ConfigurableApplicationContext
* @see org.springframework.beans.factory.BeanFactory
* @see org.springframework.core.io.ResourceLoader
*/
public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
MessageSource, ApplicationEventPublisher, ResourcePatternResolver { /**
* Return the unique id of this application context.
* @return the unique id of the context, or {@code null} if none
*/
@Nullable
String getId(); /**
* Return a name for the deployed application that this context belongs to.
* @return a name for the deployed application, or the empty String by default
*/
String getApplicationName(); /**
* Return a friendly name for this context.
* @return a display name for this context (never {@code null})
*/
String getDisplayName(); /**
* Return the timestamp when this context was first loaded.
* @return the timestamp (ms) when this context was first loaded
*/
long getStartupDate(); /**
* Return the parent context, or {@code null} if there is no parent
* and this is the root of the context hierarchy.
* @return the parent context, or {@code null} if there is no parent
*/
@Nullable
ApplicationContext getParent(); /**
* Expose AutowireCapableBeanFactory functionality for this context.
* <p>This is not typically used by application code, except for the purpose of
* initializing bean instances that live outside of the application context,
* applying the Spring bean lifecycle (fully or partly) to them.
* <p>Alternatively, the internal BeanFactory exposed by the
* {@link ConfigurableApplicationContext} interface offers access to the
* {@link AutowireCapableBeanFactory} interface too. The present method mainly
* serves as a convenient, specific facility on the ApplicationContext interface.
* <p><b>NOTE: As of 4.2, this method will consistently throw IllegalStateException
* after the application context has been closed.</b> In current Spring Framework
* versions, only refreshable application contexts behave that way; as of 4.2,
* all application context implementations will be required to comply.
* @return the AutowireCapableBeanFactory for this context
* @throws IllegalStateException if the context does not support the
* {@link AutowireCapableBeanFactory} interface, or does not hold an
* autowire-capable bean factory yet (e.g. if {@code refresh()} has
* never been called), or if the context has been closed already
* @see ConfigurableApplicationContext#refresh()
* @see ConfigurableApplicationContext#getBeanFactory()
*/
AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException; }

下面是从类加载路径中加载config1.xml和config2.xml的ApplicationContext创建的一个代码示例:

ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"config1.xml","config2.xml"});

可以通过调用ApplicationContext的getBean()方法从IoC容器中获得对象:

Product product = context.getBean("product",Product.class);

genBean()方法会在xml配置文件中查询name(或id)为product且类型为Product的bean对象。

注:理想情况下,我们只需在测试代码中创建一个ApplicationContext,应用程序本身无需处理。对于Spring MVC应用,可以通过一个Spring Servlet来处理ApplicationContext,而无需直接处理。

三 XML配置文件

从1.0版本开始,Spring就支持基于XML的配置;从2.5版本开始,增加了通过注解的配置文件。下面介绍如何配置XML文件,配置文件的根元素通常为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 ">
...
</beans>

如果需要更强的Spring配置能力,可以在schema location属性中添加相应的schema,也可以指定schema版本:http://www.springframework.org/schema/beans/spring-beans-5.1.xsd,不过推荐使用默认的schma,以便升级spring库时无需修改配置文件。

配置文件既可以是一份,也可以分解为多份,以支持模块化配置。ApplicationContext的实现类支持读取多份配置文件。另一种选择是,通过一份主配置文件,将该文件导入到其他配置文件。

下面是导入其他配置文件的一个示例:

<?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 ">
<import resource="config1.xml"/>
<import resource="module2/config2.xml"/>
<import resource="/resources/config3.xml"/>
...
</beans>

bean元素的配置在后面将会详细介绍。

四 Spring控制反转(IoC)容器的使用

本节将介绍Spring如何管理bean。

1、通过无参构造器创建一个bean实例

前面已经介绍,通过调用ApplicationContext的getBean()方法可以获取一个bean的实例。

下面我们将创建一个名为spring-intro的Java Project项目,然后我们需要导入5个Spring Jar包:

  • 从spring-framework-5.1.6.RELEASE\libs下复制

spring-beans-5.1.6.RELEASE.jar

spring-context-5.1.6.RELEASE.jar

spring-core-5.1.6.RELEASE.jar

spring-expression-5.1.6.RELEASE.jar

到当前项目中,右键当前项目JRE System Library——>Build Path——>Configure Build Path——>Add External JARs把这四个包导入;

  • 从spring-framework-3.0.2.RELEASE-dependencies\org.apache.commons\com.springsource.org.apache.commons.logging\1.1.1下复制

com.springsource.org.apache.commons.logging-1.1.1.jar

到当前项目中,右键当前项目JRE System Library——>Build Path——>Configure Build Path——>Add External JARs把这一个包导入;

Spring MVC -- Spring框架入门(IoC和DI)

如果是Dynamic Java Web项目,直接将这5个Jar包导入到WebContent/WEB-INF/lib即可。

下面为代码的编写,我们先创建一个Product类,位于包springintro.bean中:

package springintro.bean;
import java.io.Serializable; public class Product implements Serializable {
private static final long serialVersionUID = 748392348L;
private String name;
private String description;
private float price; public Product() {
} public Product(String name, String description, float price) {
this.name = name;
this.description = description;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
}

下面创建一个名为spring-config.xml的配置文件,其中定义了一个名为product的bean,该配置文件位于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 name="product" class="springintro.bean.Product"/> </beans>

该bean的定义告诉Spring,通过默认无参的构造器来初始化Product类。如果不存在该构造器则会抛出一个异常。此外,该无参数的构造器并不要求是public签名。

注意:应采用id或者name属性标识一个bean。为了让Spring创建一个Product实例,应将bean定义的name值"product"和Product类型作为参数传给ApplicationContext的getBean()方法。

在包springintro下创建Main.java文件:

package springintro;

import java.time.LocalDate;
import java.util.Calendar; import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; import springintro.bean.Employee;
import springintro.bean.Product; public class Main {
public static void main(String[] args) {
//创建IoC容器对象 从类路径下(/src)加载xml配置文件 容器启动时就会创建容器中配置的所有对象
ApplicationContext context =
new ClassPathXmlApplicationContext(new String[] {"spring-config.xml"});
Product product1 = context.getBean("product", Product.class);
product1.setName("Excellent snake oil");
System.out.println("product1: " + product1.getName());
  }
}

输出如下:

product1: Excellent snake oil

2、通过静态工厂方法创建一个bean实例

大部分类可以通过构造器来实例化。然而,Spring还同样支持通过调用一个工厂的静态方法来初始化类。

下面的bean定义展示了通过静态工厂方法来实例化Java.time.LocalData,调用java.time.LocalDate的静态方法now()创建LocalDate 对象:

    <bean id="localDate" class="java.time.LocalDate"
factory-method="now"/>

本例中采用了id属性而非name属性来标识bean,采用了getBean()方法来获取LocalData实例:

        LocalDate localDate = context.getBean("localDate", java.time.LocalDate.class);
System.out.println("today:" + localDate);

输出如下:

today:2019-04-29

3、销毁方法的使用(bean元素的destroy-method属性)

有时,我们希望一些对象在被销毁前能执行一些方法。Spring考虑到这样的需求,可以在bean定义中配置destroy-method属性,来指定在销毁前要执行的方法。

下面的例子中,我们配置Spring通过java.util.concurrent.Exceutors的静态方法newCachedThreadPool()来创建一个java.util.concurrent.ExceutorService实例,并指定了destroy-method属性值为shutdown()方法。这样,Spring会在销毁ExceutorService实例前调用shutdown()方法:

     <bean id="executorService" class="java.util.concurrent.Executors"
factory-method="newCachedThreadPool"
destroy-method="shutdown">
</bean>
        ExecutorService executorService = context.getBean("executorService", ExecutorService.class);
//强制关闭IoC容器,在容器关闭之前会销毁容器中所有对象
((ClassPathXmlApplicationContext)context).close();

在程序中我们强制关闭IoC容器,这样就会销毁ExceutorService实例,从而会触发executorService.shutdown()方法的执行。

4、初始化方法的使用(bean元素的init-method属性)

与销毁方法相对应的还有一个初始化方法,会在对象实例创建之后调用,可以在bean定义中配置init-method属性,来指定初始化要执行的方法:

     <bean id="executorService" class="java.util.concurrent.Executors"
factory-method="newCachedThreadPool"
init-method="shutdown">
</bean>

5、bean元素的scope属性

  • singleton(默认值):单例模式,被标识为单例的对象,在IoC容器中只会存在一个实例;
  • prototype:多例,被标识为多例的对象,每次在获取时才会创建,每次创建都是新的对象,整合struct2时,ActionBean必须配置为多例的;

  • request(了解):web环境下,与request声明周期一致;
  • session(了解):web环境下,与session声明周期一致;

如下案例:

 <bean name="product" class="springintro.bean.Product" scope="singleton"/>

五 Spring依赖注入(DI)方式

本节将详细介绍Spring的依赖注入方式。

1、构造器方式依赖注入

前面已经介绍了使用无参构造函数来初始化类,此外,Spring支持通过带参数的构造器来初始化类。

我们仍然以Product类为例,以下的定义展示了如何通过Product类构造函数的参数名传递参数:

    <bean name="featuredProduct" class="springintro.bean.Product">
<constructor-arg name="name" value="Ultimate Olive Oil"/>
<constructor-arg name="description" value="The purest olive oil on the market"/>
<constructor-arg name="price" value="9.95"/>
</bean>

这样,在IoC容器创建Product实例时,Spring会调用如下构造器:

        Product featuredProduct = context.getBean("featuredProduct", Product.class);
System.out.println(featuredProduct.getName() + ", " + featuredProduct.getDescription()
+ ", " + featuredProduct.getPrice());
    public Product(String name, String description, float price) {
this.name = name;
this.description = description;
this.price = price;
}

输出如下:

Ultimate Olive Oil, The purest olive oil on the market, 9.95

除了通过参数名称传递参数外,Spring还支持通过指数方式来传递参数,具体如下:

    <bean name="featuredProduct2" class="springintro.bean.Product">
<constructor-arg index="0" value="Ultimate Olive Oil"/>
<constructor-arg index="1" value="The purest olive oil on the market"/>
<constructor-arg index="2" value="9.95"/>
</bean>

上面index="0",表示第一个参数传入"Ultimate Olive Oil",同理...

但是如果还存在一个构造函数如下:

    public Product(String name, String description, String price) {
this.name = name;
this.description = description;
this.price = Float.parseFloat(price);
}

我们会发现这个参数名和之前的一样,并且顺序也一样,此时为了区分构造函数,我们还需要指定type参数:

    <bean name="featuredProduct3" class="springintro.bean.Product">
<constructor-arg name="name" value="Ultimate Olive Oil"/>
<constructor-arg name="description" value="The purest olive oil on the market"/>
<constructor-arg name="price" value="9.95" type="java.lang.String" index="2"/>
</bean>

如果构造函数的参数不是指类型,而是引用类型,则需要将value更改为ref。

2、Setter方式依赖注入

下面以Employee类和Address类为例,介绍setter方式依赖注入。

Employee类代码如下:

package springintro.bean;

public class Employee {
private String firstName;
private String lastName;
private Address homeAddress; public Employee() {
} public Employee(String firstName, String lastName, Address homeAddress) {
this.firstName = firstName;
this.lastName = lastName;
this.homeAddress = homeAddress;
} public String getFirstName() {
return firstName;
} public void setFirstName(String firstName) {
this.firstName = firstName;
} public String getLastName() {
return lastName;
} public void setLastName(String lastName) {
this.lastName = lastName;
} public Address getHomeAddress() {
return homeAddress;
} public void setHomeAddress(Address homeAddress) {
this.homeAddress = homeAddress;
} @Override
public String toString() {
return firstName + " " + lastName
+ "\n" + homeAddress;
} }

Address类代码如下:

package springintro.bean;

public class Address {
private String line1;
private String line2;
private String city;
private String state;
private String zipCode;
private String country; public Address(String line1, String line2, String city,
String state, String zipCode, String country) {
this.line1 = line1;
this.line2 = line2;
this.city = city;
this.state = state;
this.zipCode = zipCode;
this.country = country;
} public String getLine1() {
return line1;
} public void setLine1(String line1) {
this.line1 = line1;
} public String getLine2() {
return line2;
} public void setLine2(String line2) {
this.line2 = line2;
} public String getCity() {
return city;
} public void setCity(String city) {
this.city = city;
} public String getState() {
return state;
} public void setState(String state) {
this.state = state;
} public String getZipCode() {
return zipCode;
} public void setZipCode(String zipCode) {
this.zipCode = zipCode;
} public String getCountry() {
return country;
} public void setCountry(String country) {
this.country = country;
} @Override
public String toString() {
return line1 + "\n"
+ line2 + "\n"
+ city + "\n"
+ state + " " + zipCode + "\n"
+ country;
} }

Employee类依赖于Address类,可以通过如下配置来保证每个Employee实例都能包含Address实例:

    <bean name="simpleAddress" class="springintro.bean.Address">
<constructor-arg name="line1" value="151 Corner Street"/>
<constructor-arg name="line2" value=""/>
<constructor-arg name="city" value="Albany"/>
<constructor-arg name="state" value="NY"/>
<constructor-arg name="zipCode" value="99999"/>
<constructor-arg name="country" value="US"/>
</bean>

simpleAddress对象是Address类的一个实例,它通过构造器方式实例化。

    <bean name="employee1" class="springintro.bean.Employee">
<property name="homeAddress" ref="simpleAddress"/>
<property name="firstName" value="Junior"/>
<property name="lastName" value="Moore"/>
</bean>

employee1对象则通过配置property元素来调用setter方法以设置字段值。需要注意的是,homeAddress属性配置的是simpleAddress对象的引用。

被引用对象的配置定义无需早于引用其对象的定义,在本例中,employee1对象可以出现在simpleAddress对象定义之前。

这样,在IoC容器创建employee1实例时,Spring会调用默认构造器,并通过setter方法设置值:

        Employee employee1 = context.getBean("employee1", Employee.class);
System.out.println(employee1.getFirstName() + " " + employee1.getLastName());
System.out.println(employee1.getHomeAddress());

输出如下:

Junior Moore
151 Corner Street Albany
NY 99999
US

我们还可以通过调用有参构造器创建Employee实例,并将Address对象通过构造器注入:

    <bean name="employee2" class="springintro.bean.Employee">
<constructor-arg name="firstName" value="Senior"/>
<constructor-arg name="lastName" value="Moore"/>
<constructor-arg name="homeAddress" ref="simpleAddress"/>
</bean>

这样,在IoC容器创建employee2实例时,Spring会调用有参的构造器,具体是哪个构造器,由设置的constructor-arg确定:

        Employee employee2 = context.getBean("employee2", Employee.class);
System.out.println(employee2.getFirstName() + " " + employee2.getLastName());
System.out.println(employee2.getHomeAddress());

输出如下:

Senior Moore
151 Corner Street Albany
NY 99999
US

3、p名称空间方式依赖注入

4、spel方式依赖注入、

p名称空间方式依赖注入和spel方式依赖注入使用不多,因此不做介绍,有兴趣可以参考其他博客。

5、复杂类型注入

如果类中的字段存在复杂类型,如数组,集合(List,Set,Map),Properties,这时依赖注入的配置文件将会有一些小的变化,具体可以参考博客:Spring依赖注入之数组,集合(List,Set,Map),Properties的注入

注:本文所使用的程序来自控制反转和依赖注入的理解(通俗易懂),代码下载地址:https://github.com/pauldeck/springmvc-2ed

参考文献

[1]Spring框架下载方法

[2]Spring MVC学习指南

[3]控制反转和依赖注入的理解(通俗易懂)

[4]Spring MVC(推荐)

[5]Spring装配Bean---使用xml配置(推荐)

[6]Spring应用上下文中Bean的生命周期