查看原文
其他

Spring系列之beanFactory与ApplicationContext

平凡希 SpringForAll社区 2021-05-26
点击上方☝SpringForAll社区 轻松关注!
及时获取有趣有料的技术文章

本文来源:https://www.cnblogs.com/xiaoxi/p/5846416.html

一、BeanFactory
BeanFactory 是 Spring 的“心脏”。它就是 Spring IoC 容器的真面目。Spring 使用 BeanFactory 来实例化、配置和管理 Bean。

BeanFactory:是IOC容器的核心接口, 它定义了IOC的基本功能,我们看到它主要定义了getBean方法。getBean方法是IOC容器获取bean对象和引发依赖注入的起点。方法的功能是返回特定的名称的Bean。

BeanFactory 是初始化 Bean 和调用它们生命周期方法的“吃苦耐劳者”。注意,BeanFactory 只能管理单例(Singleton)Bean 的生命周期。它不能管理原型(prototype,非单例)Bean 的生命周期。这是因为原型 Bean 实例被创建之后便被传给了客户端,容器失去了对它们的引用。

BeanFactory有着庞大的继承、实现体系,有众多的子接口、实现类。来看一下BeanFactory的基本类体系结构(接口为主):

img

这是我画的BeanFactory基本的类体系结构,这里没有包括强大的ApplicationContext体系。
具体:
  1、BeanFactory作为一个主接口不继承任何接口,暂且称为一级接口
  2、有3个子接口继承了它,进行功能上的增强。这3个子接口称为二级接口
  3、ConfigurableBeanFactory可以被称为三级接口,对二级接口HierarchicalBeanFactory进行了再次增强,它还继承了另一个外来的接口SingletonBeanRegistry
  4、ConfigurableListableBeanFactory是一个更强大的接口,继承了上述的所有接口,无所不包,称为四级接口
  (这4级接口是BeanFactory的基本接口体系。继续,下面是继承关系的2个抽象类和2个实现类:)
  5、AbstractBeanFactory作为一个抽象类,实现了三级接口ConfigurableBeanFactory大部分功能。
  6、AbstractAutowireCapableBeanFactory同样是抽象类,继承自AbstractBeanFactory,并额外实现了二级接口AutowireCapableBeanFactory
  7、DefaultListableBeanFactory继承自AbstractAutowireCapableBeanFactory,实现了最强大的四级接口ConfigurableListableBeanFactory,并实现了一个外来接口BeanDefinitionRegistry,它并非抽象类。
  8、最后是最强大的XmlBeanFactory,继承自DefaultListableBeanFactory,重写了一些功能,使自己更强大。

总结:
  BeanFactory的类体系结构看似繁杂混乱,实际上由上而下井井有条,非常容易理解。

再来看一下BeanFactory的源码:

1package org.springframework.beans.factory;
2
3public interface BeanFactory {
4
5    /**
6     * 用来引用一个实例,或把它和工厂产生的Bean区分开,就是说,如果一个FactoryBean的名字为a,那么,&a会得到那个Factory
7     */

8    String FACTORY_BEAN_PREFIX = "&";
9
10    /*
11     * 四个不同形式的getBean方法,获取实例
12     */

13    Object getBean(String name) throws BeansException;
14
15    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
16
17    <T> T getBean(Class<T> requiredType) throws BeansException;
18
19    Object getBean(String name, Object... args) throws BeansException;
20
21    boolean containsBean(String name)// 是否存在
22
23    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;// 是否为单实例
24
25    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;// 是否为原型(多实例)
26
27    boolean isTypeMatch(String name, Class<?> targetType)
28            throws NoSuchBeanDefinitionException
;// 名称、类型是否匹配
29
30    Class<?> getType(String name) throws NoSuchBeanDefinitionException; // 获取类型
31
32    String[] getAliases(String name);// 根据实例的名字获取实例的别名
33
34}

具体:
  1、4个获取实例的方法。getBean的重载方法。
  2、4个判断的方法。判断是否存在,是否为单例、原型,名称类型是否匹配。
  3、1个获取类型的方法、一个获取别名的方法。根据名称获取类型、根据名称获取别名。一目了然!
总结:
  这10个方法,很明显,这是一个典型的工厂模式的工厂接口。

