spring的依赖注入用配置web.xml文件吗?

先帮助你理清几个概念：
（1）webxml是J2EE用来描述web工程的描述文件，在里面可配置servelet filter listener 等，应用服务器根据此配置响应用户的请求，spring和它无直接关系；
（2）spring总共包含两个概念：AOP（切面编程）和IOC（控制反转），依赖注入主要指的是IOC，所有的这些功能主要是通过spring自定义的配置文件ApplicationContextxml文件进行描述（也可以使用注解方式），spring通过加载自己的配置文件完成依赖注入。

spring和web的关系：
spring的初始化的方式（加载配置文件）有很多种，为了方便spring在web下的使用，spring专门编写了针对web下的listener或者servlet进行启动，当然你也可以自己写个servelet对他进行初始化。

传统的创建对象的方法是直接通过 new 关键字 ，而 spring 则是通过 IOC 容器来创建对象，也就是说我们将创建对象的控制权交给了 IOC 容器。我们可以用一句话来概括 IOC

Spring 容器创建对象的三种方式

传统的创建对象的方法：new 关键字

这里通过 Spring 容器怎么来创建呢？
第一种方法：利用默认的构造方法

在 src 目录下新建 applicationContextxml 文件，这是 spring 配置文件，添加如下代码：

<xml version="10" encoding="UTF-8">

<beans p=""

xmlns:xsi=">

创建对象的第一种方式：利用无参构造器

id:唯一标识符

class:类的全类名

-->

/

Spring 容器利用构造函数创建对象

/

@Test

public void testCreateObjectByConstrutor(){

//1、启动 spring 容器

ApplicationContext context =

new ClassPathXmlApplicationContext("applicationContextxml");

//2、从 spring 容器中取出数据

HelloIoc IOC = (HelloIoc) contextgetBean("helloIoc");

//3、通过对象调用方法

IOCsayHello();

//利用配置文件 alias 别名属性创建对象

HelloIoc IOC2 = (HelloIoc) contextgetBean("helloIoc2");

IOC2sayHello();

}

HelloIocjava 中手动添加无参的构造方法，然后执行上面的测试代码，会发现构造方法会在 sayHello()方法执行之前调用

<xml version="10" encoding="UTF-8">

<beans p=""

xmlns:xsi=">

创建对象的第二种方式：利用静态工厂方法

factory-method：静态工厂类的获取对象的静态方法

class:静态工厂类的全类名

-->

/

Spring 容器利用静态工厂方法创建对象

/

@Test

public void createObjectStaticFactory(){

ApplicationContext context =

new ClassPathXmlApplicationContext("applicationContextxml");

HelloIoc staticFactory =

(HelloIoc) contextgetBean("helloStaticFactory");

staticFactorysayHello();

}

spring容器只负责调用静态工厂方法，而这个静态工厂方法内部实现由程序员完成

利用实例工厂方法

首先创建实例工厂类 HelloInstanceFactory java

public class HelloInstanceFactory {

public HelloInstanceFactory(){

Systemoutprintln("实例工厂方法构造函数");

}

//利用实例工厂方法创建对象

public HelloIoc getInstance(){

HelloIoc instanceIoc = new HelloIoc();

return instanceIoc;

}

}

接着在 applicationContextxml 中进行如下配置：

<!--

创建对象的第三种方式：利用实例工厂方法

factory-bean:指定当前Spring中包含工厂方法的beanID

factory-method:工厂方法名称

-->

/

Spring 容器利用实例工厂方法创建对象

/

@Test

public void createObjectInstanceFactory(){

ApplicationContext context =

new ClassPathXmlApplicationContext("applicationContextxml");

HelloIoc staticFactory =

(HelloIoc) contextgetBean("instance");

staticFactorysayHello();

}

Spring 容器创建对象的时机

默认情况下，启动 spring 容器便创建对象

在spring的配置文件bean中有一个属性 lazy-init="default/true/false"

①、如果lazy-init为"default/false"在启动spring容器时创建对象（默认情况）

②、如果lazy-init为"true",在contextgetBean时才要创建对象

