从Spring为什么要用IoC的支点,我撬动了整个Spring的源码脉络!

基于OFDM的实时图像传输系统MATLAB仿真:MPSK与MQAM调制性能对比与误码率分析 本文详细介绍了基于OFDM的实时图像传输系统在MATLAB中的仿真实现,重点对比了MPSK与MQAM调制方式的性能差异与误码率分析。通过搭建OFDM系统模型,探讨了QPSK和16QAM在不同信道条件下的表现,包括频谱效率、抗噪能力和误码率等关键指标。文章还提供了MATLAB代码示例和实用技巧,帮助读者快速掌握OFDM图像传输系统的核心算法与优化方法。 阅读详情

前言

有一天,我翻开源码横看竖看,满屏只看到四个字,我看不懂啊。

所以是不是曾和我一样迷失在毫无头绪的源码里,在各种类和方法里翻山越岭,却如同管中窥豹。是的话,要不今晚早点睡?

呸,扯远了,写文章怎么能分神呢。

所以正当我苦恼的时候,我想起了一句话“给我一个支点我就可以撬动整个地球”,阿基米德说的。

咦,突然让我灵机一动,那撬动整个Spring源码的支点是什么呢?或者说Spring作者在开发Spring时的支点是什么呢?这么想让我开始觉得有点意思了。

如果尝试先从使用Spring的角度来看源码,好像事情也并没有那么错综复杂。

你是怎么使用Spring的,你就怎么看Spring源码!

先把镜头拉回到使用Spring后最大变化是什么?毫无疑问是改变了我们编程方式,原来是程序员自己既要定义对象,然后还要通过new的方式创建出对象。而在Spring中则我们只需要定义Bean,然后交给Spring来创建对象(从甲乙方的角度,定义对象是提需求的甲方,实现对象是执行的乙方。那么new的方式是即做甲方又做乙方。而Spring让程序员当了一回甲方)。

而这个动作就是IOC(Inversion of Control)控制反转。不过IoC不是一种具体的技术,而是一种设计思想。

那问题来了,IoC是怎么来的?

其实IoC可以追溯到一个原则,好莱坞原则。把IOC对应到这一原则,一切都很好理解,就是在IoC中,所有的对象都是被动的,对象初始化和调用都由Spring负责。

“不要给我们打电话,我们会给你打电话(don‘t call us, we‘ll call you)”这是著名的好莱坞原则。在好莱坞,把简历递交给演艺公司后就只有回家等待。由演艺公司对整个娱乐项的完全控制,演员只能被动式的接受公司的差使,在需要的环节中,完成自己的演出。—— 好莱坞原则

Bean是Spring中的图纸

为什么要有Bean,或者说Bean是什么呢?

我们知道无论是控制反转还是依赖注入都是围绕Object,而对应到Spring中也就是Bean;Bean其实是包装了的Object(对象)

