Spring源码分析：bean加载流程

7b2663d67506b10df9cc11971a332081.jpeg

背景

在Spring中，Bean的加载和管理是其核心功能之一，包括配置元数据解析、Bean定义注册、实例化、属性填充、初始化、后置处理器处理、完成创建和销毁等步骤。

源码入口

AbstractBeanFactory#doGetBean

884e11e7c022917f72c3d6bf8566f7ba.png

具体源码流程如下：

56bd983a68cf1beba09cb1d7973c1343.png

bean加载流程（#getBean方法）分析：

1、提取beanName

  • 提取FactoryBean修饰符，比如name=“&aa”，那么就要去掉&，使得name=“aa”

  • 或者，提取指定的beanName，比如别名A->B的bean则返回B

2、从缓存中加载单例

创建单例时，为避免循环依赖，不等完全bean创建，就将创建bean的ObjectFactory提早曝光；即，ObjectFactory放到缓存Map中，一旦下一个bean需要依赖上个bean，就直接使用 ObjectFactory即可。

  • singletonObjects：key=BeanName，value=构造完成的bean实例

  • earlySingletonObjects：key=BeanName，value=构造完成的bean实例，用来解决循环依赖问题

  • singletonFactories：key=BeanName，value=ObjectFactory工厂实例

三级缓存实现原理

当Spring容器创建Bean时，首先会从singletonObjects缓存中查找Bean实例，如果能找到则直接返回。

  • 如果在singletonObjects缓存中没有找到Bean实例，则从earlySingletonObjects缓存中查找，如果找到了一个未完成初始化的Bean实例，则将其返回，并在后续的处理中完成初始化。

  • 如果在earlySingletonObjects缓存中也没有找到Bean实例，则从singletonFactories缓存中查找是否存在创建Bean实例的工厂对象，如果存在，则通过工厂对象创建一个新的Bean实例，并将工厂对象从singletonFactories缓存中移除。

  • 如果在singletonFactories缓存中也没有找到工厂对象，则需要创建一个新的工厂对象，并放到singletonFactories缓存中，以便后续使用。

  • 创建Bean实例时，如果Bean存在循环依赖，那么Spring框架会先创建一个用于创建Bean实例的工厂对象，放到singletonFactories缓存中。然后通过工厂对象创建一个新的Bean实例，并将其放到earlySingletonObjects缓存中，以便后续处理。

下面是DefaultSingletonBeanRegistry源码

/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);


/** Cache of singleton factories: bean name to ObjectFactory. */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);


/** Cache of early singleton objects: bean name to bean instance. */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);


@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   Object singletonObject = this.singletonObjects.get(beanName);
   // 【1】
   if (singletonObject == null 
       && isSingletonCurrentlyInCreation(beanName)) {
     // 【2】
      synchronized (this.singletonObjects) {
          // 【3】
         singletonObject = this.earlySingletonObjects.get(beanName);
         if (singletonObject == null && allowEarlyReference) {
             // 【4】
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
                // 【5】
               singletonObject = singletonFactory.getObject();
               // 【6】
               this.earlySingletonObjects.put(beanName, singletonObject);
               // 【7】
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return singletonObject;


}

代码分析：

  • 【1】isSingletonCurrentlyInCreation 判断是否循环依赖

  • 【2】用synchronized 锁住singleObjects一级缓存全局变量，确保线程安全，因为有3个全局变量要修改的

  • 【3】从 earlySingletonObjects 二级缓存取 object

    • 如果object不为空，说明bean正在被创建，则跳出来

    • 如果object为空，说明bean没在被创建，需要执行下面逻辑

  • 【4】从 singletonFactories 三级缓存取 ObjectFactory（某些方法提前初始化了ObjectFactory策略到 singletonFactories 中）

    • 【5】如果object不为空，说明已经有预设好的ObjectFactory，可以实例化它：通过预设的getBean ObjectFactory@getObject() 创建bean实例

    • 【6】记录到 earlySingletonObjects 中，说明此bean正在被创建

    • 【7】earlySingletonObjects 和 singletonFactories是互斥的，因此要remove调

3、多例对象-是否创建中检测

if (isPrototypeCurrentlyInCreation(beanName)) {
   throw new BeanCurrentlyInCreationException(beanName);
}

单例才检测循环依赖，多例抛异常。

4、检测parentBeanFactory

BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
   // Not found -> check parent.
   String nameToLookup = originalBeanName(name);
   if (parentBeanFactory instanceof AbstractBeanFactory) {
      return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
            nameToLookup, requiredType, args, typeCheckOnly);
   }
   else if (args != null) {
      // Delegation to parent with explicit args.
      return (T) parentBeanFactory.getBean(nameToLookup, args);
   }
   else if (requiredType != null) {
      // No args -> delegate to standard getBean method.
      return parentBeanFactory.getBean(nameToLookup, requiredType);
   }
   else {
      return (T) parentBeanFactory.getBean(nameToLookup);
   }
}

