Springboot源码：自动装配流程解析

news2025/1/17 4:52:18

前言

前面在写业务框架后，由于项目依赖的Spring IOC，单将该项目install后，在其它项目引入时，会找不到所依赖的Bean。所以利用Springboot的自动转配，在项目启动时加载Bean，并注册到IOC容器中。

Springboot自动装配可以说是SpringBoot自己定义的SPI机制，SPI 的全名为 Service Provider Interface ，SPI 思想 也可以叫做 SPI机制 ，它就是为某个接口寻找服务实现的机制。

正文

项目启动时，会传入启动类的Class对象，在创建完容器后，会将该传入的启动类注册包装成BeanDeifinition后注册到BeanFactory中。

    public static void main(String[] args) {
        //这里传入启动类对象
        SpringApplication.run(BtestApplication.class, args);
    }

	public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		this.resourceLoader = resourceLoader;
		Assert.notNull(primarySources, "PrimarySources must not be null");
        //这里存放启动类传入的Class对象
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
		this.bootstrapRegistryInitializers = new ArrayList<>(
				getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		this.mainApplicationClass = deduceMainApplicationClass();
	}

BtestApplication.class 这个对象最终会被存入到primarySources属性集合中。

1：注册后置处理器

	public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		if (beanFactory != null) {
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
			}
		}

		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
		//注册ConfigurationClassPostProcessor 工厂后置处理器
		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}
		//注册AutowiredAnnotationBeanPostProcessor 工厂后置处理器，用于处理器@Autowire等
		if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		//注册AutowiredAnnotationBeanPostProcessor 工厂后置处理器，用于处理器@Resoruce注解等
		if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
		if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition();
			try {
				def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
						AnnotationConfigUtils.class.getClassLoader()));
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
			}
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
		}

		return beanDefs;
	}

在创建ConfigurableApplicationContext上下文对象时，会往容器中注册Spring内部处理器类，包括后面需要用到的BeanFactoryPostProcessor，跟自动装配相关的是ConfigurationClassPostProcessor后置处理器。

2：注册启动类

	private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
			ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments, Banner printedBanner) {
        //设置系统环境参数
		context.setEnvironment(environment);
		postProcessApplicationContext(context);
		applyInitializers(context);
		listeners.contextPrepared(context);
		bootstrapContext.close(context);
		if (this.logStartupInfo) {
			logStartupInfo(context.getParent() == null);
			logStartupProfileInfo(context);
		}
		// Add boot specific singleton beans
        //获取Bean工厂
		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
		beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
		if (printedBanner != null) {
			beanFactory.registerSingleton("springBootBanner", printedBanner);
		}
		if (beanFactory instanceof AbstractAutowireCapableBeanFactory) {
			((AbstractAutowireCapableBeanFactory) beanFactory).setAllowCircularReferences(this.allowCircularReferences);
			if (beanFactory instanceof DefaultListableBeanFactory) {
				((DefaultListableBeanFactory) beanFactory)
					.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
			}
		}
		if (this.lazyInitialization) {
			context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
		}
		context.addBeanFactoryPostProcessor(new PropertySourceOrderingBeanFactoryPostProcessor(context));
		// Load the sources
        //获取存放启动类Class对象的集合
		Set<Object> sources = getAllSources();
		Assert.notEmpty(sources, "Sources must not be empty");
        //将其注册到Bean工厂中
		load(context, sources.toArray(new Object[0]));
		listeners.contextLoaded(context);
	}

	public Set<Object> getAllSources() {
		Set<Object> allSources = new LinkedHashSet<>();
		if (!CollectionUtils.isEmpty(this.primarySources)) {
			allSources.addAll(this.primarySources);
		}
		if (!CollectionUtils.isEmpty(this.sources)) {
			allSources.addAll(this.sources);
		}
		return Collections.unmodifiableSet(allSources);
	}

在前面Spring将系统启动所传入的Class对象存入到了primarySources集合中，现将该集合中的对象获取出来并注册到BeanFactory工厂中，后续需要扫描该类的注解。

