【第二讲 】容器实现

已于 2022-08-20 16:58:30 修改
阅读量188 收藏
点赞数 1
分类专栏： 黑马spring高级49讲 文章标签： spring java 后端
于 2022-08-07 23:14:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25614773/article/details/126219096
版权

第二讲 容器实现

  1. BeanFactory实现的特点
  2. ApplicationContext 的常见实现和用法
  3. 内嵌容器、注册DispatcherServlet

文章目录

[007]-BeanFactory实现

在002中ConfigurableApplicationContext 类内部组合的BeanFactory实际类型为DefaultListableBeanFactory，使用这个类，模拟spring 使用DefaultListableBeanFactory 类创建其他实体类对象的过程

ConfigurableApplicationContext context = SpringApplication.run(Spring01Application.class, args);
// ----class org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext
System.out.println("----"+context.getClass());

// class org.springframework.beans.factory.support.DefaultListableBeanFactory
System.out.println(context.getBeanFactory().getClass());

public class TestBeaFactory {
    public static void main(String[] args) {
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        // bean 的定义（即bean的一些描述信息，包含class：bean是哪个类，scope：单例还是多例，初始化、销毁方法等）
        AbstractBeanDefinition beanDefinition =
            BeanDefinitionBuilder.genericBeanDefinition(Config.class).setScope("singleton").getBeanDefinition();
        beanFactory.registerBeanDefinition("config", beanDefinition);

        // 打印BeanFactory中Bean
        for (String name : beanFactory.getBeanDefinitionNames()) {
            System.out.println(name);
        }
    }

    @Configuration
    static class Config {
        @Bean
        public Bean1 bean1() {
            return new Bean1();
        }

        @Bean
        public Bean2 bean2() {
            return new Bean2();
        }
    }

    @Slf4j
    static class Bean1 {

        public Bean1() {
            log.info("构造 Bean1()");
        }
        @Autowired
        private Bean2 bean2;

        public Bean2 getBean2() {
            return bean2;
        }
    }

    @Slf4j
    static class Bean2 {
        public Bean2() {
            log.info("构造 Bean2()");
        }
    }

}

将 config 注册进入了 beanDefinition 容器，但是bean1，和 bean2 没有注册到容器中

在这里插入图片描述

给BeanFactory 添加一些常用的后处理器

public static void main(String[] args) {
    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
    // bean 的定义（即bean的一些描述信息，包含class：bean是哪个类，scope：单例还是多例，初始化、销毁方法等）
    AbstractBeanDefinition beanDefinition =
   BeanDefinitionBuilder.genericBeanDefinition(Config.class).setScope("singleton").getBeanDefinition();
    beanFactory.registerBeanDefinition("config", beanDefinition);

       // 给 BeanFactory 添加一些常用的后处理器
        AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);

        // 给 BeanFactory添加一些常用的后处理器，让它具备解析@Configuration、@Bean等注解的能力
        beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values().forEach(beanFactoryPostProcessor -> {
            System.out.println("--------"+ beanFactoryPostProcessor);
            beanFactoryPostProcessor.postProcessBeanFactory(beanFactory);
        });

    // 打印BeanFactory中Bean
    for (String name : beanFactory.getBeanDefinitionNames()) {
        System.out.println(name);
    }
}

在这里插入图片描述

此时打印 bean2 是为空的，因为 @Autowired 没有起作用

// 从BeanFactory中取出Bean1，然后再从Bean1中取出它依赖的Bean2
//  可以看到结果为null，所以@Autowired注解并没有被解析
Bean1 bean1 = beanFactory.getBean(Bean1.class);
System.out.println(bean1.getBean2());

-------
 null

添加

 // 要想@Autowired、@Resource等注解被解析，还要添加Bean的后处理器，可以针对Bean的生命周期的各个阶段提供扩展
        // 从bean工厂中取出Bean的后处理器，并且执行这些后处理器
        // BeanFactory 后处理器主要功能，补充了一些 bean 的定义
         beanFactory.getBeansOfType(BeanPostProcessor.class).values().forEach(beanFactory::addBeanPostProcessor);

