BeanFactory与ApplicationContext

已于 2022-06-09 08:37:49 修改
阅读量509 收藏
点赞数
分类专栏： spring 文章标签： java spring 开发语言
于 2022-06-09 01:19:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouhe_/article/details/125177032
版权

这里写目录标题

BeanFactory与ApplicationContext

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) throws   Exception {
        ConfigurableApplicationContext context = SpringApplication.run(DemoApplication.class, args);
        /**
         * 1 . 到底什么是BeanFactory
         *  - 它是ApplicationContext的父接口
         *  - 它才是Spring的核心容器，主要的ApplicationContext都组合了它的功能
         */
        System.out.println(context);

        /**
         * 2. BeanFactory 能干什么
         *  - 表面上只有 getBean
         *  - 实际上控制反转、基本的依赖注入，直至Bean的生命周期的各种功能，都是由它的实现类提供
         */

        Field singletonFactories = DefaultSingletonBeanRegistry.class.getDeclaredField("singletonObjects");
        singletonFactories.setAccessible(true);
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        Map<String,Object> map = (Map<String, Object>) singletonFactories.get(beanFactory);
        System.out.println(map);


        /**
         * 3 . ApplicationContext 比 BeanFactory 多点啥
         *
         */
        // - MessageSource 国际化，通过浏览器请求头带过来（getMessage）
        // - ResourcePatternResolver 获取资源（file，获取磁盘下的资源，classpath，获取类路径下的资源，classpath*，获取类路径和jar包中的资源）
        Resource[] resources = context.getResources("classpath*:META-INF/spring.factories");
        for (Resource resource : resources) {
            System.out.println(resource);
        }
        // - PropertyResolver 获取环境变量
        System.out.println(context.getEnvironment().getProperty("java_home"));
        System.out.println(context.getEnvironment().getProperty("server.port"));
        // - ApplicationEventPublisher 发布事件，实现组件之间的解耦
        PublishEvent bean = context.getBean(PublishEvent.class);
        bean.register();

    }
}

发布事件
事件发布

public class UserRegisterEvent extends ApplicationEvent {
    public UserRegisterEvent(Object source) {
        super(source);
    }
}

@Component
public class PublishEvent {
    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;

    public void register(){
        System.err.println("用户注册");
        applicationEventPublisher.publishEvent(new UserRegisterEvent("用户注册事件"));

    }
}

事件监听

@Component
public class ListenerEvent  {

    @EventListener
    public void listener(UserRegisterEvent userRegisterEvent){
        System.err.println("listener "+userRegisterEvent.getSource()+ "   发短信");
    }
}

BeanFactory 的实现DefaultListableBeanFactory

BeanFactory 处理器

public class DefaultListBeanFactoryDemo {
    public static void main(String[] args) {

        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        // 定义 bean 并注册到 beanFactory
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(BeanConfig.class).setScope("singleton").getBeanDefinition();
        beanFactory.registerBeanDefinition("beanConfig",beanDefinition);
        // 可以发现 @Configuration @Bean 注解并没有识别
        // 给beanFactory添加 bean工厂后处理器，并执行后处理器
        AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);
        beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values().stream().
                forEach(beanFactoryPostProcessor ->beanFactoryPostProcessor.postProcessBeanFactory(beanFactory));

        for (String beanDefinitionName : beanFactory.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }

    }

    @Configuration
    static class BeanConfig{
        @Bean
        public Bean1 bean1(){
            return new Bean1();
        }
        @Bean
        public Bean2 bean2(){
            return new Bean2();
        }
    }

    static class Bean1{
        public Bean1(){
            System.out.println("Bean11111");
        }
    }
    static class Bean2{
        public Bean2(){
            System.out.println("Bean11111");
        }
    }


}

Bean 处理器

public class DefaultListBeanFactoryDemo {
    public static void main(String[] args) {

        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        // 定义 bean 并注册到 beanFactory
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(BeanConfig.class).setScope("singleton").getBeanDefinition();
        beanFactory.registerBeanDefinition("beanConfig",beanDefinition);
        // 可以发现 @Configuration @Bean 注解并没有识别
        // 给beanFactory添加后处理器，并执行后处理器
        AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);
        beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values().stream().
                forEach(beanFactoryPostProcessor ->beanFactoryPostProcessor.postProcessBeanFactory(beanFactory));

//        Bean1 bean = beanFactory.getBean(Bean1.class);
//        System.out.println(bean.bean2());
        // 并未识别到 @Autowire 注解 ？

