第一讲：BeanFactory和ApplicationContext

news2025/4/24 9:19:32

BeanFactory和ApplicationContext

什么是BeanFactory

  • 它是ApplicationContext的父接口
  • 它才是Spring的核心容器，主要的ApplicationContext实现都组合了它的功能

image-20231205165356277

BeanFactory能做什么?

表面上看BeanFactory的主要方法只有getBean()，实际上控制反转、基本的依赖注入、Bean的生命周期的各种功能，都由他的实现类提供

例如：通过反射查看它的成员变量singletonObjects，singletonObjects内部包含了所有单例bean

实现这个例子前，引出一个类DefaultListableBeanFactory，主要功能是作为一个可配置的、可列表化的 Bean 工厂，用于管理和维护应用程序中的 Bean 定义和实例

DefaultListableBeanFactory继承了DefaultSingletonBeanRegistry类，而DefaultSingletonBeanRegistry类就是专门用来管理单例Bean的

image-20231205165954183

DefaultSingletonBeanRegistry其中有个成员变量也就是singletonObjects

image-20231205170156677

这样我们就找到了单例Bean存储的地方，通过反射调用即可

SpringBoot启动会有很多单例Bean注入，map中包含了所有的单例Bean，我自定义了Component1类注入到其中

@SpringBootApplication
public class Application {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        //返回容器对象
        ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);

        //反射获取singletonObjects属性
        Field singletonObjects = DefaultSingletonBeanRegistry.class.getDeclaredField("singletonObjects");
        //开启可操作singletonObjects，否则无法对他进行操作，因为他是private final的
        singletonObjects.setAccessible(true);
        //BeanFactory是ConfigurableListableBeanFactory实现类的成员变量
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        //Field.get(Object obj)：获取指定对象obj上此field表示的字段的值
        Map<String,Object> map = (Map<String, Object>) singletonObjects.get(beanFactory);
        map.entrySet().stream().filter(e -> e.getKey().startsWith("component")).forEach(e -> {
            System.out.println(e.getKey() + "=" + e.getValue());
        });
    }
}

上面代码最难理解的是singletonObjects.get(beanFactory)，刚开始没有理解到反射，重新翻了反射的代码发现他的作用是填充ConfigurableListableBeanFactory中的singletonObjects属性

Java源码中并没有这个属性，反复查找后发现DefaultListableBeanFactory是ConfigurableListableBeanFactory的实现类，而DefaultListableBeanFactory继承了DefaultSingletonBeanRegistry，所以自然有singletonObjects属性

ApplicationContext能做什么

前面提到过，ApplicationContext是在BeanFactory基础上做了扩展

  • MessageSource：拓展国际化功能
  • ApplicationEventPublisher：事件发布与监听，实现组件之间的解耦
  • ResourcePatternResolver：通过通配符方式获取一组Resource资源
  • EnvironmentCapable：整合 Environment 环境（能通过它获取各种来源的配置信息）

image-20231205165356277

国际化

所谓国际化就是可以通过准备好的配置文件，将语言翻译成各种国家的语言

#准备以下2个配置文件
#messages_en.properties  翻译成英文
hi=hello

#messages_zh.properties  翻译成中文  \u4F60\u597D对应着你好
hi=\u4F60\u597D

通过getMessage()转化

@SpringBootApplication
public class Application {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);
        //国际化
        System.out.println(context.getMessage("hi", null, Locale.US)); //hello
        System.out.println(context.getMessage("hi", null, Locale.CHINA)); //你好
    }
}

获取Resource资源

@SpringBootApplication
public class Application {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);
        //通配符方式获取一组 Resource 资源
        Resource[] resources = context.getResources("classpath:application.properties");
        for (Resource resource : resources) {
            System.out.println(resource); //class path resource [application.properties]
        }
    }
}

整合 Environment 环境

可以读取系统环境变量，也可以读取SpringBoot配置文件

@SpringBootApplication
public class Application {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);
        //整合 Environment 环境
        System.out.println(context.getEnvironment().getProperty("JAVA_HOME"));
        System.out.println(context.getEnvironment().getProperty("server.port"));
    }
}

事件发布与监听

事件发布与监听指的是，一条线程发布特定事件，监听该事件的方法收到消息后，处理该方法，这也是异步的一种思想

创建事件

事件需要继承ApplicationEvent

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

监听者