3：容器刷新

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 容器刷新前准备工作
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			//创建Bean工厂，解析配置
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// bean工厂准备工作
			prepareBeanFactory(beanFactory);

			try {
				//拓展接口，留给子类进行实现拓展
				postProcessBeanFactory(beanFactory);

				// 注册执行，BeanFactoryPostProcessor
				invokeBeanFactoryPostProcessors(beanFactory);

				// 注册创建BeanPostProcessor
				registerBeanPostProcessors(beanFactory);

				// 这个方法主要作用就是使用国际化，定制不同的消息文本，比如定义了一个Person的Bean，它有name属性，我们需要在不同的国家展示对应国家所在语言名称，这时候就可以使用国际化了。
				initMessageSource();

				// Initialize event multicaster for this context.
				//初始化应用事件广播器
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				//拓展接口，留给子类进行实现拓展，springboot就对该方法进行了处理
				onRefresh();

				// Check for listener beans and register them.
				//将内部的、以及我们自定义的监听器添加到缓存中，为后续逻辑处理做准备。还有添加事件源到缓存中。
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				//实例化剩下非懒加载的Bean
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				//使用应用事件广播器推送上下文刷新完毕事件（ContextRefreshedEvent ）到相应的监听器。
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				//执行相关销毁方法
				destroyBeans();

				// Reset 'active' flag.
				//重置上下文刷新状态
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

前面步骤都是基本准备工作，创建完上下文对象之后，调用Spring IOC的核心流程，完成Bean的扫描注册、实例化、初始化工作。笔者前面写了16篇Spring IOC的流程文章，有兴趣可以看一下。

4：执行BeanFactory后置处理器

在步骤1中，已经往BeanFactory工厂中注册了一个ConfigurationClassPostProcessor后置处理器

在这里插入图片描述在这里插入图片描述

该后置处理器实现了BeanDefinitionRegistryPostProcessor接口，所以最终会调用其postProcessBeanDefinitionRegistry方法。

该方法主要作用：

1、获取所有的BeanDefinition，挨个循环判断

2、对@Componet、@PropertySources、@ComponentScans、@Import、@ImportResource进行解析处理

我们启动类配置了@SpringBootApplication注解，@SpringBootApplication注解信息如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

@EnableAutoConfiguration:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

由于启动类配置了@Import注解，所以会动@Import进行解析操作

5： @Import解析处理

	private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
			Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
			boolean checkForCircularImports) {

		if (importCandidates.isEmpty()) {
			return;
		}

		if (checkForCircularImports && isChainedImportOnStack(configClass)) {
			this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
		}
		else {
			this.importStack.push(configClass);
			try {
				for (SourceClass candidate : importCandidates) {
					if (candidate.isAssignable(ImportSelector.class)) {
						// Candidate class is an ImportSelector -> delegate to it to determine imports
						Class<?> candidateClass = candidate.loadClass();
						ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
								this.environment, this.resourceLoader, this.registry);
						Predicate<String> selectorFilter = selector.getExclusionFilter();
						if (selectorFilter != null) {
							exclusionFilter = exclusionFilter.or(selectorFilter);
						}
                        //如果Import选择器 实现了DeferredImportSelector接口，则添加到容器里面。后续会调用其getAutoConfigurationEntry方法
						if (selector instanceof DeferredImportSelector) {
							this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
						}
						else {
                            //调用Import选择器的selectImports方法，返回需要注册的BeanName
							String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
							Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
							processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
						}
					}
					else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
						// Candidate class is an ImportBeanDefinitionRegistrar ->
						// delegate to it to register additional bean definitions
						Class<?> candidateClass = candidate.loadClass();
						ImportBeanDefinitionRegistrar registrar =
								ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
										this.environment, this.resourceLoader, this.registry);
						configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
					}
					else {
						// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
						// process it as an @Configuration class
						this.importStack.registerImport(
								currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
						processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
					}
				}
			}
			catch (BeanDefinitionStoreException ex) {
				throw ex;
			}
			catch (Throwable ex) {
				throw new BeanDefinitionStoreException(
						"Failed to process import candidates for configuration class [" +
						configClass.getMetadata().getClassName() + "]", ex);
			}
			finally {
				this.importStack.pop();
			}
		}
	}

由于启动类配置的Import是AutoConfigurationImportSelector类，而该类实现了DeferredImportSelector接口，所以不会直接调用其selectImports方法，网上有很多文章说是掉这个方法进来的，其实并不是。如果实现了DeferredImportSelector接口，会将该Selector实现类加入到集合中，在后续调用其getAutoConfigurationEntry()方法;

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
		ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
}

