Spring实例化源码解析之ConfigurationClassParser(三)

news2024/12/24 21:13:42

前言

上一章我们分析了ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法的源码逻辑，其中核心逻辑do while中调用parser.parse(candidates)方法，解析candidates中的候选配置类。然后本章我们主要分析ConfigurationClassParser的parse方法到底做了什么。

parse

configCandidates在项目启动的时候只有我们的AopConfig类，也就是说这个parse方法其实就是解析启动类。

在这里插入图片描述

public void parse(Set<BeanDefinitionHolder> configCandidates) {
		for (BeanDefinitionHolder holder : configCandidates) {
			BeanDefinition bd = holder.getBeanDefinition();
			try {
				if (bd instanceof AnnotatedBeanDefinition) {
					parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
				}
				else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
					parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
				}
				else {
					parse(bd.getBeanClassName(), holder.getBeanName());
				}
			}
			catch (BeanDefinitionStoreException ex) {
				throw ex;
			}
			catch (Throwable ex) {
				throw new BeanDefinitionStoreException(
						"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
			}
		}

		this.deferredImportSelectorHandler.process();
	}

当前我的启动类是AopConfig，属于AnnotatedBeanDefinition，会进入到第一个if逻辑里。parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());第一个参数传入的元数据，第二个参数传入的是beanName。

private static final Predicate<String> DEFAULT_EXCLUSION_FILTER = className ->
			(className.startsWith("java.lang.annotation.") || className.startsWith("org.springframework.stereotype."));

protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
		processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
	}

processConfigurationClass方法传递了一个ConfigurationClass和一个Predicate，Predicate就是为了判断ClassName的，ConfigurationClass包含了元数据、beanName等信息。

processConfigurationClass

进入方法的第一个if用于判断是否包含@Condition注解，反正含义就是看这个候选配置类需不需要跳过，里面的其他逻辑就不关注了。下面其实就是核心逻辑了，我们继续拆解分析。

protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
		if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
			return;
		}
		// 查看这个配置类是不是存在了，如果存在就走下面的if逻辑
		ConfigurationClass existingClass = this.configurationClasses.get(configClass);
		if (existingClass != null) {
			if (configClass.isImported()) {
				if (existingClass.isImported()) {
					existingClass.mergeImportedBy(configClass);
				}
				// Otherwise ignore new imported config class; existing non-imported class overrides it.
				return;
			}
			else {
				// Explicit bean definition found, probably replacing an import.
				// Let's remove the old one and go with the new one.
				this.configurationClasses.remove(configClass);
				this.knownSuperclasses.values().removeIf(configClass::equals);
			}
		}

		// Recursively process the configuration class and its superclass hierarchy.
		SourceClass sourceClass = asSourceClass(configClass, filter);

		// 此处使用了个do while
		do {
			// 查看源码就是习惯性的查看do something开头的，至少spring是这样的一个习惯。
			sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
		}
		while (sourceClass != null);

    	// 解析完了放入configurationClasses
		this.configurationClasses.put(configClass, configClass);
	}

existingClass是看配置类是不是已经解析过了，为什么启动的时候要判断是否存在，原因就是因为底下有个do while循环。这个方法后续会调用很多次。如果不存在会走底下的do while逻辑，就是本章的核心内容。这里会很绕，我尽量讲清楚。

SourceClass sourceClass = asSourceClass(configClass, filter);还是可以单独拿出来描述一下:

方法的参数包括一个可为null的className和一个Predicate<String>类型的filter，还可能抛出IOException异常。

方法的执行逻辑如下：

1、首先，检查className是否为null或者经过filter筛选后返回true。如果是这种情况，直接返回预先设定的objectSourceClass对象。

2、如果className以"java"开头，表示该类是核心Java类型，将不使用ASM（Java字节码操作库）进行处理。此时，尝试加载该类，并使用ClassUtils.forName方法获取类的Class对象。如果加载失败，将抛出ClassNotFoundException异常并包装为NestedIOException。