@EventListener 可以在 Spring 应用中监听和响应特定类型的事件。当事件发生时，标记有 @EventListener 注解的方法将被自动调用。

@Component
public class Component1 {
    private static final Logger logger = LoggerFactory.getLogger(Component1.class);

    @EventListener
    public void aaa(UserRegisteredEvent event) {
        logger.info("{}",event);
    }
}

事件发布

@SpringBootApplication
public class Application {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);
        //发布事件
        context.publishEvent(new UserRegisteredEvent(context));
    }
}

BeanFactory实现

代码准备

我们最终想要实现的是，像Spring一样，向自定义的BeanFactory注册Config对象

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

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

static class Bean1{
    private static final Logger logger = LoggerFactory.getLogger(Bean1.class);

    @Autowired
    private Bean2 bean2;

    public Bean1() {
        logger.info("构造 Bean1()");
    }

    public Bean2 getBean2(){
        return bean2;
    }
}

static class Bean2{
    private static final Logger logger = LoggerFactory.getLogger(Bean2.class);

    public Bean2() {
        logger.info("构造 Bean2()");
    }
}

具体实现

BeanFactory可以通过registerBeanDefinition注册一个BeanDefinition 对象

public static void main(String[] args) {
    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
    //定义一个bean (class，scope，初始化，销毁) 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);
    }
}

执行以上代码，控制台输出config，证明Config已经注册到BeanFactory中

但是发现Bean1，Bean2并没有注册进去，因为BeanFactory并不会主动调用BeanFactory的后置处理器

现在我们需要为BeanFactory添加一些常用的后置处理器，注意这里仅仅是添加

AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);

通过观察控制台输出，发现多了一些BeanFactory中多了些Bean

image-20231207113233914

简单介绍一下目前需要了解几个关键的处理器

  • internalConfigurationAnnotationProcessor：用于处理@Configuration注解，它会解析@Configuration注解并处理其中的@Bean注解，将被注解的方法返回的对象注册为Bean。
  • internalAutowiredAnnotationProcessor：用于处理@Autowired注解，它会解析@Autowired注解并自动装配依赖对象。它会在Bean初始化之前进行处理，确保依赖对象正确注入。
  • internalCommonAnnotationProcessor：用于处理通用注解，如@Resource，@PostConstruct，@PreDestroy等。它会在Bean初始化之前进行处理，执行相应的初始化和销毁方法。

接下来需要让BeanFactory处理器生效，其中internalConfigurationAnnotationProcessor属于BeanFactory后置处理器，internalAutowiredAnnotationProcessor，internalCommonAnnotationProcessor属于Bean的后置处理器，生效方式不一样

//BeanFactory后置处理器的主要功能，补充了一些bean的定义
beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values()
    .forEach(beanFactoryPostProcessor -> {
    beanFactoryPostProcessor.postProcessBeanFactory(beanFactory);
});

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

观察控制台，发现Bean1，Bean2也被出册到了BeanFactory中，并且可以实例化

image-20231207115043414

目前到这看似我们的目标已经完成了，实际上会发现Bean的构造方法是在用到的时候调用的，属于懒汉式，对于单例Bean来说，希望他在注册的时候就已经实例化

//在容器初始化完成后，提前实例化所有的单例Bean
beanFactory.preInstantiateSingletons();

观察控制台发现，构造方法在容器初始化的时候就已经执行了

image-20231207132430162

总结

  • BeanFactory不会主动调用BeanFactory后置处理器
  • BeanFactory不会主动调用Bean后置处理器
  • BeanFactory不会主动初始化单例

补充说明

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

举个例子，当一个接口有两个实现类时，这个接口通过依赖注入的形式注入，同时标注了@Autowired以及@Resource，哪个注解会生效，取决于Bean的哪个后置处理器先添加到BeanFactory中

ApplicationContext实现

这里我们主要了解几个常用的ApplicationContext实现

  • ClassPathXmlApplicationContext
  • FileSystemXmlApplicationContext
  • AnnotationConfigApplicationContext
  • AnnotationConfigServletWebServerApplicationContext

基于XML配置文件注册Bean

目前无论是Spring还是SpringBoot都很少用XML的方式，更推荐使用配置类来注册Bean，所以这里了解即可

前置代码

需要注册的Bean

static class Bean1{
}

static class Bean2{
    private Bean1 bean1;

