Spring IOC容器

by admin on 2019年10月7日

在上篇中,我们提到了两个接口ApplicationContext,BeanFactory。那么我们这章便从这里开始了解这两个接口。

本文章只是粗粗讲解了一下基本流程,并不涉及更深入的内容

ApplicationContext ac=new
ClassPathXmlApplicationContext(“Spring.xml”);
获取Spring配置文件
接口可以实现多继承 ,但类不行

Public interface ApplicationContext extends EnvironmentCapable,
ListableBeanFactory, HierarchicalBeanFactory,MessageSource,
ApplicationEventPublisher, ResourcePatternResolver

向下转型为ClassPathXmlApplicationContext 这么个类

那么这个类又是何方神圣?我画了个结构的粗体,但中间很多借口没有标明,(在回中会具体讲解几个借口)

图片 1

context.png

ResourceLoader:这个接口是定义了了两个方法:
Resource getResource(String location);(Resource
是一个接口,应该是对于inputstream resource 资源的一系列操作接口)
ClassLoader getClassLoader();
Bean定义资源文件定位由ResourceLoader通过统一的Resource接口来完成,Resource接口将各种形式的Bean定义资源文件封装成统一的、IoC容器可进行载入操作的对象。

ResourceUtils 这个类在图中并没有标明,它是Spring一系列资源的URL
的字符定义。(“file:”,zip等)。

DefaultResourceLoader
这个类其实是通过获取ClassLoader以及资源URL进行资源获取,在之前的代码中是用于Spring配置文件的加载。

这段代码初始化的时候,是调用ClassPathXmlApplicationContext
的构造函数,其构造函数跳转并将输入的字符串转化为数组对象,进入第二个构造函数。
第二个构造函数中,

图片 2

Paste_Image.png

Super(parent)的函数是调用其父类的方法,具体是
AbstractApplicationContext类的构造函数,
this()中获取了一个ResourcePatternResolver对象,应该是一个接口,它调用的get方法返回的是实现其接口的一个类:PathMatchingResourcePatternResolver
PathMatchingResourcePatternResolver:这个类实现的是一个资源location
path匹配到一个或者多个匹配资源。

图片 3

Paste_Image.png

这个函数是正在调用的函数,setParent()
Parent 是ApplicationContext
类,这个类在Spring中还是比较重要的。这个类在这章Spring基础流程片就不深加了解。这个类我会放在另一章中详细讲解。

图片 4

Paste_Image.png

这个方法是等到配置文件的信息。
从Assert类中和其在这些代码中出现的频率来说,Spring在各种数据和方法的防范上可以说是非常明显的,逻辑十分清楚。(Assert类是对于各种情况的判断,包括object是否为空等)。
Refresh()方法是启动IOC容器的方法。
其实在IOC容器设计中,比较有名的是ApplicationContext
和BeanFactory这两类。
但预知后事如何,请听下回分解。

1.Spring框架简介

由于Spring是采用依赖注入(DI)的方式来实现IOC,所以本文将IOC和依赖注入(DI)等同看待, 主要讨论依赖注入(DI)

一.Spring的IOC容器概述

Spring的IOC的过程也被称为依赖注入(DI),那么对象可以通过构造函数参数,工厂方法的参数或在工厂方法构造或返回的对象实例上设置的属性来定义它们的依赖关系,然后容器 在创建bean时注入这些依赖关系。Spring实现IOC容器的基础是org.springframework.be和org.springframework.context。  

有关spring常用的设计模式和应用请点击查看
《spring中常用设计模式及应用》
 
核心接口BeanFactory 接口提供了一种能够管理任何类型对象的高级配置机制。
ApplicationContext
是一个子接口BeanFactory。它增加了与Spring的AOP功能更容易的集成;
BeanFactory提供了配置框架和基本功能,并ApplicationContext增加了更多的企业特定功能。
在Spring中,构成应用程序的骨干并由Spring IoC
容器管理的对象称为bean。bean是一个实例化,组装并由Spring
IoC容器管理的对象。
 
Spring如何工作的视图:
图片 5 

图片 6Paste_Image.png

什么是Spring?

此文回答三个问题

二.Spring的IOC的方式