3、如果以上条件都不满足，说明className表示的类不是核心Java类型，那么使用metadataReaderFactory（可能是一个元数据读取工厂）获取className对应的元数据读取器（MetadataReader），并将其传递给SourceClass的构造函数，创建一个新的SourceClass对象。

doProcessConfigurationClass

首先我的AopConfig有两个注解，@EnableAspectJAutoProxy和@ComponentScan(value = {“com.qhyu.cloud.**”})，当然我们的springboot项目一般都是约定大于配置的方式，不写这个ComponentScan注解。

在这里插入图片描述

下面是整个方法的源码和我的个人注释信息，我们这边还是先将源码整体放出来，然后再拆解分析。

protected final SourceClass doProcessConfigurationClass(
			ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
			throws IOException {

		// 如果这个候选配置类中有Component注解，走下面的逻辑
		if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
			// Recursively process any member (nested) classes first
			processMemberClasses(configClass, sourceClass, filter);
		}

		// Process any @PropertySource annotations
		for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), PropertySources.class,
				org.springframework.context.annotation.PropertySource.class)) {
			if (this.environment instanceof ConfigurableEnvironment) {
				processPropertySource(propertySource);
			}
			else {
				logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
						"]. Reason: Environment must implement ConfigurableEnvironment");
			}
		}

		// Process any @ComponentScan annotations
		// 我们的AopConfig候选配置类就会走到下面这个逻辑
		Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
		// componentScans不为空，第一个条件满足
		// sourceClass.getMetadata()不为null；通过Conditional注解来控制bean是否需要注册，控制被@Configuration标注的配置类是否需要被解析 第二个条件false，取反。
		if (!componentScans.isEmpty() &&
				!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
			for (AnnotationAttributes componentScan : componentScans) {
				// The config class is annotated with @ComponentScan -> perform the scan immediately
				// 使用this.componentScanParser ComponentScanAnnotationParser来解析
				// 这里面将会注册我们自己写的一些将被spring接管的类的BeanDefinition信息
				Set<BeanDefinitionHolder> scannedBeanDefinitions =
						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
				// Check the set of scanned definitions for any further config classes and parse recursively if needed
				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
					if (bdCand == null) {
						bdCand = holder.getBeanDefinition();
					}
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
						parse(bdCand.getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}

		// Process any @Import annotations
		processImports(configClass, sourceClass, getImports(sourceClass), filter, true);

		// Process any @ImportResource annotations
		AnnotationAttributes importResource =
				AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
		if (importResource != null) {
			String[] resources = importResource.getStringArray("locations");
			Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
			for (String resource : resources) {
				String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
				configClass.addImportedResource(resolvedResource, readerClass);
			}
		}

		// Process individual @Bean methods
		Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
		for (MethodMetadata methodMetadata : beanMethods) {
			configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
		}

		// Process default methods on interfaces
		processInterfaces(configClass, sourceClass);

		// Process superclass, if any
		if (sourceClass.getMetadata().hasSuperClass()) {
			String superclass = sourceClass.getMetadata().getSuperClassName();
			if (superclass != null && !superclass.startsWith("java") &&
					!this.knownSuperclasses.containsKey(superclass)) {
				this.knownSuperclasses.put(superclass, configClass);
				// Superclass found, return its annotation metadata and recurse
				return sourceClass.getSuperClass();
			}
		}

		// No superclass -> processing is complete
		return null;
	}
片段一
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
			// Recursively process any member (nested) classes first
			processMemberClasses(configClass, sourceClass, filter);
		}

当前AopConfig启动类是没有Component注解的，不会进入这个逻辑。代码中的英文注释说的是首先递归处理任何成员（嵌套）类，也就是说如果@Component注解注释的类中没有内部类（嵌套类）也不会做任何处理。

片段二
// Process any @PropertySource annotations
		for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), PropertySources.class,
				org.springframework.context.annotation.PropertySource.class)) {
			if (this.environment instanceof ConfigurableEnvironment) {
				processPropertySource(propertySource);
			}
			else {
				logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
						"]. Reason: Environment must implement ConfigurableEnvironment");
			}
		}