    public Bean1 getBean1() {
        return bean1;
    }

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

读取的XML配置文件

<?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.yellowstar.spring.demo1.TestApplicationContext$Bean1"/>

    <bean id="bean2" class="com.yellowstar.spring.demo1.TestApplicationContext$Bean2">
        <property name="bean1" ref="bean1"/>
    </bean>
</beans>
ClassPathXmlApplicationContext

ClassPathXmlApplicationContext的作用是基于classpath下 xml 格式的配置文件来注册Bean

private static void testClassPathXmlApplicationContext(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("b01.xml");
    for (String name : context.getBeanDefinitionNames()) {
        System.out.println(name);
    }
    System.out.println(context.getBean(Bean2.class).getBean1());
}

image-20231207152154004

FileSystemXmlApplicationContext

FileSystemXmlApplicationContext的作用是基于磁盘路径下 xml 格式的配置文件来创建

    private static void testFileSystemXmlApplicationContext(){
        //可以选择绝对路径，也可以是相对路径
        FileSystemXmlApplicationContext context = 
            new FileSystemXmlApplicationContext("src/main/resources/b01.xml");
    }
实现ClassPathXmlApplicationContext

XmlBeanDefinitionReader用于从XML配置文件中读取和解析Bean的定义信息

   DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
   //设置配置文件读取到beanFactory
   XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
   xmlBeanDefinitionReader.loadBeanDefinitions(new ClassPathResource("b01.xml"));

基于Java配置类注册Bean

AnnotationConfigApplicationContext

AnnotationConfigApplicationContext的作用是基于Java配置类来注册Bean

配置类

@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;
    }
}

实现

private static void testAnnotationConfigApplicationContext(){
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
    for (String name : context.getBeanDefinitionNames()) {
        System.out.println(name);
    }
    System.out.println(">==" + context.getBean(Bean2.class).getBean1());
}

这里可以注意到常用的一些后置处理器是自动帮我们加载到容器中了，而基于XML模式的方式还需要在XML另外定义才行

image-20231207153311158

AnnotationConfigServletWebServerApplicationContext

AnnotationConfigServletWebServerApplicationContext也是是基于Java配置类来注册Bean，区别不同的在于他适用于web环境

这块内容比较复杂，先贴代码在详细解释

    private static void testAnnotationConfigServletWebServerApplicationContext(){
        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 registrationBean(DispatcherServlet dispatcherServlet){
            // "/" 代表匹配所有请求
            return new DispatcherServletRegistrationBean(dispatcherServlet,"/");
        }

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

上述代码的功能就像是启动了Spring服务一样，可以通过访问localhost:8080来进入controller1

image-20231207160024704

其中最重要的是WebConfig必须拥有三大组件

  • ServletWebServer：用于支持 Servlet 容器的接口。它定义了与 Servlet 容器相关的通用操作和属性，允许 Spring 应用程序与不同的 Servlet 容器（如Tomcat、Jetty等）进行交互。
  • DispatcherServlet：用于处理web请求的关键组件之一，所有请求都会经过他
  • DispatcherServletRegistrationBean：用于注册和配置 DispatcherServlet 的 Bean。它允许开发者以编程方式配置 DispatcherServlet 的各种属性，以及将其与特定的 URL 映射关联起来。

Bean的生命周期

通常情况下，Bean的生命周期分为四个阶段

  1. 构造方法阶段：在这个阶段，Spring容器实例化Bean对象，调用其构造方法来创建Bean的实例
  2. 依赖注入阶段：在Bean对象被实例化完成后，Spring容器会对Bean的属性进行依赖注入，将依赖的其他 Bean或值注入到当前 Bean中。
  3. 初始化阶段：在依赖注入完成后，Spring容器会调用Bean的初始化方法，例如使用@PostConstruct注解
  4. 销毁阶段：当容器关闭或销毁时，Spring容器会调用Bean的销毁方法，例如使用@PreDestory注解

这样讲讲方法太枯燥了，我一开始也记不住，通过下面例子可以加深印象

@SpringBootApplication
public class A03Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(A03Application.class, args);
        context.close();
    }
}

@Component
public class LifeCycleBean {
    private static final Logger logger = LoggerFactory.getLogger(LifeCycleBean.class);

    public LifeCycleBean() {
        logger.debug("构造");
    }

    @Autowired
    public void autowire(@Value("${JAVA_HOME}") String home){
        logger.debug("依赖注入:{}",home);
    }