在第一种情况下可以在启动spring容器的时候，检查spring容器配置文件的正确性，如果再结合tomcat,如果spring容器不能正常启动，整个tomcat就不能正常启动。但是这样的缺点是把一些bean过早的放在了内存中，如果有数据，则对内存来是一个消耗。

反过来，在第二种情况下，可以减少内存的消耗，但是不容易发现错误

spring的bean中的scope："singleton/prototype/request/session/global session"

一、默认scope的值是singleton，即产生的对象是单例的

applicationContextxml 文件中配置：

//spring 容器默认产生对象是单例的 scope="singleton"

@Test

public void test_scope_single_CreateObject(){

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContextxml");

HelloIoc hello1 = (HelloIoc) contextgetBean("helloIoc");

HelloIoc hello2 = (HelloIoc) contextgetBean("helloIoc");

Systemoutprintln(hello1equals(hello2)); //true

}

scope=“prototype”

多例模式，并且spring容器启动的时候并不会创建对象，而是在得到 bean 的时候才会创建对象

applicationContextxml 文件中配置：

总结：在单例模式下，启动 spring 容器，便会创建对象；在多例模式下，启动容器并不会创建对象，获得 bean 的时候才会创建对象

scope=“request” 每次>

控制反转（IOC）旨在提供一种更简单的机制，来设置组件的依赖项，并在整个生命周期管理这些依赖项。通常，控制反转可以分成两种子类型：依赖注入（DI）和依赖查找（DL），这些子类型各自又可以被进一步分解为 IOC 服务的具体实现

依赖拉取（Dependency Pull），即根据需要，从注册表中提取依赖项，以下代码显示了基于 Spring 的依赖拉取

上下文依赖查找（contextualized dependency lookup，CDL），同样属于依赖查找的子类型，和依赖拉取有点类似，但在 CDL 中，查找是针对管理资源的容器执行的，这个容器通常由应用程序服务器或框架（Tomcat、JBoss、Spring）提供，比如以下代码显示了一个提供依赖查找服务的容器接口

组件需要实现该接口，当容器准备好将依赖项传递给组件时，会依次调用每个组件的 performLookup() 方法，然后组件就可以使用 Container 接口查找所需的依赖项

当在组件的构造函数中提供依赖项时，就会发生构造函数依赖注入

Ioc 容器通过 JavaBean 样式的 setter 方法注入组件的依赖项

在 Spring 中，还支持另一种被称为字段注入（field injection）的注入类型，在后面学习使用 @Autowire 注解进行自动装配时将介绍该注入类型

Spring 的依赖注入容器的核心是 BeanFactory，它负责管理组件，包括依赖项以及它们的生命周期。如果我们想获得一个组件（Bean），就必须创建一个实现了 BeanFactory 接口的实例，并对其进行配置

虽然 BeanFactory 可以通过编程方式配置，但更常见的做法是使用某种配置文件在外部对其进行配置。Bean 配置可以由实现 BeanDefinition 接口的类的实例来表示，对于任何实现了 BeanDefinitionReader 接口的 BeanFactory 实现类来说，都可以使用 PropertiesBeanDefinitionReader 或 XmlBeanDefinitionReader 从配置文件读取 BeanDefinition 数据

定义一组接口：

接下来我们来看一看，Spring 的 BeanFactory 如何被初始化并用于获取 Bean 实例

ApplicationContext 接口是 BeanFactory 的一个扩展，除了 DI 服务外，还提供其他如事务和 AOP 等服务。在开发基于 Spring 的应用程序时，建议通过 ApplicationContext 接口与 Spring 交互

标记告诉 Spring 扫描代码，从而找到 @Component 等注解注入的 bean，以及支持在指定包（及其所有子包）下使用 @Autowire 等注解的 bean

配置类使用 @Configuration 注解，并包含用 @Bean 注解的方法，这些方法由 IOC 容器直接调用来实例化 bean，bean 名称与用于创建它的方法的名称相同

如果想从该类中读取配置信息，需要一个不同的 ApplicationContext 实现