Spring容器xml配置管理
通常是多个bean定义组成。基于XML的配置元数据将这些bean配置为<bean/>顶层元素内的<beans/>元素
如下图提供spring的官方的配置文件模板(素材来源www.spring.io)
 

<?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 id="…" class="…">
        <!– collaborators and configuration for this bean go here –>
    </bean>
 
    <bean id="…" class="…">
        <!– collaborators and configuration for this bean go here –>
    </bean>
 
    <!– more bean definitions go here –>
 
</beans>

 

BeanFactoty
如上述结构图所示,它其实是一个最顶级的接口,它是最基层的接口信息,它提供了最基本的IOC容器使用方法。

Spring是一个开源的轻量级的应用开发框架,其目的是用于简化企业级应用程序开发,减少侵入

1. 什么是依赖注入

1.默认构造器

当你通过构造函数的方法创建一个bean时,所有的普通类都可以被Spring使用和兼容。也就是说,正在开发的类不需要实现任何特定的接口或以特定的方式编码。只需指定bean类就足够了。但是,根据您用于特定bean的IoC类型,需要一个默认(空)构造函数。
 
使用基于XML的配置元数据,您可以指定您的bean类如下:
 

<bean id="exampleBean" class="examples.ExampleBean"/>
 
<bean name="anotherExample" class="examples.ExampleBeanTwo"/>

 
其中 bean 中的class 是我们交于spring初始化的bean的全路径。

The root interface for accessing a Spring bean container.This is the
basic client view of a bean container;

Spring提供的IOC和AOP应用,可以将组件的耦合度降至最低,即解耦,便于系统日后的维护和升级

2. 依赖注入的方式有哪些

2.静态工厂

在定义使用静态工厂方法创建的bean时,可以使用该class
属性来指定包含static工厂方法的类和factory-method指定工厂方法本身的名称的属性。你应该可以调用这个方法(使用后面描述的可选参数)并返回一个实例化对象,这个实例化对象随后被视为是通过构造函数创建的。用于这种bean定义的就是被称为静态工厂方式创建。
静态工厂的定义

public class ClientService {
 
private static ClientService clientService = new ClientService();
 
    private ClientService() {}
 
    public static ClientService createInstance() {
        return clientService;
    }
}

 
配置xml

<bean id="clientService"
    class="examples.ClientService"
    factory-method="createInstance"/>

这样的spring框架在调用IOC实例化的使用是通过反射创建
调用静态工厂的中的static方法去创建对象。此时在创建的对象的是在静态方法手中。

图片 7Paste_Image.png

Spring为系统提供了一个整体的解决方案,开发者可以利用它本身提供的功能外,也可以与第三方框架和技术整合应用,可以自由选择采用哪种技术进行开发

3. 依赖注入的职责

3.实例化工厂

实例化工厂的方式相同于静态工厂方法,只是在一个实例工厂中反射一个存在对象的非静态方法,从而去spring容器去创建实例化的bean。
创建实例化工厂

public class DefaultServiceLocator {
 
    private static ClientService clientService = new ClientServiceImpl();
 
    private static AccountService accountService = new AccountServiceImpl();
 
    public ClientService createClientServiceInstance() {
        return clientService;
    }
 
    public AccountService createAccountServiceInstance() {
        return accountService;
    }
}

 
配置xml:

<bean id="serviceLocator" class="examples.DefaultServiceLocator">
</bean>
 
<bean id="clientService"
    factory-bean="serviceLocator"
    factory-method="createClientServiceInstance"/>
 
<bean id="accountService"
    factory-bean="serviceLocator"
    factory-method="createAccountServiceInstance"/>
 

 

这是Beanfactory所提供的所有接口,其功能依赖的注入功能其实都是依靠这个接口。它是可以将bean的信息保存起来。它定义了一个字符串,“&”,用户在使用&bean可以得到FactoryBean其本身,而不是获取它产生的对象。获取bean对象时,只需要调用getBean方法,这个方法可以通过名称来获取也可以增加其他参数。isPrototype
以及issingleton这些方法,来获取这个bean的信息,并且这些信息都可以用用户自己去控制。HierarchicalBeanFactory这个接口中有一个方法:

2.容器和Bean管理

关于为什么要使用依赖注入以及使用依赖注入的好处就不说了,
很多书已经介绍了, 而且不用比用麻烦.

三.结束

