BeanFactory与ApplicationContext

已于 2022-06-09 08:37:49 修改
阅读量671 收藏
点赞数
分类专栏： 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>
归去来兮★
关注
专栏目录
spring 的 BeanFactory 和 ApplicationContext
Java5658的博客
06-14 362
HierarchicalBeanFactory：beanFactory 可以设置 ParentBeanFactory，这个接口的两个方法都是和 ParentBeanFactory 相关的，getParentBeanFactory 方法返回 ParentBeanFactory，containsLocalBean 方法是相对 containsBean 方法而言的，containsBean 方法找不到 bean 的时候会通过 ParentBeanFactory 去找，而 containsLocalBean 只在当
BeanFactory 和ApplicationContext（Bean工厂和应用上下文）
技术成就梦想
01-25 4534
一、BeanFactory 和ApplicationContext Bean 工厂（com.springframework.beans.factory.BeanFactory）是Spring 框架最核心的接口，它提供了高级IoC 的配置机制。 应用上下文（com.springframework.context.ApplicationContext）建立在BeanFactory 基础之上。 几
spring中的BeanFactory与ApplicationContext的作用和区别？
花&败
02-23 1632
1.作用： 1)BeanFactory负责读取bean配置文档，管理bean的加载，实例化，维护bean之间的依赖关系，负责bean的生命周期。 BeanFactory是spring的原始接口，针对原始结构的实现类功能比较单一，BeanFactory接口实现的容器，特点是在每次获取对象时才会创建对象 2)ApplicationContext除了提供上述BeanFactory所能提供的功能之外，还提供了更完整的框架功能： a. 国际化支持 ...
beanfactory和applicationcontext
weixin_42601134的博客
02-14 139
BeanFactory 和 ApplicationContext 是在 Spring 框架中用于管理 Bean 对象的两个重要接口。 BeanFactory 是 Spring 框架中最基本的容器，它主要提供了对 Bean 的实例化、配置和管理的功能。 ApplicationContext 是 BeanFactory 的一个子接口，它在 BeanFactory 的基础上提供了更多高级的特性，如国际化...
2.2 BeanFactory和ApplicationContext
weixin_33701294的博客
02-29 192
1、IoC概述 控制反转（Inverse of IoC）是Spring容器的内核，AOP、声明式事务都基于此。 IOC，即通过容器来控制业务对象间的依赖关系，而非传统的由代码直接操控。此即控制反转的关键所在：控制权由应用代码中转到了外部容器，控制权的转移，就是反转。 控制权转移好处：降低业务对象间的依赖程...
day38 05-Spring的BeanFactory与ApplicationContext区别
04-26
在Spring框架中，BeanFactory和ApplicationContext是两种不同的bean容器，它们各自有其特性和应用场景，理解二者的区别对于深入掌握Spring框架至关重要。 首先，BeanFactory是Spring中最基本的bean容器，它提供了对...
Spring系列之beanFactory与ApplicationContext
m0_73533108的博客
09-08 603
Spring系列之beanFactory与ApplicationContext
深度解析：Spring框架中的BeanFactory与ApplicationContext
"这份PDF资料专注于Java开源框架的面试准备，包括了BeanFactory与ApplicationContext的区别、SpringBean的生命周期以及Spring的IoC实现等核心概念。" 在Java开发中，开源框架是不可或缺的一部分，特别是Spring框架...
Spring框架面试高频问题：BeanFactory与ApplicationContext对比及Bean生命周期详解
**BeanFactory与ApplicationContext的区别**： - **BeanFactory**：它是Spring中最基础的接口，主要提供简单对象的实例化和获取功能，设计上遵循“懒加载”原则，即只有在实际使用时才会创建对象，这有助于减少内存...
Beanfactory与applicationcontext区别
06-01
BeanFactory和ApplicationContext都是Spring框架中的容器，用于管理Bean对象的创建、配置、装配和管理等工作。他们的主要区别如下： 1. BeanFactory是Spring框架中最基础的容器，提供了最基本的IOC（控制反转）和DI...
BeanFactory和ApplicationContext区别及详解
热门推荐
su1177的博客
05-16 1万+
​ Spring 框架带有两个 IOC 容器—— BeanFactory和ApplicationContext。BeanFactory是 IOC 容器的最基本版本，ApplicationContext扩展了BeanFactory的特性。​ Spring容器最基本的接口就是BeanFactory。BeanFactory负责配置、创建、管理Bean，它有一个子接口ApplicationContext，也被称为Spring上下文，容器同时还管理着Bean和Bean之间的依赖关系。​ spring Ioc容器
BeanFactory和ApplicationContext
qq_45748049的博客
04-17 102
ApplicationContext: 单例对象适用 开发中多采用此接口 * 它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。 * * BeanFactory: 多例对象适用 BeanFactory作为底层接口，功能不是很完善。 * 它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式。也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象。
Spring——BeanFactory与ApplicationContext
weixin_45700937的博客
09-09 704
简单的认识 BeanFactory 和 ApplicationContext
ApplicationContext与BeanFactory
weixin_43678301的博客
09-15 1704
ApplicationContext与BeanFactory spring是一个容器框架，把一个类交给spring容器管理，包括了创建对象、保存对象、对象的初始化和销毁。 IOC:Inverse of control - 控制反转；将对象创建的权利和依赖关系的维护【给字段赋值】交给Spring去管理。 简单来说：spring容器就是一个管家，专门管理对象（Spring中管理的对象称之为bean）。我们需要先创建一个”管家对象“，可以是ApplicationContext或者BeanFactory。 Bean
BeanFactory和ApplicationContext的关系
Free雅轩的博客
05-02 331
使用版本为 Spring Framework 5.2.2.RELEASE，来探索BeanFactory和ApplicationContext的关系。 开始 首先创建了Repository类，有两个属性，类型为 BeanFactory 和 ApplicationContext public class Repository { private BeanFactory beanFactory; private ApplicationContext applicationContext;
解析BeanFactory和ApplicationContext
运气不好努力来凑
05-18 274
解析BeanFactory和ApplicationContext
Spring系列 BeanFactory与ApplicationContext（超通俗易懂）
weixin_45663027的博客
09-20 2522
BeanFactory是Spring框架的最底层接口，是Spring框架的基础设施，里面包含了各种对于Bean的定义，读取Bean的配置文档，管理Bean的加载、实例化，控制Bean的生命周期，维护Bean之间的依赖关系。getBean，BeanFactory帮助我们创建对象，我们通过getBean从而去拿到创建完成的对象，而不是自己手动去new。（如下图， 很多getBean方法）
【Spring高手之路】BeanFactory vs ApplicationContext：全面解读二者内在实现机制与应用场景区分，让您的技术视野从此与众不同！
最新发布
weixin_42326548的博客
04-05 1406
在深入探索Spring框架的核心容器——BeanFactory与ApplicationContext的过程中，我们了解到两者均扮演着IoC（控制反转）容器的角色，但各自有着不同的设计目标与适用场景。BeanFactory作为IoC容器的基本接口，专注于Bean的生命周期管理、依赖注入等基础功能，采取懒加载策略，仅在首次请求时实例化Bean。它的简洁设计使其轻量高效，适用于对启动速度和资源消耗敏感的应用场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值