此时是 调用了 getBean 才创建对象

System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>");
Bean1 bean1 = beanFactory.getBean(Bean1.class);
System.out.println("bean2--" + bean1.getBean2());

在这里插入图片描述

使用 beanFactory.preInstantiateSingletons()后

// 准备好所有单例，get()前就把对象初始化好
beanFactory.preInstantiateSingletons();
// 从BeanFactory中取出Bean1，然后再从Bean1中取出它依赖的Bean2
//  可以看到结果为null，所以@Autowired注解并没有被解析
System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>");
Bean1 bean1 = beanFactory.getBean(Bean1.class);
System.out.println("bean2--" + bean1.getBean2());

在这里插入图片描述

学到了什么

A. beanFactory 不会做的事

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

B. Bean 后处理器会有排序的逻辑

整理代码

public class TestBeaFactory {
    public static void main(String[] args) {
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        // bean 的定义（即bean的一些描述信息，包含class：bean是哪个类，scope：单例还是多例，初始化、销毁方法等）
        AbstractBeanDefinition beanDefinition =
            BeanDefinitionBuilder.genericBeanDefinition(Config.class).setScope("singleton").getBeanDefinition();
        beanFactory.registerBeanDefinition("config", beanDefinition);

        // 给 BeanFactory 添加一些常用的后处理器
        AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);

        // 给 BeanFactory添加一些常用的后处理器，让它具备解析@Configuration、@Bean等注解的能力
        beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values().forEach(beanFactoryPostProcessor -> {
            System.out.println("--------"+ beanFactoryPostProcessor);
            beanFactoryPostProcessor.postProcessBeanFactory(beanFactory);
        });

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


        // 打印BeanFactory中Bean
        for (String name : beanFactory.getBeanDefinitionNames()) {
            System.out.println(name);
        }

        // 准备好所有单例，get()前就把对象初始化好
        beanFactory.preInstantiateSingletons();
        // 从BeanFactory中取出Bean1，然后再从Bean1中取出它依赖的Bean2
        //  可以看到结果为null，所以@Autowired注解并没有被解析
        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>");
        Bean1 bean1 = beanFactory.getBean(Bean1.class);
        System.out.println("bean2--" + bean1.getBean2());

    }



    @Configuration
    static class Config {
        @Bean
        public Bean1 bean1() {
            return new Bean1();
        }

        @Bean
        public Bean2 bean2() {
            return new Bean2();
        }
    }

    @Slf4j
    static class Bean1 {
        @Autowired
        private Bean2 bean2;
        public Bean1() {
            log.info("构造 Bean1()");
        }
        public Bean2 getBean2() {
            return bean2;
        }
    }

    @Slf4j
    static class Bean2 {
        public Bean2() {
            log.info("构造 Bean2()");
        }
    }

}

bean 后处理器排序逻辑

问题：同时加@Autowired 和 @ Resource 那一段会生效

先加载的 AutowiredAnnotationBeanPostProcessor 后加载 CommonAnnotationBeanPostProcessor，所以 @Autowired 生效

@Autowired
@Resource(name = "bean4")
private Inter bean3;

// Bean 后处理器，针对 bean 的生命周期的各个阶段提供扩展，例如 @Autowired @Resource
         beanFactory.getBeansOfType(BeanPostProcessor.class).values().forEach(beanPostProcessor ->  {
                 System.out.println("----beanFactory----"+ beanPostProcessor);
                 beanFactory.addBeanPostProcessor(beanPostProcessor);
         });

在这里插入图片描述

我们可以通过代码控制 生效的顺序

// Bean 后处理器，针对 bean 的生命周期的各个阶段提供扩展，例如 @Autowired @Resource
beanFactory.getBeansOfType(BeanPostProcessor.class).values().stream().sorted(beanFactory.getDependencyComparator())
.forEach(beanPostProcessor ->  {
System.out.println("----beanFactory----"+ beanPostProcessor);
beanFactory.addBeanPostProcessor(beanPostProcessor);
});

增加比较器后，顺序发生了变化

在这里插入图片描述

