SpringBoot监听器源码解析

news2025/1/12 12:05:39

1.1 创建SpringApplication对象

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
		return new SpringApplication(primarySources).run(args);
}

SpringApplication(。。){
    //获取到所有配置的ApplicationListener类型的监听器，放到属性中
   setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
}


private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
		ClassLoader classLoader = getClassLoader();
		// 读取配置
		Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    //遍历实例化
		List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
		AnnotationAwareOrderComparator.sort(instnces);
		return instances;
	}

去加载META-INF下面的spring.factories文件。

在spring-boot模块下
//共计10个
org.springframework.context.ApplicationListener=\
org.springframework.boot.ClearCachesApplicationListener,\
org.springframework.boot.builder.ParentContextCloserApplicationListener,\
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,\
org.springframework.boot.context.FileEncodingApplicationListener,\
org.springframework.boot.context.config.AnsiOutputApplicationListener,\
org.springframework.boot.context.config.ConfigFileApplicationListener,\
org.springframework.boot.context.config.DelegatingApplicationListener,\
org.springframework.boot.context.logging.ClasspathLoggingApplicationListener,\
org.springframework.boot.context.logging.LoggingApplicationListener,\
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener

在spring-boot-autoconfigure模块下
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer
//================================以上共计11个监听器===============================




//================================以上共计7个应用环境初始化器================================

在spring-boot模块下
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
org.springframework.boot.context.ContextIdApplicationContextInitializer,\
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
org.springframework.boot.rsocket.context.RSocketPortInfoApplicationContextInitializer,\
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer

在spring-boot-autoconfigure模块下
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

完成上面的逻辑之后，具体对象放到了SpringApplication的

private List<ApplicationContextInitializer<?>> initializers;

private List<ApplicationListener<?>> listeners;

属性中。

1.2 执行run逻辑

1.2.1 生成EventPublishingRunListener对象
public ConfigurableApplicationContext run(String... args) {
    //...省略若干
    //得到EventPublishingRunListener对象，同时将监听器复制给了多波器
    SpringApplicationRunListeners listeners = getRunListeners(args);   
}

getRunListeners 即获得EventPublishingRunListener实例对象。

org.springframework.boot.SpringApplicationRunListener=\
org.springframework.boot.context.event.EventPublishingRunListener

其中EventPublishingRunListener的构造方法

public EventPublishingRunListener(SpringApplication application, String[] args) {
		this.application = application;
		this.args = args;
		this.initialMulticaster = new SimpleApplicationEventMulticaster();
       //初始状态是11个。即SpringAPplication.listeners中保存的
		for (ApplicationListener<?> listener : application.getListeners()) {
			this.initialMulticaster.addApplicationListener(listener);
		}
	}
//完成这个操作，将监听器都放到initialMulticaster（多波器）的内部类中
//this.defaultRetriever.applicationListeners.add(listener);
1.2.2 prepareContext(…)
private void prepareContext(....) {
		//....省略代码。。。。
		applyInitializers(context); //这里应该是添加了3个
	   
       //....省略代码。。。。
		//AbstractApplicationContext.applicationListeners 共4个了
		listeners.contextLoaded(context);//CloudFoundryVcapEnvironmentPostProcessor
	}

protected void applyInitializers(ConfigurableApplicationContext context) {
    //遍历这7个
		for (ApplicationContextInitializer initializer : getInitializers()) {
			Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(),
					ApplicationContextInitializer.class);
			Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
			initializer.initialize(context); // 有些初始化方法有逻辑，有些没有；RSocketPortInfoApplicationContextInitializer；ServerPortInfoApplicationContextInitializer; ConditionEvaluationReportLoggingListener 这三个加入进去
		}
}
AbstractApplicationContext.applicationListener属性中添加 ，共添加进去3个
    
    
//======================================
public void contextLoaded(ConfigurableApplicationContext context) {
    //开始这是初始的11个
		for (ApplicationListener<?> listener : this.application.getListeners()) {
			if (listener instanceof ApplicationContextAware) {
				((ApplicationContextAware) listener).setApplicationContext(context);
			}
            //添加进监听器。之前是3个，这里开始遍历哪11个往里添加。完成之后共计14个了
			context.addApplicationListener(listener);
		}
		this.initialMulticaster.multicastEvent(new ApplicationPreparedEvent(this.application, this.args, context));
}
1.2.3 prepareRefresh()