BeanFactory最常见的实现类为XmlBeanFactory,可以从classpath或文件系统等获取资源。

11)File file = new File("fileSystemConfig.xml");
2Resource resource = new FileSystemResource(file);
3BeanFactory beanFactory = new XmlBeanFactory(resource);
42
5Resource resource = new ClassPathResource("classpath.xml"); 
6BeanFactory beanFactory = new XmlBeanFactory(resource);

XmlBeanFactory可以加载xml的配置文件。假设我们有一个Car类:

1package spring.ioc.demo1;
2
3public class Car {
4
5    private String brand;
6
7    private String color;
8
9    private int maxSpeed;
10
11    public String getBrand() {
12        return brand;
13    }
14
15    public void setBrand(String brand) {
16        this.brand = brand;
17    }
18
19    public String getColor() {
20        return color;
21    }
22
23    public void setColor(String color) {
24        this.color = color;
25    }
26
27    public int getMaxSpeed() {
28        return maxSpeed;
29    }
30
31    public void setMaxSpeed(int maxSpeed) {
32        this.maxSpeed = maxSpeed;
33    }
34
35    public String toString(){
36        return "the car is:"+ getBrand() + ", color is:" +getColor() +", maxspeed is:"+getMaxSpeed();
37    }
38
39    public Car() {
40
41    }
42
43    public Car(String brand, String color, int maxSpeed) {
44        this.brand = brand;
45        this.color = color;
46        this.maxSpeed = maxSpeed;
47    }
48
49    public void introduce() {
50        System.out.println("brand:" + brand + ";color:" + color + ";maxSpeed:"
51                + maxSpeed);
52    }
53
54}

我们通过在applicationContext.xml中配置:

1<bean id="car1" class="spring.ioc.demo1.Car"
2        p:brand="spring注入-红旗001" 
3        p:color="spring注入-紫色" 
4        p:maxSpeed="520" />

通过XmlBeanFactory实现启动Spring IoC容器:

1public static void main(String[] args) {
2
3     ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
4      Resource res = resolver.getResource("classpath:applicationContext.xml");
5      BeanFactory factory = new XmlBeanFactory(res);     
6    //ApplicationContext factory=new ClassPathXmlApplicationContext("applicationContext.xml"); 
7
8       Car car = factory.getBean("car1",Car.class);
9       System.out.println("car对象已经初始化完成");
10       System.out.println(car.getMaxSpeed());
11}

1. XmlBeanFactory通过Resource装载Spring配置信息冰启动IoC容器,然后就可以通过factory.getBean从IoC容器中获取Bean了。
2. 通过BeanFactory启动IoC容器时,并不会初始化配置文件中定义的Bean,初始化动作发生在第一个调用时。
3. 对于单实例(singleton)的Bean来说,BeanFactory会缓存Bean实例,所以第二次使用getBean时直接从IoC容器缓存中获取Bean。

二、ApplicationContext

如果说BeanFactory是Spring的心脏,那么ApplicationContext就是完整的躯体了,ApplicationContext由BeanFactory派生而来,提供了更多面向实际应用的功能。在BeanFactory中,很多功能需要以编程的方式实现,而在ApplicationContext中则可以通过配置实现。

BeanFactorty接口提供了配置框架及基本功能,但是无法支持spring的aop功能和web应用。而ApplicationContext接口作为BeanFactory的派生,因而提供BeanFactory所有的功能。而且ApplicationContext还在功能上做了扩展,相较于BeanFactorty,ApplicationContext还提供了以下的功能:

(1)MessageSource, 提供国际化的消息访问
(2)资源访问,如URL和文件
(3)事件传播特性,即支持aop特性
(4)载入多个(有继承关系)上下文 ,使得每一个上下文都专注于一个特定的层次,比如应用的web层

ApplicationContext:是IOC容器另一个重要接口, 它继承了BeanFactory的基本功能, 同时也继承了容器的高级功能,如:MessageSource(国际化资源接口)、ResourceLoader(资源加载接口)、ApplicationEventPublisher(应用事件发布接口)等。

三、二者区别