通过AnnotationConfigUtils给beanFactory添加一些后处理的时候会默认设置比较器，可以对BeanPostProcessor进行排序，排序的依据是BeanPostProcessor内部的order属性，其中internalAutowiredAnnotationProcessor的order属性的值为Ordered.LOWEST_PRECEDENCE - 2，internalCommonAnnotationProcessor的order属性的值为Ordered.LOWEST_PRECEDENCE - 3。

打印结果

internalAutowiredAnnotationProcessor:2147483645，internalCommonAnnotationProcessor:2147483644，internalCommonAnnotationProcessor的order值更小，所以排序的时候会排在前面

在这里插入图片描述

[010] ApplicationContext 实现

  • 四个重要的ApplicationContext接口的实现类

在这里插入图片描述

  • ClassPathXmlApplicationContext
  • FileSystemXmlApplicationContext
  • AnnnotationConfigApplicationContext
  • AnnotationConfigServletWebServerApplication

ClassPathXmlApplicationContext

public class TestApplication {

    public static void main(String[] args) {
        testClassPathXmlApplicationContext();
    }

    // 较为经典的容器，基于classPath 下 xml 格式的配置文件来创建
    private static void testClassPathXmlApplicationContext(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("Spring_bean.xml");
        for( String name:context.getBeanDefinitionNames()){
            System.out.println("--testClassPathXmlApplicationContext:" + name);
        }

        System.out.println("----bean2:" + context.getBean(Bean2.class).getBean1());

    }

    static class Bean1 {

    }


   static class Bean2 {
        private Bean1 bean1;

        public Bean1 getBean1() {
            return bean1;
        }

        public void setBean1(Bean1 bean1) {
            this.bean1 = bean1;
        }
    }
}
  • spring配置
<?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="bean1" class="com.example.spring01.com.TestApplication.Bean1"/>

    <bean id="bean2" class="com.example.spring01.com.TestApplication.Bean2">
        <property name="bean1" ref="bean1"/>
    </bean>
</beans>
  • 输出

在这里插入图片描述

FileSystemXmlApplicationContext

/ 基于硬盘路径下 xml 格式的配置文件来创建
    private static void testFileSystemXmlApplicationContext(){
        FileSystemXmlApplicationContext context =
                new FileSystemXmlApplicationContext("D:\\2022-04-22-program\\spring_heima\\spring-01\\src\\main\\resources\\Spring_bean.xml");
        for( String name:context.getBeanDefinitionNames()){
            System.out.println("--testFileSystemXmlApplicationContext:" + name);
        }

        System.out.println("----bean2:" + context.getBean(Bean2.class).getBean1());
    }

也可以为相对路径

new FileSystemXmlApplicationContext("src\\main\\resources\\Spring_bean.xml");

在这里插入图片描述

模拟底层原理

public static void testMockClassPathAndFileSystemXmlApplicationContext() {
    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
    System.out.println("读取之前");
    for (String name : beanFactory.getBeanDefinitionNames()) {
        System.out.println(name);
    }
    System.out.println("读取之后");
    XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
    // reader.loadBeanDefinitions("spring_bean.xml");
    // reader.loadBeanDefinitions(new ClassPathResource("spring_bean.xml"));
    reader.loadBeanDefinitions(new FileSystemResource("src\\main\\resources\\spring_bean.xml"));
    for (String name : beanFactory.getBeanDefinitionNames()) {
        System.out.println(name);
    }
}

AnnotationConfigApplicationContext

//较为经典的容器，基于java配置类来创建
    private static void testAnnotationConfigApplicationContext(){
        // 会自动加上5个后处理器
        // org.springframework.context.annotation.internalConfigurationAnnotationProcessor
        // org.springframework.context.annotation.internalAutowiredAnnotationProcessor
        // org.springframework.context.annotation.internalCommonAnnotationProcessor
        // org.springframework.context.event.internalEventListenerProcessor
        // org.springframework.context.event.internalEventListenerFactory
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        for (String name : context.getBeanDefinitionNames()) {
            System.out.println(name);
        }
        System.out.println(context.getBean(Bean2.class).getBean1());

    }