缓存没有数据，直接转到父类工厂上去加载工厂方法

5、解析Defination类的类型转换，换成可用的BeanDefination

final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);

6、寻找递归解决bean依赖，并加载和初始化这些依赖 -- 递归思想哦！

String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
   for (String dep : dependsOn) {
      if (isDependent(beanName, dep)) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
               "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
      }
      registerDependentBean(dep, beanName);
      try {
         getBean(dep);
      }
      catch (NoSuchBeanDefinitionException ex) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
               "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
      }
   }
}

7、正式根据scope去创建bean

bean创建的特别之处

Spring 解决循环依赖依靠的是 Bean 的 " 中间态 " 这个概念，而这个中间态指的是已经实例化但还没初始化的状态 —>半成品。

实例化的过程又是通过构造器创建的，如果 A 还没创建好出来怎么可能提前曝光，所以构造器的循环依赖无法解决。

由于 spring 中的 bean 的创建过程为先实例化 再初始化 ( 在进行对象实例化的过程中不必赋值 ) 将实例化好的对象暴露出去, 供其他对象调用 , 然而使用构造器注入 , 必须要使用构造器完成对象的初始化的操作 ,就会陷入死循环的状态。

单例scope：实例化bean

if (mbd.isSingleton()) {
   sharedInstance = getSingleton(beanName, () -> {
      try {
         return createBean(beanName, mbd, args);
      }
      catch (BeansException ex) {
         // Explicitly remove instance from singleton cache: It might have been put there
         // eagerly by the creation process, to allow for circular reference resolution.
         // Also remove any beans that received a temporary reference to the bean.
         destroySingleton(beanName);
         throw ex;
      }
   });
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

代码分析：

  • 实例化bean：createBean -》

    • doCreateBean -》，参考下面的源码分析【1】

      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

    • createBeanInstance，参考下面的源码分析【2】

  • getSingleton：beanName是一个参数，另一个匿名函数则是ObjectFactory<?> singletonFactory，即构造bean的工厂方法

    • singletonObjects：添加经过了实例化+初始化的bean实例

    • singletonFactories：移除

    • earlySingletonObjects：移除

    • addSingleton(beanName, singletonObject)：三级缓存的清理赋值

【1】源码addSingletonFactory：创建bean实例

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
      isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
   addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}


protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
   Assert.notNull(singletonFactory, "Singleton factory must not be null");
   synchronized (this.singletonObjects) {
      if (!this.singletonObjects.containsKey(beanName)) {
         this.singletonFactories.put(beanName, singletonFactory);
         this.earlySingletonObjects.remove(beanName);
         this.registeredSingletons.add(beanName);
      }
   }
}

代码分析：该方法用于添加单例工厂，主要功能包括：

  • 检查传入的单例工厂是否为null，若为null则抛出异常。

  • 同步锁住singletonObjects确保线程安全。

  • 若singletonObjects中没有beanName对应的对象，则将singletonFactory放入singletonFactories映射中，并移除earlySingletonObjects中的对应项，最后将beanName加入registeredSingletons集合。