上述的三种的方式就是我们的spring的提供的三种初始化bean的方式。学会了吗?
下次我们来一起学习DI的四种方式

图片 8Paste_Image.png

Spring容器简介

1.  什么是依赖注入

我们可以根据这个方法去获取一个root
,BeanFactory.通过该方法Spring实现了可以控制双亲IOC容器的能力。以前的BeanFactory
的调用时用XmlBeanFactory来实现的。之后的Spring使用ClassPathXmlApplicationContext这个类来实现的。这个过程我在上篇中讲过,有兴趣的可以去看看。这个类是实现ConfigurableApplicationContext接口的一个类,可以说这个类是继承自ApplicationContext。这整个IOC容器其实就是在这样的接口框架下实现的。从一方面来说,ApplicationContext其实是在BeanFactory这个最基层的容器上进行加工实现更加复杂的功能。

在Spring中,任何java类和javaBean都被当成Bean处理,这些Bean通过容器管理和应用

用一张图来可能更好说明, 见图2-1

javawork ja=ac.getBean(“javawork”);

Spring容器实现了IOC和AOP机制,这些机制可以简化Bean对象创建和Bean对象之间的解耦

图片 9

这个方法获取bean正在调用的getbean其实是BeanFactory的方法。整个IOC就是先初始化,ClassPathXmlApplicationContext这个类初始化会传入配置文件的地址,Resource是封装了Spring对于inputStream的操作。2.开始初始化factory:ConfigurableListableBeanFactory这个factory。

Spring容器有BeanFactory和ApplicationContext两种类型

在被注入对象中, 不直接创建被依赖对象,
而是交给一个中间角色来帮助它创建被依赖对象. 这个中间角色成为IOC Service
Provider,也就是Spring IOC容器. 举个简单的例子类A依赖类B,
不要在A中直接new B(), 而是交给Spring IOC容器去帮你new.

图片 10Paste_Image.png

(什么是javaBean:一种简单规范的java对象;何时使用Spring:当需要管理javaBean对象时候就可以使用,Spring是最简洁的对象管理方案之一)

2. 依赖注入的方式有哪些

我们可以看到这个接口继承于其他的三个,都是来源于BeanFactory。refresh()中还初始化了一个XmlBeanDefinitionReader用来读取xml配置文件。先从refresh()代码中看,ConfigurableListableBeanFactory
beanFactory =
obtainFreshBeanFactory();这段代码是初始化ConfigurableListableBeanFactory,进入obtainFreshBeanFactory()函数,

Spring容器的实例化

    1) 构造方法注入

图片 11Paste_Image.png

ApplicationContext继承自BeanFactory接口,拥有更多的企业级方法,推荐使用该类型,实例化方法如下:

    2) setter方法注入

这段代码返回的就是一个BeanFactory,那么一个问题资源配置在哪里读?我们接着向下看:refreshBeanFactory();在其类中是这样的:

//加载文件系统中的配置文件实例化

    3) 接口注入(很麻烦, 不怎么用了, 也就不介绍了)

图片 12Paste_Image.png

String conf = “C:\applicationContext.xml”;

    每种方式有什么好处和缺点呢

是一个抽象方法,需要在其子类中实现。之前我发过的一张结构图,中间就是这类:AbstractRefeshableApplicationContext,其实我个人认为这个名字就是告诉我们可以refresh.

ApplicationContext ac = new FileSystemXmlApplicationContext(conf);

    构造方法注入

图片 13Paste_Image.png

//加载工程classpath下的配置文件实例化

        好处就是对象创建后不用再额外的做什么,  所有的依赖都ok了,
直接就可以使用.

如果有factory存在先销毁在建立,它生成了一个DefaultListableBeanFactory
类。而加载配置xml
是通过loadBeanDefinitions()这个方法。这个方法应是在XmlWebApplicationContext.class这个类中

String conf = “applicationContext.xml”;

        不好的地方就是, 当依赖对象很多的时候,
构造方法的参数列表会比较长, 而且在java中, 构造方法无法被继承,
无法设置默认值. 对于非必须的依赖处理, 可能需要引入多个构造方法,
维护不方便. 

图片 14Paste_Image.png

ApplicationContext ac = new ClassPathXmlApplicationContext(conf);

        特点是因为一个对象的构造函数不会被调用两次,