config

 @Configuration
   static class Config {
        @Bean
        public Bean1 bean1() {
            return new Bean1();
        }

        @Bean
        public Bean2 bean2(Bean1 bean1) {
            Bean2 bean2 = new Bean2();
            bean2.setBean1(bean1);
            return bean2;
        }
    }

<!--
        把5个后处理器加进来
            等价于：AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);
    -->
<context:annotation-config />

 // 会自动加上5个后处理器
        // org.springframework.context.annotation.internalConfigurationAnnotationProcessor
        // org.springframework.context.annotation.internalAutowiredAnnotationProcessor
        // org.springframework.context.annotation.internalCommonAnnotationProcessor
        // org.springframework.context.event.internalEventListenerProcessor
        // org.springframework.context.event.internalEventListenerFactory

AnnotationConfigServletWebServerAppliactionContext

 // 较为经典的容器，基于java配置类来创建，并且还可以用于web环境
    // 模拟了 springboot web项目内嵌Tomcat的工作原理
    public static void testAnnotationConfigServletWebServerApplicationContext() throws Exception {
        AnnotationConfigServletWebServerApplicationContext context = new AnnotationConfigServletWebServerApplicationContext(WebConfig.class);
        // 防止程序终止
        System.in.read();
    }

  @Configuration
   static class WebConfig {
        @Bean
        // 1. WebServer工厂
        public ServletWebServerFactory servletWebServerFactory() {
            return new TomcatServletWebServerFactory();
        }

        @Bean
        // 2. web项目必备的DispatcherServlet
        public DispatcherServlet dispatcherServlet() {
            return new DispatcherServlet();
        }

        @Bean
        // 3. 将DispatcherServlet注册到WebServer上
        public DispatcherServletRegistrationBean dispatcherServletRegistrationBean(DispatcherServlet dispatcherServlet) {
            return new DispatcherServletRegistrationBean(dispatcherServlet, "/");
        }

        @Bean("/hello")
        public Controller controller1() {
            return (request, response) -> {
                response.getWriter().println("hello");
                return null;
            };
        }
    }

在这里插入图片描述