使用 XML 配置来配置 setter 注入，需要在 标记下指定 标记，为其注入一个依赖项

如果使用注解，只需要向 setter 方法添加一个 @Autowired 注解

使用 XML 方式注入

什么是IOC（控制反转）

把对象创建和对象之间的调用过程，交给Spring进行管理

使用IOC目的： 为了降低耦合度

IOC底层

Spring提供的IOC容器实现的两种方式（两个接口）

ApplicationContext接口的实现类（具体根据API文档查看 ）

特殊字符处理

创建两个类service和dao类

spring配置

测试

xml注入

Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（ FactoryBean ）

第一步，创建类，让这个类作为工厂 bean，实现接口 FactoryBean 。第二步，实现接口里面的方法，在实现的方法中定义返回的 bean 类型

在 Spring 里面，默认情况下，bean 是单实例对象。在 spring 配置文件 bean 标签里面有属性 scope 用于设置单实例还是多实例

scope 属性值 :

bean 生命周期有七步 ，正常生命周期为五步，而配置后置处理器后为七步
（1）通过构造器创建 bean 实例（无参数构造）
（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
（3）把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization
（4）调用 bean 的初始化的方法（需要进行配置初始化的方法）
（5）把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization
（6）bean 可以使用了（对象获取到了）
（7）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

自动装配分为两种方式：

引入外部依赖，以druid连接池为例

使用注解目的：简化 xml 配置

所需依赖 spring-aop

开启包扫描

自定义包扫描规则

创建配置类，替代 xml 配置文件

测试方法

这个过程会记录下所有的bean定义，这只是定义，还没生成具体的bean。

Map<String, RootBeanDefinition> mergedBeanDefinitions。
为了不至于每次用到配置信息的时候都去解析一遍配置文件，我们需要将解析结果保存起来。而保存解析结果这个过程就是BeanDefinition的注册。

顺着obtainFreshBeanFactory方法，进入到AbstractRefreshableApplicationContext的refreshBeanFactory方法，这个方法的主要功能就是创建默认的IOC容器和Xml配置文件的相关 *** 作。

执行完，bean定义信息就加载完成了，后面就根据这些定义信息生成bean。

容器启动时，先读取配置文件，如果发现配置文件里设置了扫描注解，则扫描注解生成每个bean的BeanDefinition放入BeanDefinition 容器。再继续读取xml,将配置的bean放入到BeanDefinition 容器中，这样bean定义容器就有了所有的BeanDefinition。
下一步就根据这些bean定义生成bean对象，并注入依赖的bean，如果依赖的bean没有，则继续生成，这样递归下去，知道所有的bean都生成结束。

构造一个IOC容器需要如下几个步骤：
第一步：资源的定位。所谓资源就是指Spring里众多的XML配置文件，要获取到配置文件里面的信息，首先是要找到它。
第二步：加载和解析资源文件。XML文件里面定义的一些节点，和Spring里面定义的数据结构不匹配，那么就需要按照Spring的解析规则将XML解析成Spring需要的。
第三步：将解析完的数据结构注册到IOC容器中。Spring中内部的数据结构叫BeanDefinition。
经过以上三个步骤之后，IOC容器已经构造好，但是还是不能被直接使用。BeanDefinition只是配置文件里的配置在IOC中建立的一个映射，对于IOC容器来说最重要的依赖关系都还没有注入呢，相当于光有一个壳，内容还没有填充。
这里又有个Spring中重要的概念，叫做依赖注入。依赖的意思上文中有提到过吧，就是对象的引用关系嘛，注入是个动词，个人理解为设置，那依赖注入的意思不就是设置对象的引用关系了哇。
接下来这个过程是容器的实例化。容器的实例化只有一步，就是依赖注入。
完成IOC容器的构造和实例化之后，完整的IOC就建立好了。主线分析好了，接下来便可以顺藤摸瓜的学习源码了。

依赖注入主要有两个过程，一个是实例化Bean，另一个是将依赖关系注入到Bean中。
依赖注入的入口是我们熟悉的getBean方法。

---