        // Bean 后处理器，针对bean的生命周期的各个阶段提供扩展，例如 @Autowire @Resoure ...
        beanFactory.getBeansOfType(BeanPostProcessor.class).values().forEach(beanFactory::addBeanPostProcessor);

        // 预先把所有的单例对象 加载后好 而不是用到在加载
        beanFactory.preInstantiateSingletons();
        System.out.println(">>>>>>>>>>>>>>>>>");
        Bean1 bean = beanFactory.getBean(Bean1.class);
        bean.bean2();






    }

    @Configuration
    static class BeanConfig{
        @Bean
        public Bean1 bean1(){
            return new Bean1();
        }
        @Bean
        public Bean2 bean2(){
            return new Bean2();
        }
    }

    static class Bean1{
        public Bean1(){
            System.out.println("Bean11111");
        }
        @Autowired
        private Bean2 bean2;

        public Bean2 bean2(){
            return bean2;
        }

    }
    static class Bean2{
        public Bean2(){
            System.out.println("Bean2222");
        }
    }


}

拓展：

当一个接口有多个实现类，把接口注入时，既使用@Autowire 也使用 @Resource 是优先使用谁注入？
这个与 Bean 处理器 被运行的先后顺序有关 ，可以控制

get：

a. beanFactory不会做的事

  1. 不会主动调用 BeanFactory  后处理器
  2. 不会主动添加 Bean 后处理器
  3. 不会主动初始化单例
  4. 不会解析 beanFactory 还不会解析 ${} 与 #{}

b. bean 后处理器会有排序的逻辑

ApplicationContext 实现

package com.zhj;

import com.zhj.demo.DefaultListBeanFactoryDemo;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.boot.autoconfigure.web.servlet.DispatcherServletRegistrationBean;
import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext;
import org.springframework.boot.web.servlet.server.ServletWebServerFactory;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.FileSystemResource;
import org.springframework.web.servlet.DispatcherServlet;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.sql.rowset.spi.XmlReader;
import java.lang.annotation.Annotation;

public class TestBeanFactory {

    public static void main(String[] args) {
//        testClassPathXmlApplicationContext();
//        testFileSystemXmlApplicationContext();
        /**
         * 上面两个方法的原理
         */
        /**
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

        System.out.println("读取之前");
        for (String beanDefinitionName : beanFactory.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
//        reader.loadBeanDefinitions(new ClassPathResource("b01.xml"));
        reader.loadBeanDefinitions(new FileSystemResource("src/main/resources/b01.xml"));
        System.out.println("读取之后");
        for (String beanDefinitionName : beanFactory.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
         */
//        testAnnotationConfigApplicationContext(); // 自动配置了后处理器
        testAnnotationConfigServletApplicationContext(); // 运行访问 http://localhost:8080/hello

    }

    static void testClassPathXmlApplicationContext() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("b01.xml");
        String[] beanDefinitionNames = context.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }

    }

    ;

    static void testFileSystemXmlApplicationContext() {
        FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext("src/main/resources/b01.xml");
        String[] beanDefinitionNames = context.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
    }

    ;

    static void testAnnotationConfigApplicationContext() {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        for (String beanDefinitionName : context.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
    }

    ;

    static void testAnnotationConfigServletApplicationContext() {
        AnnotationConfigServletWebServerApplicationContext context = new AnnotationConfigServletWebServerApplicationContext(WebConfig.class);
    }

    @Configuration
    static class WebConfig{
        @Bean
        public ServletWebServerFactory servletWebServerFactory(){
            return new TomcatServletWebServerFactory();
        }
        @Bean
        public DispatcherServlet dispatcherServlet(){
            return new DispatcherServlet();
        }
        @Bean
        public DispatcherServletRegistrationBean dispatcherServletRegistrationBean(DispatcherServlet dispatcherServlet){
            return new DispatcherServletRegistrationBean(dispatcherServlet, "/");
        }

        @Bean("/hello") // Controller 是spring提供的一个接口
        public Controller controller(){
            return (httpServletRequest, httpServletResponse) -> {
                httpServletResponse.getWriter().write("hello");
                return null;
            };
        }
    }


    @Configuration
    static class Config{

        @Bean
        public Bean1 bean1(){
            Bean1 bean1 = new Bean1();
            return bean1;
        }
        @Bean
        public Bean2 bean2(Bean1 bean1){
            Bean2 bean2 = new Bean2();
            bean2.setBean1(bean1);
            return bean2;
        }
    }
    static class Bean1{
        public Bean1(){
            System.out.println("111");
        }
    }
    static class Bean2{
        public Bean2(){
            System.out.println("222");
        }
        private Bean1 bean1;

        public void setBean1(Bean1 bean1) {
            this.bean1 = bean1;
        }
    }
}