DisguiseR6
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Docker_容器与容器云第2版.compressed.pdf
08-22
本书根据Docker 1.10版和Kubernetes 1.2版对第1版进行了全面更新，从实践者的角度出发，以Docker和Kubernetes为重点，沿着“基本用法介绍”到“核心原理解读”到“高级实践技巧”的思路，一本书讲透当前主流的容器和容器云技术，有助于读者在实际场景中利用Docker容器和容器云解决问题并启发新的思考。全书包括两部分，第一部分深入解读Docker容器技术，包括Docker架构与设计、核心源码解读和高级实践技巧；第二部分归纳和比较了三类基于Docker的主流容器云项目，包括专注Docker容器编排与部署的容器云、专注应用支撑的容器云以及一切皆容器的Kubernetes，进而详细解读了Kubernetes核心源码的设计与实现，最后介绍了几种典型场景下的Kubernetes最佳实践。
Docker 容器与容器云（高清扫描版）
01-09
本书根据Docker 1.10版和Kubernetes 1.2版对第1版进行了全面更新，从实践者的角度出发，以Docker和Kubernetes为重点，沿着“基本用法介绍”到“核心原理解读”到“高级实践技巧”的思路，一本书讲透当前主流的容器和容器云技术，有助于读者在实际场景中利用Docker容器和容器云解决问题并启发新的思考。全书包括两部分，第一部分深入解读Docker容器技术，包括Docker架构与设计、核心源码解读和高级实践技巧；第二部分归纳和比较了三类基于Docker的主流容器云项目，包括专注Docker容器编排与部署的容器云、专注应用支撑的容器云以及一切皆容器的Kubernetes，进而详细解读了Kubernetes核心源码的设计与实现，最后介绍了几种典型场景下的Kubernetes最佳实践。
Docker 容器与容器云（第2版）
09-04
本书根据Docker 1.10版和Kubernetes 1.2版对第1版进行了全面更新，从实践者的角度出发，以Docker和Kubernetes为重点，沿着“基本用法介绍”到“核心原理解读”到“高级实践技巧”的思路，一本书讲透当前主流的容器和容器云技术，有助于读者在实际场景中利用Docker容器和容器云解决问题并启发新的思考。全书包括两部分，第一部分深入解读Docker容器技术，包括Docker架构与设计、核心源码解读和高级实践技巧；第二部分归纳和比较了三类基于Docker的主流容器云项目，包括专注Docker容器编排与部署的容器云、专注应用支撑的容器云以及一切皆容器的Kubernetes，进而详细解读了Kubernetes核心源码的设计与实现，最后介绍了几种典型场景下的Kubernetes最佳实践。
Docker容器与容器云（第2版）
05-17
本书根据Docker 1.10版和Kubernetes 1.2版对第1版进行了全面更新，从实践者的角度出发，以Docker和Kubernetes为重点，沿着“基本用法介绍”到“核心原理解读”到“高级实践技巧”的思路，一本书讲透当前主流的容器和容器云技术，有助于读者在实际场景中利用Docker容器和容器云解决问题并启发新的思考。全书包括两部分，首部分深入解读Docker容器技术，包括Docker架构与设计、核心源码解读和高级实践技巧；第二部分归纳和比较了三类基于Docker的主流容器云项目，包括专注Docker容器编排与部署的容器云、专注应用支撑的容器云以及一切皆容器的Kubernetes，进而
Docker:容器与容器云(第2版) pdf
10-08
本书根据Docker 1.10版和Kubernetes 1.2版对第 1版进行了全面更新，从实践者的角度出发，以Docker和Kubernetes为重点，沿着“基本用法介绍”到“核心原理解读”到“高 级实践技巧”的思路，一本书讲透当前主流的容器和容器云技术，有助于读者在实际场景中利用Docker容器和容器云解决问题并启发新的思考。全书包括两部分，首部分深入解读Docker容器技术，包括Docker架构与设计、核心源码解读和高 级实践技巧；第 二部分归纳和比较了三类基于Docker的主流容器云项目，包括专注Docker容器编排与部署的容器云、专注应用支撑的容器云以及一切皆容器的Kubernetes，进而详细解读了Kubernetes核心源码的设计与实现，介绍了几种典型场景下的Kubernetes实践。
01 认识容器：容器的基本操作和实现原理
kaili的博客
09-27 492
作为一名工程师，我猜在过去的几年时间里，你肯定用过或者听人提起过容器（Container）。说实话，容器这东西一点都不复杂，如果你只是想用的话，那跟着Docker 官网的说明，应该十来分钟就能搞定。 简单来说，它就是个小工具，可以把你想跑的程序，库文件啊，配置文件都一起“打包”。然后，我们在任何一个计算机的节点上，都可以使用这个打好的包。有了容器，一个命令就能把你想跑的程序跑起来，做到了一次打包，就可以到处使用。 当然，空讲原理也没什么感觉，所以我还是会先带着你启动一个容器玩玩，然后咱们再一起来探讨容器里面
第二章 容器的基本实现-之容器基本用法
weixin_43846505的博客
06-13 104
第二章 容器的基本实现-之容器基本用法
快速理解容器技术的实现原理
libinfs的博客
02-12 188
本篇文章向您介绍了容器技术的发展脉络与底层原理，通过了解容器技术所依托的 Linux 命令，您将会更加深刻地理解容器技术的实现原理。
容器的基本实现
cleargreen的博客
06-17 318
XmlBeanFactory的解析 BeanFactory bf = new XmlBeanFactory(new ClassPathResource("beanFactoryTest.xml")); 上面代码的执行逻辑，如下： title XmlBeanFactory 初始化时序图 bf(BeanFactoryTest)->+res(ClassPathResource):1. new
[深入剖析Tomcat]一个简单的servlet容器实现
0_o_c
04-02 2015
本文为读《深入剖析Tomcat》第2章做的笔记、写的代码、做的分析。作者是菜鸟，谨慎参考 实现流程图 HttpServer类： public class HttpServer1 { private static String SHUT_DOWN="shutdown"; public static void main(String[] args){ HttpServer
现在最火的容器技术到底是怎么实现的？
javaxuexilu的博客
07-08 975
通俗的来说容器其实是一种沙盒技术。顾名思义，沙盒就是能够像一个集装箱一样，把你的应用“装”起来的技术。这样，应用与应用之间，就因为有了边界而不至于相互干扰；而被装进集装箱...
docker基础学习之四：容器底层实现技术
m0_46121636的博客
04-27 755
一、先了解一下docker的几个基本概念 镜像：可以理解为一个预配置的系统光盘，光盘插入电脑后就可以启动一个操作系统（容器）， 由于是光盘，你是无法修改它或保存数据 容器：同样一个镜像，我们可以同时启动多个，运行期间产生的这个实例就是容器。把容器内的操作和 启动它的镜像进行合并，就可以产生一个新的镜像 镜像仓库：是存放容器镜像的仓库，用户可以进行镜像下载和访问，分为公有镜像仓库和私有镜像仓库 公有...
跟我一起动手实现Tomcat（二）:实现简单的Servlet容器
weixin_34397291的博客
12-31 285
前言 章节循序渐进的讲解了tomcat的原理，在接下来的章节中，tomcat都是基于上一章新增功能并完善，到最后形成一个简易版tomcat的完成品。所以有兴趣的同学请按顺序阅读，本文为记录第二章的知识点以及源码实现（造轮子）。复制代码 内容回顾 跟我一起动手实现Tomcat（一）:实现静态Web服务器上一章我们实现了简单的静态资源web服务器，能够读取到用户自定义的HTML/css/js/图片并显...
容器的实现原理
cbmljs的博客
06-03 861
容器的本质 容器的本质是一个进程。容器技术的核心功能，就是通过约束和修改进程的动态表现，从而为其创造出一个“边界”。 对于docker等大多数linux容器来说，cgroups技术是用来制造约束的主要手段，而namespace技术则是用来修改进程视图的主要方法。 首先创建一个容器试试： docker run -it busybox /bin/sh / # / # ps PID USER TI...
(1)容器的基本实现
sicofield的专栏
02-07 228
定义一个Bean 在xml配置文件之中配置好 使用BeanFactory获取Bean 使用到了XmlBeanFactory，看XmlBeanFactory的类结构图 最上层是3个接口BeanFactory、SingletonBeanRegistry、AliasRegistry AliasRegistry：定义对Alias的简单增删改等操作 xml定义bean的时候...
容器的介绍、实现及使用
学习笔记
10-01 495
泛型: 数组就是一种容器,可以在其中放置对象或基本类型数据. 数组的优势：是一种简单的线性序列,可以快速地访问数组元素,效率高.如果从效率和类型检查的角度讲, 数组是最好的. 数组的劣势：不灵活.容量需要事先定义好,不能随着需求的变化而扩容. 以下是容器的接口层次结构图: ----------------------------------------- Collection Map ^
BeanFactory 与 ApplicationContext 的那些事儿
桃子同学的博客
10-23 327
本篇内容主要讲述BeanFactory与ApplicationContext容器的关系以及各自的功能。
基于java的容器底层原理实现
萌萌的PP博客
11-13 8331
一.java容器的体系大览 1. java为啥子需要容器呢? 通常，程序总是在运行时才能确定要创建的对象，甚至是对象的类型。为了解决这个问题，需要在任意时刻任意位置创建任意数量的对象。大多数语言都提供某种方法来解决这个问题，Java使用容器来解决这个问题。容器也称集合类，基本的类型是List、Set、Queue、Map，但由于Java类库中使用了Collection关键字来代表某一接口，所以一般...
qt ioc容器实现
最新发布
01-02
2. 解析对象：IoC容器可以根据对象之间的依赖关系，自动解析和实例化需要的对象。这样可以有效地降低代码的耦合度，并且减少重复的对象实例化代码。 3. 生命周期管理：IoC容器可以管理对象的生命周期，比如单例模式...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值