到这里赋值给AbstractApplicationContext.earlyApplicationListeners。共计14个

if (this.earlyApplicationListeners == null) {
			this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JEBgGoUl-1681622852483)(C:\Users\Administrator\Desktop\监听器.assets\image-20230416100740186.png)]

1.2.4 invokeBeanFactoryPostProcessor()

添加了一个。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7Wk9Dmgg-1681622852484)(C:\Users\Administrator\Desktop\监听器.assets\image-20230416111330686.png)]

1.2.5 registerListeners
protected void registerListeners() {
		//获取到AbstractApplicationContex.applicationListeners(15个)
		for (ApplicationListener<?> listener : getApplicationListeners()) {
            //添加到广播器中
            //AbstractApplicationEventMulticaster内部类ListenerRetriever
			getApplicationEventMulticaster().addApplicationListener(listener);
		}
    
    //&org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory
    //mvcResourceUrlProvider
    //springApplicationAdminRegistrar
	String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    //添加到this.defaultRetriever.applicationListenerBeans.add(listenerBeanName);
    // //AbstractApplicationEventMulticaster内部类ListenerRetriever
		for (String listenerBeanName : listenerBeanNames) { 	getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		}

		// Publish early application events now that we finally have a multicaster...
		Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
		this.earlyApplicationEvents = null;
		if (earlyEventsToProcess != null) {
			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
				getApplicationEventMulticaster().multicastEvent(earlyEvent);
			}
		}
}


AbstractApplicationEventMulticaster.java
public void addApplicationListener(ApplicationListener<?> listener) {
		synchronized (this.retrievalMutex) {
			// Explicitly remove target for a proxy, if registered already,
			// in order to avoid double invocations of the same listener.
			Object singletonTarget = AopProxyUtils.getSingletonTarget(listener);
			if (singletonTarget instanceof ApplicationListener) {
				this.defaultRetriever.applicationListeners.remove(singletonTarget);
			}
			this.defaultRetriever.applicationListeners.add(listener);
			this.retrieverCache.clear();
		}
	}

经过以上，监听器的注入基本完成。

2. 广播执行

AbstractApplicationContext.java

@Override
	public void publishEvent(Object event) {
		publishEvent(event, null);
}


protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
		
		//早期事件不为空
		if (this.earlyApplicationEvents != null) {
			this.earlyApplicationEvents.add(applicationEvent);
		}
		else {
            //调用多播器，继而调用监听器
			getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
		}
      //....
}

调用多播器的逻辑，继而调用监听器的逻辑

	@Override
	public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
		ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
		Executor executor = getTaskExecutor();
        //获取指定类型的所有的应用监听器，遍历处理
		for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
            //线程池去执行
			if (executor != null) {
				executor.execute(() -> invokeListener(listener, event));
			}
			else {
            // 直接同步执行  
            //listener.onApplicationEvent(event); 其实就是回调执行逻辑   
			invokeListener(listener, event);
			}
		}
	}