这也侧面说明了，bean还没有完全初始化，就把工厂方法提前暴露到了singletonFactories

【2】源码createBeanInstance：bean实例化
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
   // Make sure bean class is actually resolved at this point.
   Class<?> beanClass = resolveBeanClass(mbd, beanName);


   if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
      throw new BeanCreationException(mbd.getResourceDescription(), beanName,
            "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
   }


   Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
   if (instanceSupplier != null) {
      return obtainFromSupplier(instanceSupplier, beanName);
   }


   if (mbd.getFactoryMethodName() != null) {
      return instantiateUsingFactoryMethod(beanName, mbd, args);
   }


   // Shortcut when re-creating the same bean...
   boolean resolved = false;
   boolean autowireNecessary = false;
   if (args == null) {
      synchronized (mbd.constructorArgumentLock) {
         if (mbd.resolvedConstructorOrFactoryMethod != null) {
            resolved = true;
            autowireNecessary = mbd.constructorArgumentsResolved;
         }
      }
   }
   if (resolved) {
      if (autowireNecessary) {
         return autowireConstructor(beanName, mbd, null, null);
      }
      else {
         return instantiateBean(beanName, mbd);
      }
   }


   // Candidate constructors for autowiring?
   Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
   if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
      return autowireConstructor(beanName, mbd, ctors, args);
   }


   // Preferred constructors for default construction?
   ctors = mbd.getPreferredConstructors();
   if (ctors != null) {
      return autowireConstructor(beanName, mbd, ctors, null);
   }


   // No special handling: simply use no-arg constructor.
   return instantiateBean(beanName, mbd);
}

代码分析：

createBeanInstance 用于创建 Bean 的实例，负责根据不同的条件和配置来实例化 Bean，并处理相关的异常情况：

  1. 解析并验证 Bean 类。

  2. 如果允许，尝试从 Supplier 获取实例。

  3. 若配置了工厂方法，则通过工厂方法实例化。

  4. 否则，根据参数情况选择构造器自动装配或直接实例化。

初始化bean：填充属性

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean#populateBean

@SuppressWarnings("deprecation")  // for postProcessPropertyValues
protected void populateBean(
    String beanName, RootBeanDefinition mbd, 
    @Nullable BeanWrapper bw) {
    //【1】
   if (bw == null) {
      if (mbd.hasPropertyValues()) {
         throw new BeanCreationException(
               mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
      }
      else {
         return;
      }
   }


    //【2】
   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
               return;
            }
         }
      }
   }


   PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);


    //【3】
   int resolvedAutowireMode = mbd.getResolvedAutowireMode();
   if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
      MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
      // Add property values based on autowire by name if applicable.
      if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
         autowireByName(beanName, mbd, bw, newPvs);
      }
      // Add property values based on autowire by type if applicable.
      if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
         autowireByType(beanName, mbd, bw, newPvs);
      }
      pvs = newPvs;
   }


   boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
   boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);


   PropertyDescriptor[] filteredPds = null;
   if (hasInstAwareBpps) {
      if (pvs == null) {
         pvs = mbd.getPropertyValues();
      }
      //【4】
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
            if (pvsToUse == null) {
               if (filteredPds == null) {
                  filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
               }
               pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
               if (pvsToUse == null) {
                  return;
               }
            }
            pvs = pvsToUse;
         }
      }
   }


   if (needsDepCheck) {
      if (filteredPds == null) {
         filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
      }
      //【5】
      checkDependencies(beanName, mbd, filteredPds, pvs);
   }


   if (pvs != null) {
       //【6】
      applyPropertyValues(beanName, mbd, bw, pvs);
   }
}

代码分析：

  1. 【1】检查BeanWrapper是否为空，若为空且存在属性值，则抛出异常；否则跳过属性填充。

  2. 【2】若存在实例化需要的后置处理器，则调用它们对bean进行处理。

  3. 【3】根据自动装配模式（按名或按类型）添加属性值。

  4. 【4】调用实例化后置处理器处理属性值。

  5. 【5】检查依赖关系并进行依赖检查。

  6. 【6】应用最终的属性值到bean上