直接看注释，处理任何被@PropertySource注解修饰的class

片段三
// Process any @ComponentScan annotations
		// 我们的AopConfig候选配置类就会走到下面这个逻辑
		Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
		// componentScans不为空，第一个条件满足
		// sourceClass.getMetadata()不为null；通过Conditional注解来控制bean是否需要注册，控制被@Configuration标注的配置类是否需要被解析 第二个条件false，取反。
		if (!componentScans.isEmpty() &&
				!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
			for (AnnotationAttributes componentScan : componentScans) {
				// The config class is annotated with @ComponentScan -> perform the scan immediately
				// 使用this.componentScanParser ComponentScanAnnotationParser来解析
				// 这里面将会注册我们自己写的一些将被spring接管的类的BeanDefinition信息
				Set<BeanDefinitionHolder> scannedBeanDefinitions =
						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
				// Check the set of scanned definitions for any further config classes and parse recursively if needed
				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
					if (bdCand == null) {
						bdCand = holder.getBeanDefinition();
					}
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
						parse(bdCand.getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}

处理任何被@ComponentScan注解修时的类，当然这里还包括@ComponentScans注解，componentScans属性会获取到注解的信息，如下图所示：

在这里插入图片描述

if (!componentScans.isEmpty() &&
				!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN))

首先componentScans属性肯定不为空，所以第一个条件是ture，然后看是否应该跳过，当前AopConfig不存在Condition注解，返回false，此处取反，所以if条件返回true，进入if逻辑。

for (AnnotationAttributes componentScan : componentScans) {
				// The config class is annotated with @ComponentScan -> perform the scan immediately
				// 使用this.componentScanParser ComponentScanAnnotationParser来解析
				// 这里面将会注册我们自己写的一些将被spring接管的类的BeanDefinition信息
				Set<BeanDefinitionHolder> scannedBeanDefinitions =
						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
				// Check the set of scanned definitions for any further config classes and parse recursively if needed
				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
					if (bdCand == null) {
						bdCand = holder.getBeanDefinition();
					}
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
						parse(bdCand.getBeanClassName(), holder.getBeanName());
					}
				}
			}

这个循环，获取的AnnotaionAttributes就是我们的@ComponentScan(value = {“com.qhyu.cloud.**”})注解的信息。然后会调用使用this.componentScanParser ComponentScanAnnotationParser来解析，主要就是扫描我们定义的路径下的所有需要被Spring管理的bean，组装程BeanDefinitionHolder返回到scannedBeanDefinitions集合，同时这些bean的定义信息会被注入到bean工厂中，本章在此处不会深入的去分析里面的源码，将在下一章节进行分析。

在这里插入图片描述

if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
						parse(bdCand.getBeanClassName(), holder.getBeanName());
					}

这段源码在之前已经分析过了，第二章节，如果发现我们scannedBeanDefinitions中还存在配置类，就继续解析，也就是把这些beanDefinition都注册到bean工厂中。
如果不是配置类或者处理完了配置类之后会继续往下走他的逻辑。

片段四

处理被@Import注解修时的类

processImports(configClass, sourceClass, getImports(sourceClass), filter, true);

比如我们的AopConfig不是有个@EnableAspectJAutoProxy注解嘛，这个注解里面会有个@Import，所以AopConfig解析之后会执行configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());代码，在ConfigurationClassPostProcessor的processConfigBeanDefinitions方法中this.reader.loadBeanDefinitions(configClasses);这行代码会读取出来进行注册。

在这里插入图片描述

片段五

处理任何@ImportResource annotations

// Process any @ImportResource annotations
AnnotationAttributes importResource =
       AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
if (importResource != null) {
    String[] resources = importResource.getStringArray("locations");
    Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
    for (String resource : resources) {
       String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
       configClass.addImportedResource(resolvedResource, readerClass);
    }
}
片段六

处理各个@Bean的方法

// Process individual @Bean methods
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
		for (MethodMetadata methodMetadata : beanMethods) {
			configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
		}
片段七

处理接口上的默认方法