对于getApplicationListeners(event, type)解析。还是在AbstractApplicationEventMulticaster.java类中，调用retrieveApplicationListeners(…）

//得到所有的监听器
private Collection<ApplicationListener<?>> retrieveApplicationListeners(
			ResolvableType eventType, @Nullable Class<?> sourceType, @Nullable ListenerRetriever retriever) {

    //最终返回的监听器
		List<ApplicationListener<?>> allListeners = new ArrayList<>();
    //项目设置进来的监听器addApplicationListener方法加入的，会保存在这里面
		Set<ApplicationListener<?>> listeners;
		Set<String> listenerBeans;
		synchronized (this.retrievalMutex) {
			listeners = new LinkedHashSet<>(this.defaultRetriever.applicationListeners);
			listenerBeans = new LinkedHashSet<>(this.defaultRetriever.applicationListenerBeans);
		}

		// Add programmatically registered listeners, including ones coming
		// from ApplicationListenerDetector (singleton beans and inner beans).
		for (ApplicationListener<?> listener : listeners) {
			if (supportsEvent(listener, eventType, sourceType)) {
				if (retriever != null) {
					retriever.applicationListeners.add(listener);
				}
				allListeners.add(listener);
			}
		}

		if (!listenerBeans.isEmpty()) {
			ConfigurableBeanFactory beanFactory = getBeanFactory();
			for (String listenerBeanName : listenerBeans) {
				try {
					if (supportsEvent(beanFactory, listenerBeanName, eventType)) {
						ApplicationListener<?> listener =
								beanFactory.getBean(listenerBeanName, ApplicationListener.class);
						if (!allListeners.contains(listener) && supportsEvent(listener, eventType, sourceType)) {
							if (retriever != null) {
								if (beanFactory.isSingleton(listenerBeanName)) {
									retriever.applicationListeners.add(listener);
								}
								else {
									retriever.applicationListenerBeans.add(listenerBeanName);
								}
							}
							allListeners.add(listener);
						}
					}
					else {
						Object listener = beanFactory.getSingleton(listenerBeanName);
						if (retriever != null) {
							retriever.applicationListeners.remove(listener);
						}
						allListeners.remove(listener);
					}
				}
				catch (NoSuchBeanDefinitionException ex) {
					// Singleton listener instance (without backing bean definition) disappeared -
					// probably in the middle of the destruction phase
				}
			}
		}

		AnnotationAwareOrderComparator.sort(allListeners);
		if (retriever != null && retriever.applicationListenerBeans.isEmpty()) {
			retriever.applicationListeners.clear();
			retriever.applicationListeners.addAll(allListeners);
		}
		return allListeners;
	}

3. 自定义的监听器

所有对象实例完成之后，

@Override
	public void preInstantiateSingletons() throws BeansException {
		// 将所有BeanDefinition的名字创建一个集合
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		// 触发所有非延迟加载单例bean的初始化，遍历集合的对象
		for (String beanName : beanNames) {
	    //。。。。。
		}

		// Trigger post-initialization callback for all applicable beans...
		// 遍历beanNames，触发所有SmartInitializingSingleton的后初始化回调
		for (String beanName : beanNames) {
			// 获取beanName对应的bean实例
			Object singletonInstance = getSingleton(beanName);
			// 判断singletonInstance是否实现了SmartInitializingSingleton接口
			if (singletonInstance instanceof SmartInitializingSingleton) {
				// 类型转换
				SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				// 触发SmartInitializingSingleton实现类的afterSingletonsInstantiated方法
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

EventListenerMethodProcessor.java。检查所有的bean对象

public void afterSingletonsInstantiated() {
		ConfigurableListableBeanFactory beanFactory = this.beanFactory;
		Assert.state(this.beanFactory != null, "No ConfigurableListableBeanFactory set");
		// 获取容器中所有bean组件的名称
		String[] beanNames = beanFactory.getBeanNamesForType(Object.class);
		for (String beanName : beanNames) {
			// 遍历每个bean组件，检测其中@EventListener注解方法，生成和注册ApplicationListener实例
			if (!ScopedProxyUtils.isScopedTarget(beanName)) {
				Class<?> type = null;
				try {
					type = AutoProxyUtils.determineTargetClass(beanFactory, beanName);
				}
				catch (Throwable ex) {
					// An unresolvable bean type, probably from a lazy bean - let's ignore it.
					if (logger.isDebugEnabled()) {
						logger.debug("Could not resolve target class for bean with name '" + beanName + "'", ex);
					}
				}
				if (type != null) {
					if (ScopedObject.class.isAssignableFrom(type)) {
						try {
							Class<?> targetClass = AutoProxyUtils.determineTargetClass(
									beanFactory, ScopedProxyUtils.getTargetBeanName(beanName));
							if (targetClass != null) {
								type = targetClass;
							}
						}
						catch (Throwable ex) {
							// An invalid scoped proxy arrangement - let's ignore it.
							if (logger.isDebugEnabled()) {
								logger.debug("Could not resolve target bean for scoped proxy '" + beanName + "'", ex);
							}
						}
					}
					try {
						// 针对一个bean的真正的@EventListener注解方法检测，ApplicationListener实例生成和注册
						processBean(beanName, type);
					}
					catch (Throwable ex) {
						throw new BeanInitializationException("Failed to process @EventListener " +
								"annotation on bean with name '" + beanName + "'", ex);
					}
				}
			}
		}
	}

processBean方法，注册监听器

private void processBean(final String beanName, final Class<?> targetType) {
		if (!this.nonAnnotatedClasses.contains(targetType) &&
				AnnotationUtils.isCandidateClass(targetType, EventListener.class) &&
				!isSpringContainerClass(targetType)) {

			Map<Method, EventListener> annotatedMethods = null;
			try {
				// 检测当前类targetType上使用了注解@EventListener的方法
				annotatedMethods = MethodIntrospector.selectMethods(targetType,
						(MethodIntrospector.MetadataLookup<EventListener>) method ->
								AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class));
			}
			catch (Throwable ex) {
				// An unresolvable type in a method signature, probably from a lazy bean - let's ignore it.
				if (logger.isDebugEnabled()) {
					logger.debug("Could not resolve methods for bean with name '" + beanName + "'", ex);
				}
			}

			if (CollectionUtils.isEmpty(annotatedMethods)) {
				// 如果当前类targetType中没有任何使用了注解@EventListener的方法，则将该类保存到缓存nonAnnotatedClasses，从而
				// 避免当前处理方法重入该类，避免二次处理
				this.nonAnnotatedClasses.add(targetType);
				if (logger.isTraceEnabled()) {
					logger.trace("No @EventListener annotations found on bean class: " + targetType.getName());
				}
			}
			else {
				// Non-empty set of methods
				// 如果当前类targetType中有些方法使用了注解@EventListener，那么根据方法上的信息对应的创建和注册ApplicationListener实例
				ConfigurableApplicationContext context = this.applicationContext;
				Assert.state(context != null, "No ApplicationContext set");
				// 此处使用了this.eventListenerFactories,这些EventListenerFactory是在该类postProcessBeanFactory方法调用时被记录的
				List<EventListenerFactory> factories = this.eventListenerFactories;
				Assert.state(factories != null, "EventListenerFactory List not initialized");
				for (Method method : annotatedMethods.keySet()) {
					for (EventListenerFactory factory : factories) {
						if (factory.supportsMethod(method)) {
							Method methodToUse = AopUtils.selectInvocableMethod(method, context.getType(beanName));
							// 如果当前EventListenerFactory支持处理该@EventListener注解的方法，则使用它创建ApplicationListener
							ApplicationListener<?> applicationListener =
									factory.createApplicationListener(beanName, targetType, methodToUse);
							if (applicationListener instanceof ApplicationListenerMethodAdapter) {
								((ApplicationListenerMethodAdapter) applicationListener).init(context, this.evaluator);
							}
							// 将创建的ApplicationListener加入到容器中
							context.addApplicationListener(applicationListener);
							break;
						}
					}
				}
				if (logger.isDebugEnabled()) {
					logger.debug(annotatedMethods.size() + " @EventListener methods processed on bean '" +
							beanName + "': " + annotatedMethods);
				}
			}
		}
	}

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

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

相关文章

Android中的多线程编程与异步处理

Android中的多线程编程与异步处理

Android中的多线程编程与异步处理 引言 在移动应用开发中&#xff0c;用户体验是至关重要的。一个流畅、高效的应用能够吸引用户并提升用户满意度。然而&#xff0c;移动应用面临着处理复杂业务逻辑、响应用户输入、处理网络请求等多个任务的挑战。为了确保应用的性能和用户体验…
阅读更多...
《springboot实战》第六章 实现自定义全局异常处理

《springboot实战》第六章 实现自定义全局异常处理

前言 springboot实现自定义全局异常处理&#xff0c;以及统一返回数据。 1、分析 首先&#xff0c;实现全局异常的流程 从图中可以看到&#xff0c;实现全局异常会需要这样几个类&#xff1a; 自定义异常接口类自定义异常枚举类自定义异常类自定义异常处理类自定义全局响应…
阅读更多...
藏在GPT背后的治理分歧：那些赞同和反对的人们｜AI百态（下篇）

藏在GPT背后的治理分歧：那些赞同和反对的人们｜AI百态（下篇）

AGI的火种正在燎原。 一面是无可否认的AI生产力&#xff0c;正在赋能千行百业&#xff1b;而另一面&#xff0c;这团火似乎烧向了我们不可控的隐秘角落。 在《AI百态&#xff08;上篇&#xff09;——ChatGPT的“N宗罪”》中&#xff0c;我们提到监管重锤在落下&#xff0c;意大…
阅读更多...
安装 Docker和基本操作实验文档

安装 Docker和基本操作实验文档

一、安装 Docker 目前 Docker 只能支持 64 位系统。 systemctl stop firewalld.service setenforce 0 #安装依赖包 yum install -y yum-utils device-mapper-persistent-data lvm2 yum-utils&#xff1a;提供了 yum-config-manager 工具。device mapper&#xff1a; 是Li…
阅读更多...
分布式系统概念和设计-操作系统中的支持和设计

分布式系统概念和设计-操作系统中的支持和设计

分布式系统概念和设计 操作系统支持 中间件和底层操作系统的关系&#xff0c;操作系统如何满足中间件需求。 中间件需求:访问物理资源的效率和健壮性&#xff0c;多种资源管理策略的灵活性。 任何一个操作系统的目标都是提供一个在物理层&#xff08;处理器&#xff0c;内存&a…
阅读更多...
【网络安全】Xss漏洞

【网络安全】Xss漏洞

xss漏洞 xss漏洞介绍危害防御方法xss测试语句xss攻击语句1. 反射性xss2.存储型xss3.DOM型xssdvwa靶场各等级渗透方法xss反射型&#xff08;存储型方法一致&#xff09;LowMediumHightimpossible Dom型LowMediumHight xss漏洞介绍 定义&#xff1a;XSS 攻击全称跨站脚本攻击&am…
阅读更多...
Twitter|GraphJet:推特的实时内容推荐（论文+源码解读）

Twitter|GraphJet:推特的实时内容推荐（论文+源码解读）

以下内容具有主观性&#xff0c;有些问题的理解和回答不一定准确&#xff0c;仅供参考。翻译不确定的后面都有原文。 1.论文 1.1论文的动机是什么&#xff1f; 作者在追溯基于图推荐的系统的进化过程&#xff0c;发现了两大趋势&#xff08;更快更广&#xff09;。 趋势一是…
阅读更多...
MySQL ,MyBatis 1.参数占位符 2. ParameterType 3. SQL 语句中特殊字符处理

MySQL ,MyBatis 1.参数占位符 2. ParameterType 3. SQL 语句中特殊字符处理

1.参数占位符&#xff1a; 1&#xff09;#{}&#xff1a;执行sql时&#xff0c;会将#仔占位符替换为&#xff1f;&#xff0c;将来自动设置参数值 2&#xff09;${}&#xff1a;拼SQL。会存在SQL注入问题 3.使用时机&#xff1a; * 参数传递&#xff0c;都使用#{} *如果要对表名…
阅读更多...
Elasticsearch：保留字段名称

Elasticsearch：保留字段名称

作为 Elasticsearch 用户&#xff0c;我们从许多不同的位置收集数据。 我们使用 Logstash、Beats 和其他工具来抓取数据并将它们发送到 Elasticsearch。 有时&#xff0c;我们无法控制数据本身&#xff0c;我们需要管理数据的结构&#xff0c;甚至需要在摄取数据时处理字段名称…
阅读更多...
腾讯云轻量服务器测评：4核8G12M带宽流量CPU限制说明

腾讯云轻量服务器测评：4核8G12M带宽流量CPU限制说明

腾讯云轻量4核8G12M服务器446元一年&#xff0c;之前是4核8G10M配置&#xff0c;现在公网带宽和月流量包整体升级&#xff0c;系统盘为180GB SSD盘&#xff0c;每月2000GB免费流量&#xff0c;如果是选择买赠专区的4核8G12M配置是518元15个月&#xff0c;腾讯云百科来详细说下4…
阅读更多...
MyBatis插入时获取自增id

MyBatis插入时获取自增id

关于MyBatis在插入时获取自增id 1.1 注释方法 Insert("insert into book(bid, bname, price, number, cratedate) values(null,#{bname},#{price},#{number},#{cratedate}) ")int add(Book book); //注意&#xff1a;在mapper中是不能重载的这里我特意写为add01Ins…
阅读更多...
【力扣-JZ22】链表中倒数第k个结点

【力扣-JZ22】链表中倒数第k个结点

&#x1f58a;作者 : Djx_hmbb &#x1f4d8;专栏 : 数据结构 &#x1f606;今日分享 : "把手插进米堆的原因 " : 因为米堆类似于高密度的流体&#xff0c;会给人的手带来较大的压强&#xff0c;这种压强促进静脉血回流&#xff0c;会让人感到生理上的舒服。 文章目…
阅读更多...
临床决策曲线分析如何影响预测模型的使用和评价

临床决策曲线分析如何影响预测模型的使用和评价

目前&#xff0c;临床决策曲线分析&#xff08;clinical decision curve analysis, DCA&#xff09;在业界已经被超过1500文献使用&#xff0c;也被多个主流的临床杂志所推荐&#xff0c;更被写进了临床预测模型撰写标准&#xff08;TRIPOD&#xff09;中&#xff0c;但是许多预…
阅读更多...
OpenCV实例（七）汽车检测

OpenCV实例（七）汽车检测

OpenCV实例&#xff08;七&#xff09;汽车检测 1.概述2.代码实例3.代码功能 作者&#xff1a;Xiou 1.概述 对于图像和视频检测中的目标类型并没有具体限制&#xff0c;但是&#xff0c;为了使结果的准确度在可接受范围内&#xff0c;需要一个足够大的数据集&#xff0c;包括…
阅读更多...
mongodb数据库索引介绍与优化选择

mongodb数据库索引介绍与优化选择

数据库开发系列 文章目录 数据库开发系列前言一、基础篇二、提高篇总结 前言 一、基础篇 MongoDB 索引 索引通常能够极大的提高查询的效率&#xff0c;如果没有索引&#xff0c;MongoDB在读取数据时必须扫描集合中的每个文件并选取那些符合查询条件的记录。 这种扫描全集合的查…
阅读更多...
broadcast自动扩展/合并与分割/基本运算

broadcast自动扩展/合并与分割/基本运算

文章目录 一、broadcastKey ideamatch from last dim 二、合并catstack 三、拆分split&#xff1a; 四、基本运算matmulAn examplematmulpowerexp logapproximationclamp 五、统计属性总结 一、broadcast Key idea ▪ Insert 1 dim ahead ▪ Expand dims with size 1 to same…
阅读更多...
测试概念篇

测试概念篇

目录 调试和测试的区别软件测试的概念软件测试和软件开发的区别优秀的测试人员应该具什么素质为什么要做测试软件的生命周期什么是Bug什么是需求测试用例是什么产品的生命周期软件测试贯穿于软件的整个生命&#xff0c;如如何贯穿&#xff1f;开发模型瀑布模型&#xff08;面向…
阅读更多...
【java】反射基础

【java】反射基础

Class类 import java.io.*; import java.util.Scanner;public class Main {public static void main(String[] args) throws ClassNotFoundException {Class<String> clazz String.class; //使用class关键字&#xff0c;通过类名获取Class<?> clazz2 Class.f…
阅读更多...
SpringBoot源码学习系列——运行流程分析

SpringBoot源码学习系列——运行流程分析

前文SpringBoot源码学习系列——构造流程分析对SpringApplication的实例化流程进行了介绍&#xff0c;完成了基本配置文件的加载及初始化&#xff0c;本文对其run方法进行介绍&#xff0c;看看Spring Boot是如何启动运行的。 run方法核心流程 可以看到&#xff0c;SpringAppli…
阅读更多...
主机串口—虚拟机串口—linux系统串口之间的关系（实现主机和虚拟机之间的串口通信）

主机串口—虚拟机串口—linux系统串口之间的关系（实现主机和虚拟机之间的串口通信）

目录 1、准备工具 2、实现机理 3、实现过程 4、虚拟机串口 —— Linux系统串口文件 1、准备工具 VSPD&#xff1a;作用是在主机上创建虚拟串口 VSPD 下载&#xff1a;VSDP 汉化版下载VSPD 配置教程&#xff1a;VSPD虚拟串口工具实用工具–小白入门篇 | 码农家园 串口调…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023