6：getAutoConfigurationEntry解析

	protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
        //获取META/INF/spring.factories
		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
		configurations = removeDuplicates(configurations);
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
		checkExcludedClasses(configurations, exclusions);
		configurations.removeAll(exclusions);
		configurations = getConfigurationClassFilter().filter(configurations);
		fireAutoConfigurationImportEvents(configurations, exclusions);
		return new AutoConfigurationEntry(configurations, exclusions);
	}

getCandidateConfigurations(annotationMetadata, attributes)，见方法1详解

方法1：getCandidateConfigurations

该方法会加载META-INF/spring.factories目录下的文件，并获取文件KEY为org.springframework.boot.autoconfigure.EnableAutoConfiguration的所有配置类。

	protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
		List<String> configurations = new ArrayList<>(
				SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader()));
		ImportCandidates.load(AutoConfiguration.class, getBeanClassLoader()).forEach(configurations::add);
		Assert.notEmpty(configurations,
				"No auto configuration classes found in META-INF/spring.factories nor in META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. If you "
						+ "are using a custom packaging, make sure that file is correct.");
		return configurations;
	}

SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader())，见方法2详解

方法2：loadFactoryNames

	public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
		ClassLoader classLoaderToUse = classLoader;
		if (classLoaderToUse == null) {
			classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
		}
        //factoryTypeName=org.springframework.boot.autoconfigure.EnableAutoConfiguration
		String factoryTypeName = factoryType.getName();
        //加载获有的配置类放到缓存中，并从中获取KEY为org.springframework.boot.autoconfigure.EnableAutoConfiguration的配置类
		return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
	}

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
		Map<String, List<String>> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}

		result = new HashMap<>();
		try {
            //FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
			Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
            //加载配置文件中的所有KEY-VELUE配置类,并将其放入缓存中
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				UrlResource resource = new UrlResource(url);
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					String factoryTypeName = ((String) entry.getKey()).trim();
					String[] factoryImplementationNames =
							StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
					for (String factoryImplementationName : factoryImplementationNames) {
						result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
								.add(factoryImplementationName.trim());
					}
				}
			}

			// Replace all lists with unmodifiable lists containing unique elements
			result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
					.collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
			cache.put(classLoader, result);
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
		return result;
	}

只要我们在META-INF/目录下的spring.factories文件中配置key为org.springframework.boot.autoconfigure.EnableAutoConfiguration，值为我们需要注入的自动装配类，Springboot会将该类包装成BeanDefinition并注入到IOC容器中；

总结

使用Spring开发时，由于项目中某些类需要提前注入到IOC容器中时，我们可以利用Springboot的自动装配，遵守其约定，将自动装配类配置到META-INF/目录下的spring.factories文件中，并指定key为org.springframework.boot.autoconfigure.EnableAutoConfiguration。这样Springboot就可以将该类注入到IOC容器中。

如果一个ImportSelector实现类，实现了DeferredImportSelector接口，那么该ImportSelector并不会调用selectImports()方法，而是直接调用getAutoConfigurationEntry()方法，网上有很多文章直接说入口是selectImports()，所以学会看源码，才能看清本质。

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

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

相关文章

node笔记_连接mysql编写js脚本的crud

node笔记_连接mysql编写js脚本的crud

文章目录 ⭐前言⭐mysql的api依赖库⭐建立数据库连接⭐query执行sql语句&#x1f496; create 新增table数据库表&#x1f496; insert 插入表数据插入单条数据插入多条数据 &#x1f496; select 查询数据&#x1f496; delete 删除表数据删除单条数据删除多条数据 ⭐ 结束 ⭐…
阅读更多...
prometheus实战之五：飞书通知告警

prometheus实战之五：飞书通知告警

欢迎访问我的GitHub 这里分类和汇总了欣宸的全部原创(含配套源码)&#xff1a;https://github.com/zq2599/blog_demos 《prometheus实战》系列链接 prometheus实战之一&#xff1a;用ansible部署prometheus实战之二&#xff1a;使用常见指标prometheus实战之三&#xff1a;告警…
阅读更多...
Day968.如何开启一个遗留系统现代化项目？ -遗留系统现代化实战

Day968.如何开启一个遗留系统现代化项目？ -遗留系统现代化实战