processInterfaces(configClass, sourceClass);
片段八

处理superclass，超类，如果有的话。可以发现这里面有个return，其他的片段都是返回的void，此处如果返回的话，外部的do while就会继续执行。

if (sourceClass.getMetadata().hasSuperClass()) {
    String superclass = sourceClass.getMetadata().getSuperClassName();
    if (superclass != null && !superclass.startsWith("java") &&
          !this.knownSuperclasses.containsKey(superclass)) {
       this.knownSuperclasses.put(superclass, configClass);
       // Superclass found, return its annotation metadata and recurse
       return sourceClass.getSuperClass();
    }
}

在这里插入图片描述

整理流程梳理

方法的执行逻辑如下：

  • 首先，检查配置类 configClass 是否被 @Component 注解标记。如果是，则递归处理任何成员类（嵌套类）。

  • 处理任何 @PropertySource 注解。遍历配置类中的 @PropertySource 注解，如果当前环境实现了 ConfigurableEnvironment 接口，则进行属性源的处理。否则，记录日志，表明忽略该注解。

  • 处理任何 @ComponentScan 注解。获取配置类中的 @ComponentScan 注解，如果存在且满足相关条件（componentScans 不为空，且配置类满足条件判断），则使用 componentScanParser 来解析注解，执行组件扫描操作，并注册相应的 BeanDefinition 信息。如果扫描到的定义中包含其他配置类，则递归解析这些配置类。

  • 处理任何 @Import 注解。根据配置类中的 @Import 注解，获取需要导入的类，并进行处理。这些导入的类可以是其他配置类，也可以是其他普通的类。处理过程中，可能会继续递归解析导入的类。

  • 处理任何 @ImportResource 注解。根据配置类中的 @ImportResource 注解，获取资源的位置和读取器类型，并进行处理。通常，这些资源是 XML 配置文件。解析过程中，可能会使用 BeanDefinitionReader 来读取并注册相关的 BeanDefinition。

  • 处理配置类中的每个 @Bean 方法。获取配置类中所有的 @Bean 方法的元数据，并将其添加到 configClass 对象中。

  • 处理接口的默认方法。如果配置类实现了接口，并且接口中定义了默认方法，则对这些默认方法进行处理。

  • 处理父类（如果存在）。如果配置类有父类，并且父类不是 Java 核心类，也不在已知的父类列表中，则将父类添加到已知的父类列表中，并返回父类的注解元数据，以便进行递归处理。

  • 如果没有父类，则处理完成，返回 null。

总结

本章主要分析了ConfigurationClassParser的parse方法的源码，其中设计到的ComponentScanAnnotationParser的parse方法我们没有深入分析，这里面涉及到的是将我们启动类目录或者@ComponentScan注解的basePackages目录下的我们需要交给容器管理的bean的定义信息注册将在下一章进行分析。

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

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

相关文章

linux服务器部署项目

linux服务器部署项目

1.linux安装配置JDK 以Java1.8为例&#xff0c;下载安装包 将安装包提交到服务器中并解压 tar -zxvf your_file.gz 修改/etc/profile文件 vi /etc/profile 文件中添加两条 export JAVA_HOME/path/to/your/java export PATH$JAVA_HOME/bin:$PATH 输入指令刷新文件 source /etc…
阅读更多...
Python150题day08

Python150题day08

2.基础语法篇 2.1 if 条件句 ①单个条件分支 使用input函数接收用户的输入&#xff0c;如果用户输入的整数是偶数&#xff0c;则使用print函数输出"你输入的整数是:{value],它是偶数”&#xff0c;[value]部分要替换成用户的输入。 解答: value input("请输⼊⼀…
阅读更多...
java 阿里云上传照片

java 阿里云上传照片

获取对象 Resourceprivate ALiYunConfig aLiYunConfig;代码配置类 import lombok.Data; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.Component;/*** 描述:** author zhaofeng* date 2023-09-05*/ D…
阅读更多...
数字孪生技术如何提升工厂生产效率？

数字孪生技术如何提升工厂生产效率？