    @PostConstruct
    public void init(){
        logger.debug("初始化");
    }

    @PreDestroy
    public void destory(){
        logger.debug("销毁");
    }
}

执行代码可以观察到顺序依次为构造->依赖注入->初始化->销毁

image-20231208113234518

Bean扩展

Spring的扩展程度是非常高的，可以在Bean的各个生命周期中实现自己想要的结果

@Component
public class MyBeanPostProcessor implements DestructionAwareBeanPostProcessor, InstantiationAwareBeanPostProcessor {
    private static final Logger log = LoggerFactory.getLogger(MyBeanPostProcessor.class);

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean")) {
            log.debug("<<<<<< 实例化之前执行, 这里返回的对象会替换掉原本的 bean");
        }
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean")) {
            log.debug("<<<<<< 实例化之后执行, 这里如果返回 false 会跳过依赖注入阶段");
        }
        return true;
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean")) {
            log.debug("<<<<<< 依赖注入阶段执行, 如 @Autowired、@Value、@Resource");
        }
        return pvs;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean")) {
            log.debug("<<<<<< 初始化之前执行, 这里返回的对象会替换掉原本的 bean, 如 @PostConstruct、@ConfigurationProperties");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean")) {
            log.debug("<<<<<< 初始化之后执行, 这里返回的对象会替换掉原本的 bean, 如代理增强");
        }
        return bean;
    }

    @Override
    public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean")) {
            log.debug("<<<<<< 销毁之前执行, 如 @PreDestroy");
        }
    }
}

模版方法

模板方法是一种常用的设计模式，在之前对BeanFactory添加后处理器时，比较好奇他这个处理器是如何加载进去的，现在使用模板方法可以试着自己动手实现

先来看一下基础代码，MyBeanFactory是自定义的一个BeanFactory，其中getBean()可以获取Bean

我们的想法是，在getBean()时，添加后处理器，来解析@Autowired或者@Resource

    public static void main(String[] args) {
        MyBeanFactory beanFactory = new MyBeanFactory();
        beanFactory.getBean();
    }

    static class MyBeanFactory{
        public Object getBean(){
            Object bean = new Object();
            //依赖注入解析
            return bean;
        }
    }

方案一

比较简单的方法就是直接在getBean()中实现，但是这样并不利于扩展，假如需要后续解析其他注解，那么就得修改getBean()方法

方案二

参照之前DefaultListableBeanFactory的做法，我们并没有修改内部方法，而是调用DefaultListableBeanFactory其他方法来添加后处理器

通过一个集合来加载所有后处理器，这样在需要添加后处理器的时候就可以在外部直接调用addBeanPostProcessor()方法，不需要动到MyBeanFactory这个最底层的类

    public static void main(String[] args) {
        MyBeanFactory beanFactory = new MyBeanFactory();
        beanFactory.addBeanPostProcessor(() -> System.out.println("解析 @Autowired"));
        beanFactory.addBeanPostProcessor(() -> System.out.println("解析 @Resource"));
        beanFactory.getBean();
    }

    static class MyBeanFactory{
        public Object getBean(){
            Object bean = new Object();
            //执行后置处理器
            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                beanPostProcessor.inject();
            }
            return bean;
        }

        private static List<BeanPostProcessor> beanPostProcessorList = new ArrayList<>();

        public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor){
            beanPostProcessorList.add(beanPostProcessor);
        }
    }

    interface BeanPostProcessor{
        /**
         * 依赖注入阶段扩展
         */
        void inject();
    }

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1345652.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

力扣：63. 不同路径 II（动态规划）

力扣：63. 不同路径 II（动态规划）

题目&#xff1a; 一个机器人位于一个 m x n 网格的左上角 &#xff08;起始点在下图中标记为 “Start” &#xff09;。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角&#xff08;在下图中标记为 “Finish”&#xff09;。 现在考虑网格中有障碍物。那…
阅读更多...
【Matlab】基于遗传算法优化BP神经网络 (GA-BP)的数据时序预测

【Matlab】基于遗传算法优化BP神经网络 (GA-BP)的数据时序预测

资源下载&#xff1a; https://download.csdn.net/download/vvoennvv/88682033 一&#xff0c;概述 基于遗传算法优化BP神经网络 (GA-BP) 的数据时序预测是一种常用的机器学习方法&#xff0c;用于预测时间序列数据的趋势和未来值。 在使用这种方法之前&#xff0c;需要将时间序…
阅读更多...
visual studio + intel Fortran 错误解决