如何开启一个遗留系统现代化项目&#xff1f; Hi&#xff0c;我是阿昌&#xff0c;今天学习记录的是关于如何开启一个遗留系统现代化项目&#xff1f;的内容。那如何启动一个遗留系统现代化项目。 一、项目背景 说来有点唏嘘&#xff0c;国内遗留系统的重灾区&#xff0c;恰恰…
阅读更多...
MongoDB概念和操作

MongoDB概念和操作

一、相关概念 在mongodb中最基本的概念为&#xff1a;文档、集合、数据库 SQL术语/概念MongoDB术语/概念解释/说明databasedatabase数据库tablecollection数据库表/集合rowdocument数据记录行/文档columnfield数据字段/域indexindex索引table joins表连接,MongoDB不支持prima…
阅读更多...
Cordova webapp实战开发：（5）如何写一个Andorid下自动更新的插件？

Cordova webapp实战开发：（5）如何写一个Andorid下自动更新的插件？

在 《Cordova webapp实战开发&#xff1a;&#xff08;4&#xff09;Android环境搭建》中我们搭建好了开发环境&#xff0c;也给大家布置了调用插件的预习作业&#xff0c;做得如何了呢&#xff1f;今天我们来学一下如何自己从头建立一个Andorid下的cordova插件。 本次练习你能…
阅读更多...
【大腹太卷】一篇文章带你了解校招的神秘面纱

【大腹太卷】一篇文章带你了解校招的神秘面纱

校招求职复盘 写在前面方向确定前置工作就业信息获取简历制作简历投递 笔面试工作测评笔试面试八股文自我介绍项目相关HR面试反问环节 Offer选择写在后面 写在前面 2023届应届生&#xff0c;去年的时候参加了校招&#xff0c;一路走来&#xff0c;感慨良多&#xff0c;特此记录…
阅读更多...
蚊香液、蚊香片、蚊香盘的优缺点

蚊香液、蚊香片、蚊香盘的优缺点

夏天来了&#xff0c;蚊子也出来活动了&#xff0c;又到了消灭蚊子的季节。     蚊子是凭借人所呼出的二氧化碳和带气味的气体&#xff0c;来定位人的位置&#xff0c;进而叮咬人的皮肤。     蚊子吸人血&#xff0c;主要是利用血液里的胆固醇、B族维生素&#xff0c;促进蚊…
阅读更多...
OSPF综合实验（第一部分）

OSPF综合实验（第一部分）

目录 要求 确定广播域的个数 分配网段 配置路由器IP地址-优先公网配通 配置MGRE部分 拓扑结构&#xff1a; 要求 1、R4为ISP&#xff0c;其上只能配置IP地址&#xff0c;R4与其他所有直连设备间使用公有IP 2、R3~R5/6/7为MGRE环境&#xff0c;R3为中心站点 3、整个OSPF环境I…
阅读更多...
《编程思维与实践》1072.下一位妙数

《编程思维与实践》1072.下一位妙数

《编程思维与实践》1072.下一位妙数 题目 思路 思路与最小不重复数基本一致,从最高位开始找到第一个出现9的位置,让其加1,后面全变为0即可. 只需要再加一个判定条件:不能被9整除. 由数学知识,一个数不能被9整除当且仅当各位数之和不能被9整除. 这里给出简单的证明: 不妨以三位…
阅读更多...
Linux-初学者系列7_shell编程

Linux-初学者系列7_shell编程

在进行服务器集群管理时&#xff0c;需要编写shell程序来进行服务器管理。 shell是一个命令行解释器&#xff0c;他会为用户提供了一个向Linux内核发送请求以便运行程序的界面系统级程序&#xff0c;用户用shell启动、挂起、停止和编写一些程序。 Linux-初学者系列7_shell编程…
阅读更多...
简单记录一下spi的四种mode

简单记录一下spi的四种mode

0 前言 最近在学习SPI&#xff0c;刚开始接触四种mode的时候&#xff0c;还有点懵&#xff0c;也是搜了好几个博客&#xff0c;才算搞懂&#xff0c;特此记录下&#xff0c;防止下次又要翻好几篇博客才找到答案 >_< 1 四种mode的组成单元 这四种mode是由时钟极性和时钟…
阅读更多...
Leetcode刷题之反转链表Ⅱ

Leetcode刷题之反转链表Ⅱ