1.BeanFactroy采用的是延迟加载形式来注入Bean的,即只有在使用到某个Bean时(调用getBean()),才对该Bean进行加载实例化,这样,我们就不能发现一些存在的Spring的配置问题。而ApplicationContext则相反,它是在容器启动时,一次性创建了所有的Bean。这样,在容器启动时,我们就可以发现Spring中存在的配置错误。相对于基本的BeanFactory,ApplicationContext 唯一的不足是占用内存空间。当应用程序配置Bean较多时,程序启动较慢。

BeanFacotry延迟加载,如果Bean的某一个属性没有注入,BeanFacotry加载后,直至第一次使用调用getBean方法才会抛出异常;而ApplicationContext则在初始化自身是检验,这样有利于检查所依赖属性是否注入;所以通常情况下我们选择使用 ApplicationContext。
应用上下文则会在上下文启动后预载入所有的单实例Bean。通过预载入单实例bean ,确保当你需要的时候,你就不用等待,因为它们已经创建好了。

2.BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用,但两者之间的区别是:BeanFactory需要手动注册,而ApplicationContext则是自动注册。(Applicationcontext比 beanFactory 加入了一些更好使用的功能。而且 beanFactory 的许多功能需要通过编程实现而 Applicationcontext 可以通过配置实现。比如后处理 bean , Applicationcontext 直接配置在配置文件即可而 beanFactory 这要在代码中显示的写出来才可以被容器识别。)

3.beanFactory主要是面对与 spring 框架的基础设施,面对 spring 自己。而 Applicationcontex 主要面对与 spring 使用的开发者。基本都会使用 Applicationcontex 并非 beanFactory 。

四、总结

作用:
1. BeanFactory负责读取bean配置文档,管理bean的加载,实例化,维护bean之间的依赖关系,负责bean的声明周期。

2. ApplicationContext除了提供上述BeanFactory所能提供的功能之外,还提供了更完整的框架功能:
a. 国际化支持
b. 资源访问:Resource rs = ctx. getResource(“classpath:config.properties”), “file:c:/config.properties”
c. 事件传递:通过实现ApplicationContextAware接口

3. 常用的获取ApplicationContext

FileSystemXmlApplicationContext:从文件系统或者url指定的xml配置文件创建,参数为配置文件名或文件名数组,有相对路径与绝对路径。

1ApplicationContext factory=new FileSystemXmlApplicationContext("src/applicationContext.xml");
2ApplicationContext factory=new FileSystemXmlApplicationContext("E:/Workspaces/MyEclipse 8.5/Hello/src/applicationContext.xml");

ClassPathXmlApplicationContext:从classpath的xml配置文件创建,可以从jar包中读取配置文件。ClassPathXmlApplicationContext 编译路径总有三种方式:

1ApplicationContext factory = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
2ApplicationContext factory = new ClassPathXmlApplicationContext("applicationContext.xml"); 
3ApplicationContext factory = new ClassPathXmlApplicationContext("file:E:/Workspaces/MyEclipse 8.5/Hello/src/applicationContext.xml");

XmlWebApplicationContext:从web应用的根目录读取配置文件,需要先在web.xml中配置,可以配置监听器或者servlet来实现

1<listener>
2<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
3</listener>

1<servlet>
2<servlet-name>context</servlet-name>
3<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
4<load-on-startup>1</load-on-startup>
5</servlet>

这两种方式都默认配置文件为web-inf/applicationContext.xml,也可使用context-param指定配置文件

1<context-param>
2<param-name>contextConfigLocation</param-name>
3<param-value>/WEB-INF/myApplicationContext.xml</param-value>
4</context-param>






● 多线程同步的五种方法

● redis应用场景

● 手把手带你剖析 Springboot 启动原理!

● Java多线程:synchronized关键字和Lock

● Java多线程:多线程基础知识

● Kafka基本架构及原理

● JVM:基础

● 数据仓库:Mysql大量数据快速导出

● 深入理解Java:注解

● 深入理解Java:类加载机制及反射

● Java 如何设计 API 接口,实现统一格式返回?

● 图文:你女朋友也能看懂的 Kubernetes !

● 打开黑盒:从 MySQL 架构设计出发,看它是如何执行一条 SQL 语句的?


    您可能也对以下帖子感兴趣

    文章有问题?点此查看未经处理的缓存