多例scope：实例化bean

else if (mbd.isPrototype()) {
   // It's a prototype -> create a new instance.
   Object prototypeInstance = null;
   try {
      beforePrototypeCreation(beanName);
      prototypeInstance = createBean(beanName, mbd, args);
   }
   finally {
      afterPrototypeCreation(beanName);
   }
   bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}

代码分析：

  • createBean：流程参考单例scope的创建，是类似的。

8、通用：初始化bean & 注入依赖

之前已经实例化过bean了，现在则是完成注入属性；属性注入的顺序是，优先通过autowireByName，然后才是autowireByType。

int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
   MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
   // Add property values based on autowire by name if applicable.
   if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
      autowireByName(beanName, mbd, bw, newPvs);
   }
   // Add property values based on autowire by type if applicable.
   if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
      autowireByType(beanName, mbd, bw, newPvs);
   }
   pvs = newPvs;
}

9、再执行当前bean的initializeBean初始化

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
         invokeAwareMethods(beanName, bean);
         return null;
      }, getAccessControlContext());
   }
   else {
      invokeAwareMethods(beanName, bean);
   }


   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }


   try {
      invokeInitMethods(beanName, wrappedBean, mbd);
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            (mbd != null ? mbd.getResourceDescription() : null),
            beanName, "Invocation of init method failed", ex);
   }
   if (mbd == null || !mbd.isSynthetic()) {
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }


   return wrappedBean;
}

该Java函数initializeBean用于初始化一个Bean：

  1. 初始化前

    1. 根据系统安全设置，以特权操作方式或直接调用invokeAwareMethods方法，即Aware接口方法调用

    2. 执行BeanPostProcessor接口的postProcessBeforeInitialization方法，即Bean应用前置处理器

  2. 初始化时

  • 调用InitializingBean接口的afterPropertiesSet方法，完成初始化

  1. BeanPostProcessor接口的applyBeanPostProcessorsBeforeInitialization

  2. 调用初始化方法，对bean 进行初始化，若失败则抛出异常。

  3. 执行BeanPostProcessor接口的postProcessAfterInitialization方法，即对Bean应用后置处理器。

初始化后

  1. DisposableBean接口的destroy方法执行（有必要的话）

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

万界星空科技：智能称重打标系统

万界星空科技：智能称重打标系统

万界星空科技的称重系统是其为制造业&#xff0c;特别是线缆、漆包线、食品等行业提供的重要解决方案之一。以下是对该系统的详细介绍&#xff1a; 一、系统概述 万界星空科技称重系统是集成在其MES&#xff08;制造执行系统&#xff09;中的一个功能模块&#xff0c;专门用于…
阅读更多...
数据结构之旅(顺序表)

数据结构之旅(顺序表)

前言: Hello,各位小伙伴们我们在过去的60天里学完了C语言基本语法,由于小编在准备数学竞赛,最近没有给大家更新,并且没有及时回复大家的私信,小编在这里和大家说一声对不起!,小编这几天会及时给大家更新初阶数据结构的内容,然后我们来学习今天的内容吧! 一. 顺序表的概念和结…
阅读更多...
2024.10.15 sql

2024.10.15 sql

刷题网站&#xff1a; 牛客网 select device_id as user_infos_example from user_profile where id < 2 select device_id, university from user_profile where university"北京大学" select device_id, gender, age, university from user_profile where ag…
阅读更多...
Bellman-Ford

Bellman-Ford

思路 外层遍历V-1次内层遍历所有边&#xff08;共E次&#xff09;&#xff0c;尝试更新起点的终点的dist值 原材料是backup&#xff08;前次遍历的结果&#xff09;维持住性质&#xff08;见下&#xff09; 优点 允许负环 允许负权边 有特殊性质 缺点 复杂度达到 例题 代码…
阅读更多...
2、CSS笔记

2、CSS笔记