业精于勤而荒于嬉&#xff0c;行成于思而毁于随。 ——韩愈目录 前言&#xff1a; &#x1f341;一.反转链表Ⅱ &#x1f352;1.left和right中间链表反转&#xff0c;再把反转链表和剩下的链接起来 &#x1f5fc;2.left和right中间链表头插 题目描述…
阅读更多...
「实验记录」MIT 6.824 Raft Lab2A Leader Election

「实验记录」MIT 6.824 Raft Lab2A Leader Election

#Lab2A - Leader Election I. SourceII. My CodeIII. MotivationIV. SolutionS1 - 角色转换S2 - 发起 RequestVote 拉票请求S3 - 收到 RequestVote 的不同反应S4 - 发送 AppendEntries 心跳包S5 - 收到 AppendEntries 的不同反应S6 - defs.go约定俗成和GetState() V. Result I.…
阅读更多...
The service already exists!

The service already exists!

文章目录 项目场景&#xff1a;原因分析&#xff1a;解决方案&#xff1a; 项目场景&#xff1a; 提示&#xff1a;这里简述项目相关背景&#xff1a; 在给一位同学安装MySQL时报了这个错&#xff0c;我知道是她之前安装过但是没删干净的原因 但是我把Everything和注册表都查…
阅读更多...
五、RGB实验(正点原子达芬奇Pro代码＞＞ZYNQ 7020代码移植)

五、RGB实验(正点原子达芬奇Pro代码＞＞ZYNQ 7020代码移植)

RGB实验(正点原子达芬奇Pro代码&#xff1e;&#xff1e;ZYNQ 7020代码移植) 文章目录 RGB实验(正点原子达芬奇Pro代码&#xff1e;&#xff1e;ZYNQ 7020代码移植)前言一、本文目标二、移植步骤1.建立文件2.建立v文件1.lcd_rgb_colorbar2.lcd_driver3.rd_id4.clk_div5.lcd_dis…
阅读更多...
单调队列算法模板及应用

单调队列算法模板及应用

文章和代码已经归档至【Github仓库&#xff1a;https://github.com/timerring/algorithms-notes 】或者公众号【AIShareLab】回复 算法笔记 也可获取。 文章目录 队列算法模板例题&#xff1a;滑动窗口code 队列算法模板 // hh 表示队头&#xff0c;tt表示队尾 int q[N], hh 0…
阅读更多...
使用Advanced Installer软件将winform程序打包成exe安装文件

使用Advanced Installer软件将winform程序打包成exe安装文件

在使用vs编写c#代码时&#xff0c;一般都是在debug文件中双击exe文件就可以执行&#xff0c;但是有时候需要将这个exe文件发给别人使用&#xff0c;在自己的电脑上exe文件可以执行&#xff0c;但是在别人的电脑上有时候打开后会报错&#xff0c;提示缺少.neta运行环境&#xff…
阅读更多...
AUTUSAR通信篇 - CAN网络通信(一)

AUTUSAR通信篇 - CAN网络通信(一)

第一篇从全局角度出发&#xff0c;简单介绍了AUTOSAR的结构&#xff0c;从本篇开始我们一起详细了解一下AUTOSAR软件架构下内部的组成部分。下面&#xff0c;我们首先介绍第一个模块-通信。在AUTOSAR BSW中通信由三个部分组成&#xff0c;分别是&#xff1a;通信驱动、通信抽象…
阅读更多...
【计算机视觉 | Pytorch】timm 包的具体介绍和图像分类案例（含源代码）

【计算机视觉 | Pytorch】timm 包的具体介绍和图像分类案例（含源代码）

一、具体介绍 timm 是一个 PyTorch 原生实现的计算机视觉模型库。它提供了预训练模型和各种网络组件&#xff0c;可以用于各种计算机视觉任务&#xff0c;例如图像分类、物体检测、语义分割等等。 timm 的特点如下&#xff1a; PyTorch 原生实现&#xff1a;timm 的实现方式…
阅读更多...
Java之线程池

Java之线程池

目录 一.上节复习 1.阻塞队列 二.线程池 1.什么是线程池 2.为什么要使用线程池 3.JDK中的线程池 三.工厂模式 1.工厂模式的目的 四.使用线程池 1.submit()方法 2.模拟两个阶段任务的执行 五.自定义一个线程池 六.JDK提供线程池的详解 1.如何自定义一个线程池? 2.创…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023