所以被注入的对象的构造乃至整个生命周期应该是由IOC容器来管理.

从中我们看到了loadBeanDefinitions(beanDefinitionReader);这段代码,看名字应该是引导配置文件的代码。

Spring容器的使用

    setter方法注入

图片 15Paste_Image.png

从本质上讲,BeanFactory和ApplicationContext仅仅只是一个维护Bean定义以及相互依赖关系的高级工厂接口。通过BeanFactory和ApplicationContext我们可以访问bean定义

        好处就是随时可以注入, 也可以更改, 可以被集成, 允许社会默认值

这个函数有个getConfigLocations(),这个函数在本身的类中是没有实现的,它实际是用了AbstractRefreshableConfigApplicationContext这个类的getConfigLocations()方法。现在我们就应该可以看到为什么

首先在容器配置文件applicationContext.xml中添加Bean定义

        坏处就是不能构建完后不能立马使用, 需要先setter一下.

图片 16Paste_Image.png

<bean id = “标识符” class = “Bean类型”/>

所以, 构造方法注入和setter方法结合使用.

中有setConfigLocations这个方法,调用的是同一个对象。这就是为什么可以理解这个资源对象的地址来历。然后调用reader.loadBeanDefinitions(configLocation);进入到AbstractBeanDefinitionReader类中对应的方法中。中间进行不断的判断,在跳转到其子类XmlBeanDefinitionReader中调用loadBeanDefinitions(EncodedResource
encodedResource)获取inputstream,再进入protected int
doLoadBeanDefinitions(InputSource inputSource, Resource
resource)函数中便开始不断地解析xml。这个调用饶了很多的弯,画了张图:

然后在创建BeanFactory和ApplicationContext容器对象后,调用getBean()方法获取Bean的实例即可[getBean(“标识符”)]

3. 依赖注入的职责

图片 17Paste_Image.png

Bean的实例化

    或者说是依赖注入主要是干的事情是什么? 两件事:
业务对象的构建管理和业务对象间的依赖绑定.

Spring将三个模块分开,这使用户如果去定制自己的Spring的话更加方便。这个解析过程完善了上一篇的不足。但这一篇还有applicationContext类。它的结构是

Spring容器创建Bean对象的方法有以下三种:

    业务对象的构建管理: 用类A依赖类B的例子, B总是要被构建的,
A不构建B, 那就IOC容器来构建B.

图片 18Paste_Image.png

-用构造器来实例化

    业务对象间的依赖绑定: 这个职责最艰巨也最重要.
IOC容器通过结合之前构建和管理的所有业务对象,
以及各个业务对象间可以识别的依赖关系, 将这些对象所依赖的对象注入绑定,
从而保证每个业务对象在使用的时候, 可以处于就绪状态.

可以从中看出来,其实该接口还实现了EnvironmentCapable
,ApplicationEventPublisher 以及MessageSource
(除了BeanFactory的接口外)。MessageSource是实现资源国家化的接口。ApplicationEventPublisher是事件处理,这些其实是更好的管理Bean。这篇就先到这里了。若有问题请私信。

<bean id = “calendarObj1”  class = “java.util.GregorianCalendar”/>

<bean id = “calendarObj2”  class = “java.util.GregorianCalendar”/>

(id或name属性用于指定Bean名称,用于从Spring中查找这个Bean对象;class用于指定Bean类型,会自动调用无参数构造器创建对象)

-使用静态工厂方法实例化

<bean id = “calendarObj2”  class = “java.util.Calendar” 
factory-method = “getInstance”/>

(id属性用于指定Bean名称,class属性用于指定工厂类型,factory-method属性用于指定工厂中创建Bean对象的方法,必须用static修饰的方法)

-使用实例工厂方法实例化

<bean id = “calendarObj3”  class = “java.util.GregorianCalendar”/>

<bean id = “dateObj”  factory-bean = “calendarObj3”  factory-method =
“getTime”/>

 (id用于指定Bean名称,factory-bean属性用于指定工厂Bean对象,factory-method属性用于指定工厂中创建Bean对象的方法)

(将对象创建规则告诉Spring,Spring会帮你去创建对象;基于配置和默认规则,减少了代码的书写)

 Bean的命名

Bean的名称:

在Spring容器中,每个Bean都需要有名字(即标识符),该名字可以用<bean>元素的id或name属性指定;id属性比name严格,要求具有唯一性,不允许用”/”等特殊字符

Bean的别名

为已定义好的Bean,再增加另外一个名字引用,可以使用<alias>指定

<alias  name = “fromName”  alias = “toName”/>

Bean的作用域:

Spring容器在实例化Bean时,可以创建以下作用域的Bean对象

1、singleton作用域

在每个Spring IOC容器中一个bean定义对应一个对象实例,默认项
配置实例:
<bean id=”role” class=”spring.chapter2.maryGame.Role”
scope=”singleton”/>
或者
<bean id=”role” class=”spring.chapter2.maryGame.Role”
singleton=”true”/>

2、prototype

一个bean定义对应多个对象实例
配置实例:
<bean id=”role” class=”spring.chapter2.maryGame.Role”
scope=”prototype”/>
或者
<beanid=”role” class=”spring.chapter2.maryGame.Role”
singleton=”false”/>

3、request

request表示该针对每一次HTTP请求都会产生一个新的bean,同时该bean仅在当前HTTP
request内有效
request、session、global
session使用的时候,首先要在初始化web的web.xml中做如下配置:

如果你使用的是Servlet
2.4及以上的web容器,那么你仅需要在web应用的XML声明文件web.xml中增加下述ContextListener即可:
<web-app>…<listener><listener-class>org.springframework.web.context.request.RequestContextListener</listener-class></listener>…</web-app>