文章目录 二、CSS基础CSS简介CSS语法规范CSS代码风格CSS选择器CSS基础选择器标签选择器类选择器--最常用id选择器通配符选择器 CSS复合选择器交集选择器--重要并集选择器--重要后代选择器--最常用子代选择器--重要兄弟选择器相邻兄弟选择器通用兄弟选择器 属性选择器伪类选择器…
阅读更多...
Flutter url_launcher：打开网页、邮件、电话和短信的最佳实践

Flutter url_launcher：打开网页、邮件、电话和短信的最佳实践

Flutter url_launcher&#xff1a;打开网页、邮件、电话和短信的最佳实践 视频 https://youtu.be/uGT43gZNkyc https://www.bilibili.com/video/BV1G42EYcE7K/ 前言 原文 如何在 Flutter 中使用 url_launcher 打开网页和发送短信 本文介绍了如何在 Flutter 中使用 url_launc…
阅读更多...
【深度学习代码调试1】环境配置篇（上） -- 安装PyTorch（安利方法：移除所有国内源，使用默认源）

【深度学习代码调试1】环境配置篇（上） -- 安装PyTorch（安利方法：移除所有国内源，使用默认源）

【深度学习代码调试1】环境配置篇 -- 安装TensorFlow和PyTorch 写在最前面1. 创建新的Conda环境2. 安装PyTorch及相关库&#xff08;可以直接跳到2.3安装方法&#xff09;2.1 检查CUDA版本2.2 解决安装过程中常见问题2.2.1 超时问题&#xff08;这个不是最终解决方案&#xff0…
阅读更多...
【argparse】 菜鸟实用教程指南

【argparse】 菜鸟实用教程指南

文章目录 0. 引言1. argparse简介2. argparse的使用3. 实例操作4. 代码运行4.1 命令行执行4.1 IDE执行 5. 总结 0. 引言 在深度学习的过程中&#xff0c;我们常常需要操作和调参大量的参数。如果采用硬编码&#xff08;直接在代码中赋值&#xff09;的方式来设置这些参数&…
阅读更多...
java项目之科研工作量管理系统的设计与实现源码(springboot+vue+mysql)

java项目之科研工作量管理系统的设计与实现源码(springboot+vue+mysql)

风定落花生&#xff0c;歌声逐流水&#xff0c;大家好我是风歌&#xff0c;混迹在java圈的辛苦码农。今天要和大家聊的是一款基于springboot的科研工作量管理系统的设计与实现。项目源码以及部署相关请联系风歌&#xff0c;文末附上联系信息 。 项目简介&#xff1a; 科研工作…
阅读更多...
【C语言】算术运算、关系运算、逻辑运算

【C语言】算术运算、关系运算、逻辑运算

算术运算&#xff1a;常见的数字运算&#xff0c;加减乘除等 关系运算&#xff1a;数值之间大小多少的关系 逻辑运算&#xff1a;逻辑与、或、非 #include <stdio.h> /* 功能&#xff1a;算术运算、关系运算、逻辑运算 时间&#xff1a;2024年10月 地点&#xff1a;贤者…
阅读更多...
斯坦福 CS229 I 机器学习 I 构建大型语言模型 （LLMs）

斯坦福 CS229 I 机器学习 I 构建大型语言模型 （LLMs）

1. Pretraining -> GPT3 1.1. Task & loss 1.1.1. 训练 LLMs 时的关键点 对于 LLMs 的训练来说&#xff0c;Architecture&#xff08;架构&#xff09;、Training algorithm/loss&#xff08;训练算法/损失函数&#xff09;、Data&#xff08;数据&#xff09;、Evalu…
阅读更多...
Linux INPUT 子系统实验

Linux INPUT 子系统实验

按键、鼠标、键盘、触摸屏等都属于输入(input)设备&#xff0c;Linux 内核为此专门做了一个叫做 input子系统的框架来处理输入事件。输入设备本质上还是字符设备&#xff0c;只是在此基础上套上了 input 框架&#xff0c;用户只需要负责上报输入事件&#xff0c;比如按键值、坐…
阅读更多...
Qt-系统文件相关介绍使用(61)