<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <bean id="bean2" class="com.zhj.demo.DefaultListBeanFactoryDemo.Bean2"></bean>
    <bean id="bean1" class="com.zhj.demo.DefaultListBeanFactoryDemo.Bean1">
        <property name="bean2" ref="bean2"></property>
    </bean>
    <!--  添加后处理器  -->
    <context:annotation-config/>
</beans>
归去来兮★
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ApplicationContext系列三加载BeanFactory
勇心在馨
10-26 280
ApplicationContext是对BeanFactory的功能扩展，不但包含了BeanFactory的全部功能，还添加了其他扩展能力。obtainFreshBeanFactory方法是实现BeanFactory的地方，经过这个函数后，ApplicationContext就有了BeanFactory的全部功能。 protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { //初始化beanFactory，读取xm.
Spring源码系列之——BeanFactory和ApplicationContext
weixin_43398098的博客
07-27 868
Hello~大家好，只做技术交流分享~若大佬路过，请多指教~。该文章为spring源码系列文章，讲解的是beanFactory和ApplicationContext的区别，以及它们分别做了什么，娓娓道来~
@PostConstruct 注解标记的类中，由于ApplicationContext还未加载，导致空指针
m0_73311735的博客
11-05 1598
今天Code Review的时候 看到其他项目 static 方法需要使用 bean的实体方法，是从网上copy的 大概是虽然现在 代码运行没有毛病，但是 我们有公共类SpringUtils 实现了相同功能，其实不应该 重复在业务系统自己写。但是这个时候 人家可能会问 我这么写和 用公共类 的效果不是一样么？都一样。
【Spring高手之路】BeanFactory vs ApplicationContext：全面解读二者内在实现机制与应用场景区分，让您的技术视野从此与众不同！
最新发布
weixin_42326548的博客
04-05 863
在深入探索Spring框架的核心容器——BeanFactory与ApplicationContext的过程中，我们了解到两者均扮演着IoC（控制反转）容器的角色，但各自有着不同的设计目标与适用场景。BeanFactory作为IoC容器的基本接口，专注于Bean的生命周期管理、依赖注入等基础功能，采取懒加载策略，仅在首次请求时实例化Bean。它的简洁设计使其轻量高效，适用于对启动速度和资源消耗敏感的应用场景。
Spring的BeanFactory和ApplicationContext
Ralap的博客
02-24 461
BeanFactory和ApplicationContextBeanFactory第一梯队第二梯队ListableBeanFactoryHierarchicalBeanFactory第三梯队ConfigurableBeanFactory第四梯队AutowireCapableBeanFactoryAbstractBeanFactory第五梯队ConfigurableListableBeanFactoryAbstractAutowireCapableBeanFactory第六梯队DefaultListableB
Spring源码学习--ConfigurableListableBeanFactory接口
DemoTransfer
06-26 1万+
文章引用: https://www.cnblogs.com/leftthen/p/5261837.html ConfigurableListableBeanFactory 提供bean definition的解析,注册功能,再对单例来个预加载(解决循环依赖问题). 貌似我们一般开发就会直接定义这么个接口了事.而不是像Spring这样先根据使用情况细分那么多,到这边再合并 Co...
day38 05-Spring的BeanFactory与ApplicationContext区别
04-26
NULL 博文链接：https://364232252.iteye.com/blog/2369489
Spring中ApplicationContext和beanfactory区别.rar
09-16
Spring中ApplicationContext和beanfactory区别.rar
简单了解Spring中BeanFactory与FactoryBean的区别
08-25
简单了解Spring中BeanFactory与FactoryBean的区别 Spring框架中有两个非常关键的接口：BeanFactory和FactoryBean。虽然它们的名字相似，但它们的作用和实现机制却有很大的不同。 BeanFactory是Spring IoC容器的...
BeanFactory&&ApplicationContext;
12-25
这份代码主要适用于我写的一篇博客的资源，主要是想通过简短的代码来帮助我们更清晰的理解IoC实现思路，代码一式两份，分别是纯代码和注解方式。
spring中的BeanFactory与FactoryBean的讲解
08-26
Spring中的BeanFactory与FactoryBean的讲解 在Spring框架中，BeanFactory和FactoryBean都是非常重要的概念，它们都是Spring IoC容器的组成部分。今天，我们将深入探讨这两个概念的讲解。 一、BeanFactory ...
BeanFactory和ApplicationContext的基本认识
rrrrrrrrrfh的博客
12-16 267
图文结合详细讲解BeanFactory和Application之间的关系和区别，已经他们各自的具体功能
Spring源码：IOC容器BeanFactory和ApplicationContext体系结构
薄观约取，厚积薄发
12-03 262
BeanFactory 顶层接口，主要提供getBean方法，从BeanFactory获取给定beanName以及对应的bean对象实例ListableBeanFactory 主要提供根据给定条件，如type，Annotation，获取对应的所有beans列表的接口HierarchicalBeanFactory 提供getParentBeanFactory方法，使beanFactory具备层次化ConfigurableBeanFactory 继承HierarchicalBeanFactory, Single
BeanFactory与ApplicationContext的区别
weixin_45606872的博客
06-08 1万+
BeanFactory和ApplicationContext是Spring的两大核心接口，都可以当做Spring的容器。其中ApplicationContext是BeanFactory的子接口。BeanFactory:ApplicationContext1.BeanFactroy采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化，这样，我们就不能发现一些存在的Spring的配置问题。而ApplicationContext则相反，它是在容
SpringContextHolder使用报错：applicaitonContext属性未注入, 请在applicationContext.xml中定义SpringContextHolder...
热门推荐
zuixiaoyao_001的博客
05-13 1万+
SpringContextHolder代码如下：没有问题 ** * 以静态变量保存Spring ApplicationContext, 可在任何代码任何地方任何时候取出ApplicaitonContext. */ @Service @Lazy(false) public class SpringContextHolder implements ApplicationConte...
Spring系列之beanFactory与ApplicationContext
qq_14825051的博客
09-08 250
文章目录**一、BeanFactory****二、ApplicationContext****三、二者区别****四、总结****五、Spring的bean在什么时候实例化?** 一、BeanFactory BeanFactory 是 Spring 的“心脏”。它就是 Spring IoC 容器的真面目。Spring 使用 BeanFactory 来实例化、配置和管理 Bean。 BeanFactory：是IOC容器的核心接口， 它定义了IOC的基本功能，我们看到它主要定义了getBean方法。getBea
[读书笔记]Spring中BeanFactory和ApplicationContext的联系和区别
小小默：进无止境
02-16 4363
# 【1】BeanFactory BeanFactory 是 Spring 的“心脏”。它就是 Spring IoC 容器的真面目。Spring 使用 BeanFactory 来实例化、配置和管理 Bean。 BeanFactory：是IOC容器的核心接口， 它定义了IOC的基本功能，我们看到它主要定义了getBean方法。getBean方法是IOC容器获取bean对象和引发依赖注入的起点。方法的功能是返回特定的名称的Bean。 BeanFactory 是初始化 Bean 和调用它们生命周期方法的“吃苦
ApplicationContext.getBean源码解析
小英雄
07-04 1329
spring中有两种类型的Bean：一种是普通的JavaBean；另一种就是工厂Bean（FactoryBean），这两种Bean都受Spring的IoC容器管理，但它们之间却有一些区别。 普通的JavaBean不再多说，我们将其定义好，然后在配置文件中定义并配置其依赖关系，就可以通过IoC容器的getBean获取到。 那么FactoryBean呢？ FactoryBean跟普通Bean不同，它是实现了FactoryBean<T>接口的Bean， 1.通过BeanFactory类的.
3.2-1、Spring源码学习：ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
༺ bestcxx的专栏 ༻
09-01 703
文章目录前言AbstractApplicationContext.obtainFreshBeanFactory(AbstractRefreshableApplicationContext.refreshBeanFactory(createBeanFactory()loadBeanDefinitions(beanFactory);XmlWebApplicationContext.loadBeanDe...
Beanfactory与applicationcontext区别
06-01
BeanFactory和ApplicationContext都是Spring框架中的容器，用于管理Bean对象的创建、配置、装配和管理等工作。他们的主要区别如下： 1. BeanFactory是Spring框架中最基础的容器，提供了最基本的IOC（控制反转）和DI...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值