visual studio + intel Fortran 错误解决

版本&#xff1a;VS2022 intel Fortran 2024.0.2 Package ID: w_oneAPI_2024.0.2.49896 共遇到三个问题。 1.rc.exe not found 2.kernel32.lib 无法打开 3.winres.h 无法打开 我安装时参考的教程&#xff1a;visual studio和intel oneAPI安装与编写fortran程序_visual st…
阅读更多...
小巧的Windows Memory Cleaner内存清理工具-释放内存，提升电脑的性能-供大家学习研究参考

小巧的Windows Memory Cleaner内存清理工具-释放内存，提升电脑的性能-供大家学习研究参考

软件介绍 Windows Memory Cleaner是一款非常不错的内存清理工具大小仅200KB&#xff0c;这款免费的 RAM 清理器使用本机 Windows 功能来清理内存区域&#xff0c;帮助用户释放内存&#xff0c;提升电脑的性能&#xff0c;有时程序不会释放分配的内存&#xff0c;从而使计算机变…
阅读更多...
pytest pytest.ini 设置目录路径，不执行该目录下的case

pytest pytest.ini 设置目录路径，不执行该目录下的case

pytest.ini [pytest] norecursedirs case/1 && case/2
阅读更多...
【Vue2+3入门到实战】（15）VUE路由入门声明式导航的基本使用与详细代码示例

【Vue2+3入门到实战】（15）VUE路由入门声明式导航的基本使用与详细代码示例

目录 一、声明式导航-导航链接1.需求2.解决方案3.通过router-link自带的两个样式进行高亮4.总结 二、声明式导航-两个类名1.router-link-active2.router-link-exact-active3.在地址栏中输入二级路由查看类名的添加4.总结 三、声明式导航-自定义类名&#xff08;了解&#xff09…
阅读更多...
日志高亮 | notepad

日志高亮 | notepad

高亮显示日志 日志文件无法清晰看到关键问题所在? 看到一堆日志头疼?高亮日志可以清晰展示出日志的 ERROR级等各种等级的问题, 一下浏览出日志关键所在 tailspin 项目地址&#xff1a; https://githubfast.com/bensadeh/tailspin 使用Rust包管理器cargo安装 安装 - Cargo 手…
阅读更多...
LeetCode二叉树路径和专题：最大路径和与路径总和计数的策略

LeetCode二叉树路径和专题：最大路径和与路径总和计数的策略

目录 437. 路径总和 III 深度优先遍历 前缀和优化 124. 二叉树中的最大路径和 437. 路径总和 III 给定一个二叉树的根节点 root &#xff0c;和一个整数 targetSum &#xff0c;求该二叉树里节点值之和等于 targetSum 的 路径 的数目。 路径 不需要从根节点开始&#xf…
阅读更多...
【MYSQL】-函数

【MYSQL】-函数

&#x1f496;作者&#xff1a;小树苗渴望变成参天大树&#x1f388; &#x1f389;作者宣言&#xff1a;认真写好每一篇博客&#x1f4a4; &#x1f38a;作者gitee:gitee✨ &#x1f49e;作者专栏&#xff1a;C语言,数据结构初阶,Linux,C 动态规划算法&#x1f384; 如 果 你 …
阅读更多...
在线智能防雷监控检测系统应用方案

在线智能防雷监控检测系统应用方案

在线智能防雷监控检测系统是一种利用现代信息技术&#xff0c;对防雷设施的运行状态进行实时监测、管理和控制的系统&#xff0c;它可以有效提高防雷保护的安全性、可靠性和智能化程度&#xff0c;降低运维成本和风险&#xff0c;为用户提供全方位的防雷解决方案。 地凯科技在…
阅读更多...
Vue常见面试问答

Vue常见面试问答

vue响应式数据 vue2 Vue2 的对象数据是通过 Object.defineProperty 对每个属性进行监听&#xff0c;当对属性进行读取的时候&#xff0c;就会触发 getter&#xff0c;对属性进行设置的时候&#xff0c;就会触发 setter。 /** * 这里的函数 defineReactive 用来对 Object.def…
阅读更多...
2023.12.28 关于 Redis 数据类型 List 内部编码、应用场景

2023.12.28 关于 Redis 数据类型 List 内部编码、应用场景