Qt-系统文件相关介绍使用(61)

目录 描述 输⼊输出设备类 打开/读/写/关闭 使用 先初始化&#xff0c;创建出大致的样貌 输入框设置 绑定槽函数 保存文件 打开文件 提取文件属性 描述 在C/C Linux 中我们都接触过关于文件的操作&#xff0c;当然 Qt 也会有对应的文件操作的 ⽂件操作是应⽤程序必不…
阅读更多...
八、Linux之实用指令

八、Linux之实用指令

1、指定运行级别 1.1 基本介绍 运行级别说明 0 &#xff1a;关机 1 &#xff1a;单用户【找回丢失密码】 2&#xff1a;多用户状态没有网络服务&#xff08;用的非常少&#xff09; 3&#xff1a;多用户状态有网络服务&#xff08;用的最多&#xff09; 4&#xff1a;系统未使…
阅读更多...
《Effective C++》 笔记

《Effective C++》 笔记

让自己习惯C&#xff0c;Accustoming Yourself to C 1. 视C为一个语言联邦&#xff0c;View Cas a federation of languages. 将 C视为一个由相关语言组成的联邦而非单一语言。在其某个次语言&#xff08;sublanguage&#xff09;中&#xff0c;各种守则与通例都倾向简单、直观…
阅读更多...
机器学习笔记-2

机器学习笔记-2

文章目录 一、Linear model二、How to represent this function三、Function with unknown parameter四、ReLU总结、A fancy name 一、Linear model 线性模型过于简单&#xff0c;有很大限制&#xff0c;我们需要更多复杂模式 蓝色是线性模型&#xff0c;线性模型无法去表示…
阅读更多...
【.net core使用minio大文件分片上传】.net core使用minio大文件分片上传以及断点续传、秒传思路

【.net core使用minio大文件分片上传】.net core使用minio大文件分片上传以及断点续传、秒传思路

版本&#xff1a;.net core 7 需求&#xff1a;net限制了上传的大小&#xff0c;只能上传25M上下的文件&#xff0c;如果上传一个八十多兆的文件&#xff0c;swagger接口报错&#xff0c;如果前端调用上传接口&#xff0c;会报CORS跨域错误&#xff0c;这篇文章介绍怎么使用分片…
阅读更多...
【X线源】关于滨松MCS2软件的说明

【X线源】关于滨松MCS2软件的说明

【X线源】关于滨松MCS2软件的说明 1.软件背景2.MCS2界面3.MCS2操作4.常见问题 1.软件背景 滨松为了方便客户将滨松MFX集成进自己的系统&#xff0c;滨松提供了MFX二次开发相关的信息和Demo代码。参考博客说明&#xff1a; 【X线源】关于滨松MFX二次开发demo示例简介 https://…
阅读更多...
一个Idea：爆改 T480

一个Idea：爆改 T480

爆改 T480 准备大改 T480&#xff0c;家里有一台闲置很久的 T480&#xff0c;不舍得扔&#xff0c;打算升级一下。看了几位up主的视频后&#xff0c;决定动手改造。 计划如下 网卡&#xff1a;加装4G网卡硬盘&#xff1a;更换为 1T 的 NVMe 2280 固态硬盘内存&#xff1a;升…
阅读更多...
Unity实战案例全解析 类宝可梦回合制的初级案例 源码分析（加了注释和流程图）

Unity实战案例全解析 类宝可梦回合制的初级案例 源码分析（加了注释和流程图）

这是一个老教程了&#xff0c;但是对于没有写过回合制的初级程序同学来讲是比较适合的&#xff0c;也可以直接看源码&#xff0c;半小时内可以解决战斗 当然&#xff0c;我也没写过回合制系统所以就到处找&#xff0c;思路明白了就能自己修改了 视频教程 - 油管链接 Turn-Bas…
阅读更多...
最新文章

Copyright @ 2022~2023