如果是Servlet2.4以前的web容器,那么你要使用一个javax.servlet.Filter的实现:
<web-app>..<filter>
<filter-name>requestContextFilter</filter-name>
<filter-class>org.springframework.web.filter.RequestContextFilter</filter-class></filter>
<filter-mapping>
<filter-name>requestContextFilter</filter-name>
<url-pattern>/*</url-pattern></filter-mapping>…</web-app>
接着既可以配置bean的作用域了:
<bean id=”role” class=”spring.chapter2.maryGame.Role”
scope=”request”/>

4、session

session作用域表示该针对每一次HTTP请求都会产生一个新的bean,同时该bean仅在当前HTTP
session内有效(在一个HTTPSession中,一个bean定义对应一个实例,仅限于Web环境)
配置实例:
和request配置实例的前提一样,配置好web启动文件就可以如下配置:
<bean id=”role” class=”spring.chapter2.maryGame.Role”
scope=”session”/>

5、global
session

在一个全局的HTTPSession中,一个bean定义对应一个实例,仅在基于portlet的Web应用中才有意义,Portlet规范定义了全局Session的概念
配置实例:
和request配置实例的前提一样,配置好web启动文件就可以如下配置:
<bean id=”role” class=”spring.chapter2.maryGame.Role” scope=”global
session”/>

(上面的Bean作用域,可以通过<bean>定义的scope属性指定)

Bean的生命周期回调

指定初始化回调方法:

<bean  id = “exampleBean”  class = “com.foo.ExampleBean”  init-method
= “init”>

</bean>

指定销毁回调方法,仅适用于singleton模式的bean:

<bean  id = “exampleBean”  class = “com.foo.ExampleBean” 
destroy-method = “destroy”>

</bean>

在顶级的<beans/>元素中的default-init-method属性,可以为容器所有<bean>指定初始化回调方法

<beans  default-init-method = “init”>

  <bean id = “exampleBean”  class = “com.foo.ExampleBean”/>

</beans>

在顶级的<beans/>元素中的default-destroy-method属性,可以为容器所有<bean>指定销毁回调方法

<beans  default-destroy-method = “destroy”>

  <bean id = “exampleBean”  class = “com.foo.ExampleBean”/>

</beans>

Bean延迟实例化

在ApplicationContext实现的默认行为就是在启动时将所有singleton
bean提前进行实例化

如果不想让一个singleton
bean在ApplicationContext初始化时被提前实例化,可以使用<bean>元素的lazy-init
= “true” 属性改变

一个延迟初始化bean将在第一次被用到时实例化

<bean id = “exampleBean”  lazy-init = “true”  class =
“com.foo.ExampleBean”/>

在顶级的<beans/>元素中的default-lazy-init属性,可以为容器所有<bean>指定延迟实例化特性

指定bean依赖关系

当一个bean对另一个bean存在依赖关系时,可以利用<bean>元素的depends-on属性指定

<bean id = “beanOne”  class = “ExampleBean”  depends-on =
“manager”/>

<bean id = “manager”  class = “ManagerBean”/>

当一个bean对多个bean存在依赖关系时,depends-on属性可以指定多个bean名,用逗号隔开

<bean id = “beanOne”  class = “ExampleBean”  depends-on =
“manager1,manager2″/>

3.容器的IOC应用

IOC概念

IOC全称是Inversion of  Control,被译为控制反转;

IOC是指程序中对象的获取方式发生反转,由最初的new方式创建,转变为由第三方框架创建,注入。第三方框架一般是通过配置方式指定注入哪一个具体实现,从而降低了对象之间的耦合度

IOC按实现方法不同,可以分为依赖注入DI和依赖查找两种

Spring容器是采用DI方式实现了IOC控制,IOC是Spring容器的基础和核心

DI概念

DI全称是Dependency  Injection,被译为依赖注入

DI的基本原理就是将一起工作具有关系的对象,通过构造方法参数或方法参数传入建立联系,因此容器的工作就是创建bean时注入那些依赖关系

IOC是一种思想,而DI是实现IOC的主要技术途径

DI主要有两种注入方式,即Setter注入和构造器注入

Setterr注入

通过调用无参构造器或无参static工厂方法实例化bean之后,调用该bean的setter方法,即可实现setter方式的注入

public class JDBCDataSource{

  private String driver;

  public void setDriver(String driver){

    try{

      Class.forName(driver);

      this.driver = driver;

      }catch(Exception e){

        throw new RuntimeException(e);

      }

     }

    //其他代码….

  }

在容器xml配置中,配置注入参数

<bean id = “dataSource”  class = “org.dao.JDBCDataSource”>

  <property name = “driver”  value =
“oracle.jdbc.OracleDriver”/>

  <property name = “url”  value =
“jdbc.oracle:thin:@localhost:1521:XE”/>

  <property name = “user”  value = “openlab”/>

  <property name = “pwd”  value = “open123″/>

</bean>

构造器注入

基于构造器的注入是通过调用带参数的构造器来实现的,容器在bean被实例化的时候,根据参数类型执行相应的构造器

public class OracleUserDAO implements UserDAO{

  private JDBCDataSource dataSource;

  public OracleUserDAO(JDBCDataSource dataSource){

    this.dataSource = dataSource;

  }

  //其他代码…..

}

按构造器参数索引指定注入

<bean id = “dataSource”  class = “org.dao.JDBCDataSource”>

  <property name = “driver”  value =
“oracle.jdbc.OracleDriver”/>

  <property name = “url”  value =
“jdbc:oracle:thin:@localhost:1521:XE”/>

  <peoperty name = “user”  value = “openlab”/>

  <peoperty name = “pwd”  value = “open123″/>

</bean>

<bean id = “userDAO”  class = “org.dao.OracleUserDAO”>

  <constructor-arg index = “0”  ref = “dataSource”/>

</bean>

自动装配

Spring 
IOC容器可以自动装配(autowire)相互协作bean之间的关联关系,autowire可以针对单个bean进行设置,autowire的方便之处在于减少xml的注入配置

在xml配置文件中,可以在<bean/>元素中使用autowire属性指定自动装配规则,一共有五种类型值

属性值为no:禁止自动装配,默认值;

属性值为byName:根据属性名自动装配,此选项将检查容器并根据名字查找与属性完全一致的bean,并将其与属性自动装配;

属性值为byType:如果容器中存在一个与指定属性类型相同的bean,那么将与该属性自动装配;

属性值为constructor:与byType的方式类似,不同之处在于它应用于构造器参数;

属性值为autodetect:通过bean类来决定是使用constructor还是byType方式进行自动装配,如果发现默认的构造器,那么将使用byType方式

配置示例:

<bean id = “userDAO”  class = “org.dao.OracleUserDAO”>

  <constructor-arg index = “0”  ref = “dataSource”/>

</bean>

<bean id = “userService”  class = “org.service.UserService”  autowire
= “byType”/>

上述配置,在UserService中如果存在接收UserDao类型的方法Setter方法,Spring就可以自动将userDAO对象注入进去

(自己总结,仅供参考。)

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图