目录 List 编码方式 早期版本 现今版本 List 实际应用 多表之间的关联关系 消息队列 频道&#xff08;多列表&#xff09;消息队列 微博 Timeline 栈 & 队列 List 编码方式 早期版本 早期版本 List 类型的内部编码方式有两种 ziplist&#xff08;压缩列表&#xf…
阅读更多...
论文阅读＜Contrastive Learning-based Robust Object Detection under Smoky Conditions＞

论文阅读＜Contrastive Learning-based Robust Object Detection under Smoky Conditions＞

论文链接&#xff1a;https://openaccess.thecvf.com/content/CVPR2022W/UG2/papers/Wu_Contrastive_Learning-Based_Robust_Object_Detection_Under_Smoky_Conditions_CVPRW_2022_paper.pdf Abstract 目标检测是指有效地找出图像中感兴趣的目标&#xff0c;然后准确地确定它们…
阅读更多...
ssrf之gopher协议的使用和配置，以及需要注意的细节

ssrf之gopher协议的使用和配置，以及需要注意的细节

gopher协议 目录 gopher协议 &#xff08;1&#xff09;安装一个cn &#xff08;2&#xff09;使用Gopher协议发送一个请求&#xff0c;环境为&#xff1a;nc起一个监听&#xff0c;curl发送gopher请求 &#xff08;3&#xff09;使用curl发送http请求&#xff0c;命令为 …
阅读更多...
【MATLAB】PSO粒子群优化LSTM（PSO_LSTM）的时间序列预测

【MATLAB】PSO粒子群优化LSTM（PSO_LSTM）的时间序列预测

有意向获取代码&#xff0c;请转文末观看代码获取方式~也可转原文链接获取~ 1 基本定义 PSO粒子群优化LSTM&#xff08;PSO-LSTM&#xff09;是一种将粒子群优化算法&#xff08;PSO&#xff09;与长短期记忆神经网络&#xff08;LSTM&#xff09;相结合的混合模型。该算法通过…
阅读更多...
Kubernetes技术与架构-集群管理

Kubernetes技术与架构-集群管理

Kubernetes技术与架构提供支撑工具支持集群的规划、安装、创建以及管理。 数字证书 用户可以使用easyrsa、openssl、cfssl工具生成数字证书&#xff0c;在kubernetes集群的api server中部署数字证书用于访问鉴权 资源管理 如上所示&#xff0c;定义一个服务类service用于负…
阅读更多...
计算机视觉技术-目标检测数据集

计算机视觉技术-目标检测数据集

目标检测领域没有像MNIST和Fashion-MNIST那样的小数据集。 为了快速测试目标检测模型&#xff0c;我们收集并标记了一个小型数据集。 首先&#xff0c;我们拍摄了一组香蕉的照片&#xff0c;并生成了1000张不同角度和大小的香蕉图像。 然后&#xff0c;我们在一些背景图片的随机…
阅读更多...
【计算机网络】第五，六章摘要重点

【计算机网络】第五，六章摘要重点

1.运输层协议概述 运输层提供的是进程之间的通信 2. 3.套接字指的是什么 ip地址端口号 4.每一条TCP语句唯一地被通信两端连接的两个端点 5.TCP传输如何实现 以字节为单位的滑动窗口 超时重传 选择确认 6.TCP流量控制和拥塞控制的区别 流量控制&#xff1a;点对点通信…
阅读更多...
android 13.0 Launcher3长按app弹窗设置为圆角背景功能实现一

android 13.0 Launcher3长按app弹窗设置为圆角背景功能实现一

1.前言 在13.0的系统ROM定制化开发中，在进行一些Launcher3的定制化开发中，在使用app的弹窗的功能时，会弹出应用信息和微件之类的内容，所以在定制需求中，需要默认设置为圆角背景，接下来就来分析下相关功能的实现 如图: 2.Launcher3长按app弹窗设置为圆角背景功能实现的核…
阅读更多...
如何高效查询文件：Linux 下的多种方法详解

如何高效查询文件：Linux 下的多种方法详解

如何高效查询文件&#xff1a;Linux 下的多种方法详解 在日常工作中&#xff0c;我们经常需要查找文件&#xff0c;无论是寻找特定的代码文件、配置文件还是其他文档。Linux 提供了多种强大的命令和工具&#xff0c;通过巧妙地使用管道符&#xff0c;我们可以将这些命令组合起来…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023