数字孪生技术是一项引领工业界数字化转型的创新力量。随着工业4.0时代的到来&#xff0c;制造业正经历着巨大的变革&#xff0c;数字孪生技术在这个变革中发挥了关键作用。它不仅仅是一种技术&#xff0c;更是一种理念&#xff0c;将现实世界与数字世界相结合&#xff0c;为工厂…
阅读更多...
2022年3月13日安装和启动ActiveMQ遇到问题

2022年3月13日安装和启动ActiveMQ遇到问题

今天我学习了一天周阳老师的ActiveMQ课程&#xff0c;讲的还不错&#xff0c;但是&#xff0c;碰到一个问题就是&#xff1a; 我Linux里可以通过 http://IP地址:8161/访问到ActiveMQ的一个界面&#xff0c;并且能够登录成功&#xff0c;但是呢&#xff0c;windows里面无法访问到…
阅读更多...
python 串口发送图片给arduino

python 串口发送图片给arduino

python 代码 import serial import threading import time from PIL import Image from PIL import ImageSequence## im.show()##print(img) ## ####img b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00…
阅读更多...
单例模式有几种写法？

单例模式有几种写法？

作者&#xff1a;猴子007 选自&#xff1a;https://monkeysayhi.github.io “你知道茴香豆的‘茴’字有几种写法吗&#xff1f;” 纠结单例模式有几种写法有用吗&#xff1f;有点用&#xff0c;面试中经常选择其中一种或几种写法作为话头&#xff0c;考查设计模式和coding styl…
阅读更多...
springboot2.7.15+thymeleaf

springboot2.7.15+thymeleaf

如下使用了thymeleaf的基础应用&#xff1a;th:text, th:each, th:if, th:unless, th:value等标签的使用 页面效果&#xff1a;未登录状态 登录状态&#xff1a; 如下的所有html放在templates 下&#xff0c; 配置文件不需要做任何配置 只需要在pom.xml中增加 <dependen…
阅读更多...
记一次 .NET 某仪器测量系统 CPU爆高分析

记一次 .NET 某仪器测量系统 CPU爆高分析

一&#xff1a;背景 1. 讲故事 最近也挺奇怪&#xff0c;看到了两起 CPU 爆高的案例&#xff0c;且诱因也是一致的&#xff0c;觉得有一些代表性&#xff0c;合并分享出来帮助大家来避坑吧&#xff0c;闲话不多说&#xff0c;直接上 windbg 分析。 二&#xff1a;WinDbg 分析…
阅读更多...
【ODPS新品发布第2期】实时数仓Hologres：推出计算组实例/支持JSON数据/向量计算+大模型等新能力

【ODPS新品发布第2期】实时数仓Hologres：推出计算组实例/支持JSON数据/向量计算+大模型等新能力

阿里云ODPS系列产品以MaxCompute、DataWorks、Hologres为核心&#xff0c;致力于解决用户多元化数据的计算需求问题&#xff0c;实现存储、调度、元数据管理上的一体化架构融合&#xff0c;支撑交通、金融、科研、等多场景数据的高效处理&#xff0c;是目前国内最早自研、应用最…
阅读更多...
七、定时器类的编写与解析 —— TinyWebServer

七、定时器类的编写与解析 —— TinyWebServer

定时器类的编写与解析 —— TinyWebServer 一、前言 定时器非常好写。就是链表加定时函数。搞懂他的作用就成。 定时器的作用是什么&#xff1f;什么是回调函数&#xff1f;用到的函数是什么&#xff1f; 二、问题回答 Ⅰ、定时器的作用是什么&#xff1f; 处理非活跃的连…
阅读更多...
Mybatis自动映射Java对象 与 MySQL8后的JSON数据

Mybatis自动映射Java对象 与 MySQL8后的JSON数据