所以Bean是Spring中最核心的东西,Bean`好比有了图纸,才能在Spring上建各种不同的的房子、车子。

可以说一个Bean就是经过了我们定义最后由Spring所创建的Object。

(所以对于程序而言是由一堆的Object构成,那么在Spring所构成的程序里就是一堆Bean)

什么是依赖注入(DI)

前面说Bean是图纸,那么我们就是拿着图纸的设计师,因为在Spring中创建Bean的工作是由Spring来承担的,所以我们要做的是定义Bean信息。如下图所示,我们通过XML,注解的方式来定义Bean的信息。

而这个我们手动的方式定义Bean的方式,我们称为是依赖注入(DI)的方式。

将程序运行需要依赖外部的资源,从外部注入到内部,而容器加载了外部的文件、对象、数据怼到程序内的对象,此时程序内外对象之间的依赖关系,就是依赖注入。

所以说IoC是设计思想,那么DI就是具体的实现方式。

上面我们是我们常定义的是手动方式,而汽车都有分手动挡和自动挡,那么依赖注入方式也有分。

手动方式:

  • XML 资源配置元信息
  • Java 注解配置元信息
  • API 配置元信息

自动方式:

  • Autowiring

依赖除了有按方式,也有按注入类型区分:

  • Setter注入
  • 构造器注入
  • 接口注入
  • 方法注入

但是我们在开发中定义Bean信息的方式还可以有properties,yaml等等。

那么如果我们想要更多配置方式怎么呢?

其实Spring已经想好了,通过定义规范来约束所有需要解析操作的接口BeanDefinitionReader。

如下图BeanDefinitionReader类结构图所示,可以看到那些实现BeanDefinitionReader接口的类。

  • XmlBeanDefinitionReader:读取XML文件定义的Bean。
  • PropertiesBeanDefinitionReader:可以从属性文件Resource,Property对象等读取Bean。
  • GroovyBeanDefinitionReader:可以读取Groovy语言定义的Bean。

所以你会发现Spring中的Bean其实就是用来统一规范的格式,纵使你有不同的Bean定义方式,其原理也只不过解析方式不一样,那么只要定义Bean方式能解析成Spring读的懂得“Bean格式”,那么就能在Spring上运行。

此时如果你回望Java虚拟机中通过Class Loader(类装载器子系统)只能加载.class(字节码)文件格式的想法简直如出一辙。

(所以Spring的胃口也不小,也许在不久的将来,Spring如此生猛的生态下,会不会演化成一门面向Spring开发的语言)

BeanFactory:制造Bean的工厂

当我们自定义了Bean的信息后就是来到给Spring制造Bean时,Spring提供了暴露在外获取bean的入口BeanFactory容器,顾名思义是Bean的工厂,负责生产和管理各个bean实例。

我们进入源码可以看到开头一句注释:

The root interface for accessing a Spring bean container.

是SpringBean容器的根接口。

BeanFactory常见的实现方式类XmlBeanFactory,可以从classpath或文件系统等获取资源。

Resource resource = new ClassPathResource("helloWorld.xml"); 
BeanFactory beanFactory = new XmlBeanFactory(resource);

ApplicationContext

除了BeanFactory你还会注意到一样具有定位Bean功能的ApplicationContext。

如ApplicationContext从ClassPath获取XML配置文件资源是通过XmlApplicationContext。

ApplicationContext resource = new ClassPathXmlApplicationContext("helloWorld");

另外还有两种常见的实现方式:

  • FileSystemXmlApplicationContext:从文件系统中的XML配置文件读取上下文。
  • XmlWebApplicationContext:从Web应用的XML文件读取上下文。

那直接来到源码看ApplicationContext的类结构图,可以发现它继承了多个接口,同时也继承BeanFactory。

所以BeanFactory可以说是最基本的IoC容器,而ApplicationContext是它的子类,成为子类实际上就是为了有更丰富的特性和功能。

那么又会有一个问题,Bean有这么多信息,我们怎么方便的在生产Bean的时候直接使用?

BeanDefiniton

其实在到BeanFactory还会使用到BeanDefinition来描述Bean实例的信息。

在使用<bean>标签的时,你会发现有class、scope、lazy-init等的配置属性,其实是Spring对所管理的Bean的一系列描述,而BeanDefinition中就提供了与之相对应的beanClass、scope、lazylnit属性。

(简单的说,BeanDefinition就是存储着我们给Bean定义的元数据)

所以如果说Class描述的是类的信息,那么BeanDefinition描述的是对象的信息。

那么有了BeanDefinition再制造Bean的时候就可以直接使用,比如getBeanClassName。

BeanDefinition类中开头注释的可以看到这么一段话。

A BeanDefinition describes a bean instance

BeanDefinition描述bean实例。

IoC容器的初始化过程

从上面我们知道了,BeanDefinition描述了Bean的信息,那么意味BeanDefinition装载着Bean的信息,从而加载到BeanFactory。

那么问题又来了,在IoC容器的初始化过程中BeanDefinition是怎么装载进容器里的?

BeanDefinition的定位过程

而这就得把镜头拉到Bean容器的初始化过程。而第一个过程是定位的过程,我们直接来看常用的ApplicationContext的FileSystemXmlApplicationContext可以从文件读入Resource(资源)。

FileSystemXmlApplicationContext res = new FileSystemXmlApplicationContext("helloWorld.xml");

我们可以来看ApplicationContext的实现是怎么完成这个Resource定位过程的。

继续打开类结构图一探究竟 (下图如果看不清,可以右键打开图片浏览)

可以发现很醒目的提供了ResourceLoader对外部资源的访问接口。从而可以加载文件、网络、流中的资源。

ResourceLoader代码如下:

public interface ResourceLoader {
    String CLASSPATH_URL_PREFIX = "classpath:";

    Resource getResource(String var1);

    @Nullable
    ClassLoader getClassLoader();
}


FileSystemXmlApplicationContext继承了AbstractApplicationContext具备了ResourceLoader读入Resource定义的BeanDefinition的能力。

public FileSystemXmlApplicationContext(ApplicationContext parent) {
    super(parent);
}

对于获取Resource的具体过程,可以看DefaultResourceLoader的getResource。

public Resource getResource(String location) {
   Assert.notNull(location, "Location must not be null");

   for (ProtocolResolver protocolResolver : getProtocolResolvers()) {
      Resource resource = protocolResolver.resolve(location, this);
      if (resource != null) {
         return resource;
      }
   }

   if (location.startsWith("/")) {
      return getResourceByPath(location);
   }
   else if (location.startsWith(CLASSPATH_URL_PREFIX)) {
      return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
   }
   else {
      try {
         // Try to parse the location as a URL...
         URL url = new URL(location);
         return (ResourceUtils.isFileURL(url) ? new FileUrlResource(url) : new UrlResource(url));
      }
      catch (MalformedURLException ex) {

         return getResourceByPath(location);
      }
   }
}


getResource最后返回的getResourceByPath会被子类FileSystemXmlApplicationContext实现。而方法返回的是一个FileSystemResource对象。

protected Resource getResourceByPath(String path) {
    if (path.startsWith("/")) {
        path = path.substring(1);
    }

    return new FileSystemResource(path);
}

通过这个FileSystemResource,Spring进行了相关的I/O操作,完成了BeanDefinition的定位。

而在定位过程完成后,就为BeanDefinition创作了载入的条件,定位过程还没有将具体数据读入,而就到了需要BeanDefinitoin载入和解析中完成。以甲乙方为例,甲方提出需求,乙方执行。乙方执行前,要先拿到甲方提出需求的具体资料才行。定位过程就好比已经拿到甲方需求资料。

BeanDefinition的载入

在前面FileSystemXmlApplicationContext的初始化过程中,其实会发现有一个refresh方法,这个方法就是在当调用容器时载入BeanDefinition的入口。

public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
    super(parent);
    this.setConfigLocations(configLocations);
    if (refresh) {
        this.refresh();
    }
}

refresh对容器的启动来说是很重要的方法,可以在AbstractApplicationContext抽象类中找到refresh()。如下所示,它实际上描述了ApplicationContext的初始化过程。有BeanFactory的更新等等。

refresh可以说是对ApplicationContext初始化的模板。

所以整个载入的过程是把用户定义的Bean转化为IoC容器内部数据结构,而容器内部的数据结构就是BeanDefinition。

而refresh就像重启电脑主机一样的重启容器,在建立IoC容器后,对容器的一系列准备工作,也就是初始化过程,其中就包括BeanDefinition载入。

注册BeanDefinition

第三个过程是IoC容器注册BeanDefinition的过程,我们定义的BeanDefinition信息虽然建立起了容器对应的数据形式,但此时这些数据还不能供IoC容器直接使用,还需在IoC容器中对BeanDefinition数据进行注册。

而注册的方式实际上就是通过一个Map来存储BeanDefinition。(可以看出所谓的注册,其实是为了让IoC容器更方便获取和使用)

在DefaultListableBeanFactory类中提前定义的beanDefinitionMap。

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

DefaultListableBeanFactory中实现了 BeanDefinitionRegistry的接口。这个接口定义了 registerBeanDefinition方法来将BeanDefinition向容器的注册。

关键代码并不复杂,其实就是将准备好的BeanDefinition加到Map中。(翻阅到这行关键代码是被遮掩在各种if判断中,最后发现就在末尾处后不由感到欣慰的笑,不愧是你)

this.beanDefinitionMap.put(beanName, beanDefinition);

完整的registerBeanDefinition方法如下,包括了处理遇到其他情况,例如遇到同名的BeanDefinition的处理。

@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
      throws BeanDefinitionStoreException {

   Assert.hasText(beanName, "Bean name must not be empty");
   Assert.notNull(beanDefinition, "BeanDefinition must not be null");

   if (beanDefinition instanceof AbstractBeanDefinition) {
      try {
         ((AbstractBeanDefinition) beanDefinition).validate();
      }
      catch (BeanDefinitionValidationException ex) {
         throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
               "Validation of bean definition failed", ex);
      }
   }

   BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
   if (existingDefinition != null) {
      if (!isAllowBeanDefinitionOverriding()) {
         throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
      }
      else if (existingDefinition.getRole() < beanDefinition.getRole()) {
         // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
         if (logger.isInfoEnabled()) {
            logger.info("Overriding user-defined bean definition for bean '" + beanName +
                  "' with a framework-generated bean definition: replacing [" +
                  existingDefinition + "] with [" + beanDefinition + "]");
         }
      }
      else if (!beanDefinition.equals(existingDefinition)) {
         if (logger.isDebugEnabled()) {
            logger.debug("Overriding bean definition for bean '" + beanName +
                  "' with a different definition: replacing [" + existingDefinition +
                  "] with [" + beanDefinition + "]");
         }
      }
      else {
         if (logger.isTraceEnabled()) {
            logger.trace("Overriding bean definition for bean '" + beanName +
                  "' with an equivalent definition: replacing [" + existingDefinition +
                  "] with [" + beanDefinition + "]");
         }
      }
      this.beanDefinitionMap.put(beanName, beanDefinition);
   }
   else {
      if (hasBeanCreationStarted()) {
         // Cannot modify startup-time collection elements anymore (for stable iteration)
         synchronized (this.beanDefinitionMap) {
            this.beanDefinitionMap.put(beanName, beanDefinition);
            List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
            updatedDefinitions.addAll(this.beanDefinitionNames);
            updatedDefinitions.add(beanName);
            this.beanDefinitionNames = updatedDefinitions;
            removeManualSingletonName(beanName);
         }
      }
      else {
         // Still in startup registration phase
         this.beanDefinitionMap.put(beanName, beanDefinition);
         this.beanDefinitionNames.add(beanName);
         removeManualSingletonName(beanName);
      }
      this.frozenBeanDefinitionNames = null;
   }

   if (existingDefinition != null || containsSingleton(beanName)) {
      resetBeanDefinition(beanName);
   }
}

完成了BeanDefinition注册,那么就完成了IoC容器的初始化过程。意味着IoC容器已经建立了整个Bean的配置信息。而且BeanDefinition就可以通过beanDefinitionMap被获取和使用。

(不过需要注意的是,这里只是IoC容器的初始化过程,并不包含Bean依赖注入的实现。在Spring IoC设计中,Bean定义的依赖注入方式和IoC依赖注入是两个独立过程。IoC容器的依赖注入通常发生在getBean向容器索取Bean的时候。)

至此这些信息就成了容器建立依赖反转的基础。

Spring的扩展性

那么就到了IoC实例化Bean,然后使用对象,最后销毁对象的过程。

但实际上Spring框架强大的地方还在于它的扩展性,所以Spring在这整个制造Bean的过程中加入许多的扩展点,而正是这些扩展点让我们可以即操作Spring也可以在这基础上去做更多的自定义操作(可以说是为所欲为)。

Spring的扩展点:BeanFactoryPostProcessor

BeanFactoryPostProcessor接口是Spring初始化BeanFactory时对外暴露的扩展点。调用BeanFactoryPostProcess方法时,Bean刚被解析成 BeanDefinition对象,所以bean还没有实例化,就可以在bean实例化之前通过BeanFactoryPostProcessor读取配置元数据,并可以根据需要进行修改。

BeanFactoryPostProcessor是对实例之前的任何Bean之前对其进行更改。

实例化Bean

直到经过BeanFactoryPostProcessor,才终于到了我们的实例化Bean。而通常框架在实例化时并不会使用new的方式,而是使用更灵活的反射。

而反射的具体实现,我们也相当熟悉。

//获取Class对象
Class.forName("bean");
//获取构造器
getDeclareConstructor();
//创建对象
newInstance();

到了实例化后,就是到了真正对象的使用,最后销毁过程。

但是在这个过程中还有跟应用相关的许多固定工作,如建立数据库的连接,网络的连接等等。同时等到最后程序结束时相应的要销毁这些固定的工作来释放资源。

IoC容器中的Bean生命周期

所以Spring的IoC容器制定了Bean从实例化到销毁的过程。Bean容器的实现过程就是IoC管理的Bean的生命周期。

Bean的生命周期如下:

  • 实例化Bean。
  • 设置Bean实例属性。
  • 调用Bean初始化方法。
  • 应用通过IoC容器使用Bean。
  • 容器关闭时的Bean销毁。

实际上在对Bean设置完属性后,已经差不多可以使用了,但是在Bean初始化方法的前后还有Bean的前置和后置处理器扩展点。

BeanPostProcessor:AOP的关键

BeanPostProcessor后置处理器有两个方法,一个是BeanPostProcessor:before,另一个是BeanPostProcessor:after分别用于前后执行。BeanPostProcessor跟前面的BeanFactoryProcessor一样是Spring留给我们的扩展点。但是不同是BeanFactoryProcessor是对Bean实例化之前的扩展。而BeanPostProcessor是对Bean实例化之后的扩展。

但你发现这些扩展点的特性跟AOP(面向切面)的代理很相似。e而实际上BeanPostProcessor后置处理器就是AOP实现的关键。

我们可以从继承BeanPostProcessor接口的AbstractAutoProxyCreator抽象类里找到postProcessBeforeInstantiation后置处理器的createProxy()方法,而在此方法中找到调用了关键的代码getProxy()方法,而这个方法定义自AopProxy接口。

AOP中的JDK和cglib动态代理都是继承AopProxy。

在AopProxy接口的上方注释是这样描述的。

Delegate interface for a configured AOP proxy, allowing for the creation of actual proxy objects.

用于配置的AOP代理的委托接口,允许创建实际的代理对象。

所以当你再回过头看Spring,都是由IoC所主导的,纵使Spring的核心还有AOP,但AOP是以IoC来作为基础的。AOP也只不过是IoC中的分支,而IoC才是树的主干。

最后

或许会如梦初醒,再问Spring为什么要用IOC?

从一开始改变了我们编程的方式,即符合人类永不停息追求效率以及更方便(懒),也符合软件工程永远追求的目标,降低系统之间、模块之间和对象之间的耦合度。包括了在扩展性方面提供让整个Spring生态万物生长的扩展点。

可以说Spring改变了你以IoC的方式开发的同时,你的代码也交由了Spring进行管理。

最后的最后,

如果纯粹盲目的去看Spring源码,你对Spring的知识就是一块一块的碎片,既不系统,也不结构化,更别说融会贯通了。你会觉得自己需要好好地梳理脉络,系统地掌握知识。你的这种感觉一定很强烈吧。所以记住IoC思想是Spring的支点,而源码本身只不过是解决问题的细节而已。不要为了捡芝麻,而丢了整个西瓜。

14、OpenClaw(龙虾助手)Skill 开发完整规范(2026最新版) OpenClaw Skill 开发指南摘要: Skill 是 OpenClaw AI 助手的核心扩展机制,支持声明式(SKILL.md)和原生代码(JS/TS/Python)两种开发模式。声明式 Skill 通过 Markdown 定义触发条件和执行流程,适合简单业务;原生代码 Skill 提供完整编程能力,适合复杂场景。开发需遵循标准化项目结构,包含 SKILL.md(元数据)、manifest.json(权限声明)等文件,并严格处理错误和多系统适配。新版要求原生 Skill 必须声明文件、网络等权限,确 阅读详情

相关推荐

手把手教你用Cesium和RayMarching实现逼真体积云(附完整Shader代码)

本文详细介绍了如何利用Cesium和RayMarching技术实现逼真的体积云效果,包括环境准备、核心逻辑、云层建模和光照增强等关键步骤,并提供了完整的Shader代码。通过噪声函数选型、动态风场模拟和多重散射近似等技术,开发者可以在数字地球可视化项目中创建沉浸式天气效果,显著提升场景的真实感。

weixin_29230649的博客 419

MyBatisFlex多项查询结果

weixin_61746525的博客 456

python数据分析与可视化

Python数据分析主要包括数据清洗、数据探索和数据可视化三个部分。数据清洗是数据分析的重要环节,主要是对数据进行预处理,包括缺失值处理、异常值处理、数据类型转换等。数据探索则是通过对数据进行初步分析,了解数据的分布和特征,为后续的数据分析提供基础。数据可视化则是将数据以图形化的方式呈现,帮助人们更好地理解和分析数据。

2301_82032652的博客 7718

从Spring为什么要用IoC的支点,我撬动了整个Spring的源码脉络

纯粹盲目的去看Spring源码,你对Spring的知识就是一块一块的碎片,既不系统,也不结构化,更别说融会贯通了。你会觉得自己需要好好地梳理脉络,系统地掌握知识。你的这种感觉一定很强烈吧。源码本身只不过是解决问题的细节而已,而IoC思想才是主导Spring脉络的支点。不要为了捡芝麻,而丢了西瓜。...

YYniannian的博客 191

有限元缺陷:剪切锁死

有限元缺陷:剪切锁死

wsxww11的博客 5191

初识机会网络仿真器ONE中ExternalMovement移动模型(导入外部移动数据)

最近半个月一直在研究ONE中关于ExternalMovement移动模型的源代码,在网上几乎没有找到相关的资料,很是苦恼,如果有共同研究方向的小伙伴欢迎联系我,共同讨论进步。 下面记录一下几点感悟: 1、使用外部数据的前提是在ONE的配置文件中增加及修改相关代码: Group.movementModel = ExternalMovement ExternalMovement.file = move...

qq_36974792的博客 661

从源码看Spring如何解决循环依赖的脉络?鸡生蛋与蛋生鸡的问题!

当我从《从Spring为什么要用IoC的支点,我撬动了整个Spring的源码脉络!》走过来,再来看Spring中源码的各种细节是如此的舒畅。所以让我们接着剑指Spring源码。Spring为了解决单例的循环依赖问题,首先会定义三级缓存做准备(你会发现很多缓存都是用key-value的方式,Spring也如此,同样用了三个Map)。三个Map就定义在DefaultSingletonBeanRegistry类中。(现在可能对为什么要定义三级缓存感到陌生,但是别急,后面相信你会无比熟悉)...

m0_71777195的博客 203

【RV1126/RV1109学习笔记】#基础篇#(2)基础入门使用

一、调试方式 1、串口调试 2、ADB调试 3、网络调试 二、基础外设使用 音频使用(aplay,arecord,amixer) 三、WIFI连接 四、屏幕背光控制

丨晋丨 1868

【源码】Spring IOC源码

Spring源码分析以及如何阅读源码

m0_46179147的博客 157

基于截图详解:SAP GUI for Java 如何设置登录链接,以及 conn= 连接字符串该怎么写

摘要:SAP GUI for Java 的连接属性配置关键是在"高级"页签的"conn="后填写连接字符串。连接字符串格式取决于网络拓扑:直连应用服务器使用"/H/主机/S/端口";通过消息服务器负载均衡使用"/M/消息服务器/S/端口/G/组名";经SAProuter访问则需添加路由器前缀。配置时需注意专家模式会覆盖其他页签设置,且连接字符串还支持附加参数如客户端、语言和默认事务码。具体填写内容应根据Basis团队提供的系统信

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 252

DeepQA: A Unified Transcriptome-Based Aging Clock Using Deep Neural Networks

摘要: 本研究针对转录组衰老时钟存在的关键局限——仅在健康样本训练导致对患病个体预测偏差的问题,提出DeepQA,一种基于专家混合架构与新型Hinge-MAE损失函数的深度学习模型。通过同时利用健康与患病个体的异质数据训练,DeepQA显著提升预测精度:在健康个体上MAE比现有方法低1.5年,且是首个能正确处理五类疾病条件的模型。其创新性体现在: 方法学突破:Hinge-MAE损失函数消除健康/患病样本的训练偏差,专家混合架构高效整合多队列数据; 流程革新:摒弃传统基因预筛选步骤,通过显著图分析直接识别衰老

qq_44050612的博客 125

从源码看Spring如何解决循环依赖的脉络?鸡生蛋与蛋生鸡的问题

当我从《从Spring为什么要用IoC的支点,我撬动了整个Spring的源码脉络!》走过来,再来看Spring中源码的各种细节是如此的舒畅。所以让我们接着剑指Spring源码。Spring为了解决单例的循环依赖问题,首先会定义三级缓存做准备(你会发现很多缓存都是用key-value的方式,Spring也如此,同样用了三个Map)。三个Map就定义在DefaultSingletonBeanRegistry类中。(现在可能对为什么要定义三级缓存感到陌生,但是别急,后面相信你会无比熟悉)//省略其他。...

m0_67322837的博客 135

GEE:关于遥感生态指数(RSEI)的若干疑问

本文记录了若干关于在 Google Earth Engine (GEE)平台上,计算基于主成分分析(PCA)的遥感生态指数(RSEI)的问题。并记录了解决这些问题的一些答案。问题包括,主成分分析的特征值的正负,主成分的占比,去云后空值像素的处理方法,异常值处理方法,如何看载荷等。

养乐多的博客 3419

第三篇 第 6 课

前置:第三篇第 1 课(stdx 引入),第二篇第 1 课(std.regex)。环境:仓颉 SDK 1.2.0。本文所有代码与输出均逐行实测。

weixin_41618057的博客 557

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

MCP 2026-07-28 无状态协议大改版:Spring AI 2.1 多轮往返请求与网关路由落地

无状态,所以任何实例都能处理任何请求,扩容不再需要粘性会话;显式句柄,所以跨调用状态是可审计、可过期的,而不是藏在进程内存里;幂等重放,所以交互式中断在分布式环境下也可恢复,代价是你要自己保证副作用可对账;头部路由,所以网关能在不解析 body 的前提下做治理,而校验 header/body 一致性成了新的安全底线。这些没有一个是在发明新概念。它们是分布式系统里被验证过二十年的老手艺:无状态、显式上下文、幂等、网关治理、fail-fast、可观测。

qq_36021478的博客 185

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

压缩省了60%磁盘,写入TPS掉了25%——InnoDB页压缩的三类隐性代价与适用边界

InnoDB页压缩能显著降低表空间占用,但磁盘的节省不是免费的。压缩页在写入时需要CPU执行压缩算法、读取时需要CPU解压;压缩后的页在Buffer Pool中占用更少空间,但命中后的解压开销和未命中时的解压延迟会改变缓存的实际效能;写密集场景下,压缩/解压带来的写入放大可能让TPS明显下降。本文拆解InnoDB页压缩的物理机制、三类隐性代价的量化表现,以及“什么场景该用、什么场景该绕开”的判断框架。

DBAxiaoye的博客 342

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

实际工程问题:AI 生成 Spring Cache(@Cacheable / @CachePut / @CacheEvict)缓存注解踩坑

商品详情服务,要求:商品基础信息走缓存,减少 DB 查询;典型:AI 只贴注解,忽略 AOP 代理、key 设计、缓存穿透/击穿/过期、序列化、同步刷新,本地单测正常,上线后缓存脏数据、命中率异常、雪崩。如果业务在事务中,@CacheEvict / @CachePut 如果在事务提交前执行,一旦事务回滚,缓存已经被删掉/更新,数据不一致。• 如果在同一个类里用 this.xxx() 调用带缓存注解的方法,不走代理,缓存直接失效;// 更新商品:先更新 DB,再删除缓存,而不是直接 @CachePut。

2401_89363342的博客 492

Spring 事务详解:@Transactional 如何生效、何时回滚、传播行为怎么选

从订单与库存写入出发,拆解 @Transactional 的代理调用链、默认回滚规则与自调用问题;通过 Spring Boot + H2 的五个验证用例比较 REQUIRED、REQUIRES_NEW、NESTED,并说明数据库事务与 Redis、消息和远程接口的边界。

qq_74421990的博客 335

Spring IoC 控制反转 完整技术笔记

Spring 框架的两大核心能力为IoC(控制反转)与AOP(面向切面编程)IoC:底层基于工厂模式实现,负责对象的创建、属性赋值与生命周期管理,是 Spring 框架的核心基础AOP:底层基于代理模式实现,用于实现横向功能的统一增强。

2401_87069538的博客 311

模型“看不见”中间的东西——prompt cache 与 Zone 分区

本文揭示了LLM系统中promptcache失效的根源:动态内容错置于系统提示词前缀,导致缓存命中率从80%骤降至4%。核心教训是“变化内容必须排在最后”——通过Zone分区(ZoneA稳定区、ZoneB动态区),将每轮可能变化的内容移至末尾,可确保前缀稳定,恢复高命中率。关键在于:前缀匹配要求逐字节相同,任何一处变动即导致后续全部失效。修复建议包括:重构提示词结构、正确分类内容、监控缓存单位(字节与token不可混用)、避免压缩破坏前缀。最终实现成本降低9倍,提升推理效率。

qinglongcn的博客 224

SpringBoot 新闻推荐系统:88个Java文件105个接口,首页推荐位是后端按点击数排出来的

# SpringBoot 新闻推荐系统:88个Java文件105个接口,首页推荐位是后端按点击数排出来的 > 这是一套基于 Spring Boot 的新闻推荐系统源码,配套 `db.sql` 建表脚本,业务覆盖新闻发布、排行榜管理、评论回复、点赞点踩、收藏夹和轮播图配置。形态是**前后台双端**:前台是读者用的 layui 静态站,后台是管理员用的 Vue 单页应用(编译产物已嵌在工程里)。最值

面朝大海 881

Spring Framework 7 HTTP Interface 实战:声明式 RestClient、超时与测试

Spring Framework 7 中,Java 开发者如何使用 HTTP Interface 管理外部服务调用?本文从传统 RestClient 出发,介绍 @HttpExchange、`@GetExchange`、`RestClientAdapter` 和 HttpServiceProxyFactory 的使用方式,并结合商品服务案例说明客户端配置、超时控制、异常处理及 Mock 测试。最后讨论从 RestTemplate、Feign 迁移时的技术取舍,帮助开发者建立更清晰的 HTTP 客户端架构。

代码不止,探索不息 257

【从零理解 Spring AI · 12】MCP 的两种角色:做客户端还是做服务端

上一篇讲了 MCP 的概念:标准协议、三大角色、M+N 替代 M×N。

nice_lcj520的博客 612

【Spring AI】Tool Calling 入门与实践

本文介绍Spring AI中工具调用(Tool Calling)机制,通过@Tool注解定义可被模型调用的Java方法,实现模型与应用能力的协同。核心在于模型生成结构化调用请求,由应用执行真实逻辑并返回结果,确保安全可控。文章以查询时区时间为例,演示了工具注册、参数Schema、回调执行及异常处理等关键环节,并对比了三种注册方式:直接对象传递、MethodToolCallbackProvider统一管理与编程式构建,适用于不同场景下的灵活集成。

REGARD712的博客 400

Spring AI开发从入门到实践-什么是Spring AI

《Spring AI开发从入门到实践》是面向Java开发者的企业级AI应用指南,基于Spring生态构建,实现LLM、向量库、智能体等技术的低门槛集成。书中以“不造模型,只做连接”为核心,通过统一API屏蔽厂商差异,原生支持自动配置、可观测性等工程能力,解决AI从Demo到生产落地的痛点。全书分五部分,覆盖环境搭建、核心组件、实战应用、生产优化与前沿探索,配套可运行代码,助力开发者无缝将AI融入现有系统,真正实现企业级落地。

老卫的技术站 152
上一篇: 后端接口性能差,该从哪些方面进行优化?
下一篇: 从Architecture带你认识JVM
Java技术那些事儿
博客等级 码龄5年 2306粉丝 2584原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值