文章目录 Mybatis自动映射Java对象 与 MySQL8后的JSON数据1.转化成为正常Json类型1.1 JsonTypeHander1.2 ListJsonTypeHandler 负责List<T> 类型1.3 实体类1.4 mapper1.5 测试类 2. 存储为携带类型的Json Mybatis自动映射Java对象 与 MySQL8后的JSON数据 1.转化成为正常…
阅读更多...
OPTEE Ftrace函数跟踪

OPTEE Ftrace函数跟踪

安全之安全(security)博客目录导读 OPTEE调试技术汇总 目录 一、序言 二、Ftrace配置 三、Ftrace使用 四、Ftrace典型输出 一、序言 本节描述如何使用ftrace为TA生成函数调用图。该名称来自具有类似目的的Linux框架&#xff0c;但是OP-TEE ftrace非常具体…
阅读更多...
前端代码统计工具之cloc介绍

前端代码统计工具之cloc介绍

目录 一、安装 二 使用命令cloc path&#xff1a; 使用cloc工具可以很好的统计出前端的代码量&#xff0c;经过亲身实践真的很棒。 一、安装 安装命令 pnpm add cloc -g 二 使用命令cloc path&#xff1a; cloc ./ 如果报错&#xff1a; perl 不是内部或外部命令的问…
阅读更多...
风靡全国的真人猫抓老鼠是什么？

风靡全国的真人猫抓老鼠是什么？

某音上这个词条2.6亿&#xff0c;小某书上1.2亿。据说已经风靡全国50多个城市了。各大新闻网站和自媒体人争相报道&#xff0c;热度直接拉满&#xff01; 现在的年轻人真会玩&#xff01; 仔细了解过后发现&#xff0c;它火是有内在原因的&#xff0c;现在都市工作后没有可以…
阅读更多...
近年来国内室内定位领域硕士论文选题的现状与趋势

近年来国内室内定位领域硕士论文选题的现状与趋势

目录 一、前言 二、选题的目的和意义 三、选题现状分析 四、选题趋势分析 一、前言 本博文采用了图表统计法分析了近5年来100余篇高被引室内定位领域硕士论文选题的现状&#xff0c;并从选题现状中得出了该领域选题的大致趋势。本文还通过分析该领域硕士毕业论文选题的现…
阅读更多...
只需100GB内存，让Falcon 180B在你的电脑上起飞

只需100GB内存，让Falcon 180B在你的电脑上起飞

一、前言 自2023年5月&#xff0c;阿布扎比技术创新研究所&#xff08;TII&#xff09;发布了两个预训练的LLM&#xff1a;Falcon 7B和Falcon-40B&#xff0c;这两个模型的表现十分优异&#xff0c;在OpenLLM排行榜上高居榜首。然而&#xff0c;在短短不到几个月的时间&#x…
阅读更多...
Sftp服务安全评估

Sftp服务安全评估

1 认识SFTP FTP&#xff08;SSH文件传输协议&#xff09;和FTP&#xff08;文件传输协议&#xff09;是两种用于文件传输的协议&#xff0c;它们在工作原理、安全性和配置方面有很大的差异。 1&#xff09;工作原理&#xff1a; FTP&#xff1a;FTP使用两个独立的连接&#…
阅读更多...
【MySql】1- 基础篇(上)

【MySql】1- 基础篇(上)

文章目录 1.1 前言1.2 基础架构1.2.1 MySql基本架构示意图1.2.2 SQL语句执行顺序 1.3 日志系统&#xff1a;一条SQL更新语句如何执行1.3.1 两阶段提交 1.4 事务隔离1.4.1 隔离性与隔离级别1.4.2 事务隔离的实现-展开说明“可重复读”1.4.3 事务的启动方式 1.5 深入浅出索引1.5.…
阅读更多...
什么是实时操作系统（UCOS简介）

什么是实时操作系统（UCOS简介）

uC/OS-III官网&#xff1a;Home Page - Weston Embedded Solutions 一、裸机与RTOS介绍 下面我将从不同方面阐述裸机与试试操作系统的区别&#xff0c;从而进一步介绍裸机和实时操作系统 定义&#xff1a; 裸机&#xff1a;裸机指的是没有任何操作系统或软件层的硬件系统。在…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023