Spring源码分析 @Autowired 是怎样完成注入的？究竟是byType还是byName亦两者皆有

1. 五种不同场景下 @Autowired 的使用

第一种情况 上下文中只有一个同类型的bean

配置类

package org.example.bean;import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class FruitConfiguration {@Bean("apple")public Fruit apple(){return new Fruit("apple");}}

启动类

@ComponentScan(basePackages = "org.example.bean")
public class AutowiredTestDemo {@Autowiredprivate Fruit fruit;public static void main(String[] args) {AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(AutowiredTestDemo.class);AutowiredTestDemo autowiredTestDemo = app.getBean(AutowiredTestDemo.class);System.out.println(autowiredTestDemo.fruit);}}

输出

Fruit{name='apple', price=null}

第二种情况 上下文中有两个同类型不同名的bean 且都与注入字段名称不一致

配置类

@Configuration
public class FruitConfiguration {@Bean("apple")public Fruit apple(){return new Fruit("apple");}@Bean("banana")public Fruit banana(){return new Fruit("banana");}}

启动类

@ComponentScan(basePackages = "org.example.bean")
public class AutowiredTestDemo {@Autowiredprivate Fruit fruit;public static void main(String[] args) {AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(AutowiredTestDemo.class);AutowiredTestDemo autowiredTestDemo = app.getBean(AutowiredTestDemo.class);System.out.println(autowiredTestDemo.fruit);}}

异常结果

No qualifying bean of type 'org.example.bean.Fruit' available: expected single matching bean but found 2: apple,banana

第三种情况 上下文中有两个同类型不同名的bean 且其中一个与注入字段名称一致

配置类

@Configuration
public class FruitConfiguration {@Bean("apple")public Fruit apple(){return new Fruit("apple");}@Bean("banana")public Fruit banana(){return new Fruit("banana");}}

启动类

@ComponentScan(basePackages = "org.example.bean")
public class AutowiredTestDemo {@Autowiredprivate Fruit apple;public static void main(String[] args) {AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(AutowiredTestDemo.class);AutowiredTestDemo autowiredTestDemo = app.getBean(AutowiredTestDemo.class);System.out.println(autowiredTestDemo.apple);}}

输出结果

Fruit{name='apple', price=null}

第四种情况 上下文中有两个同类型不同名的bean 且都与注入字段名称不一致但其中一个使用@Primary 注解

配置类

package org.example.bean;import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;@Configuration
public class FruitConfiguration {@Bean("apple")public Fruit apple(){return new Fruit("apple");}@Primary@Bean("banana")public Fruit banana(){return new Fruit("banana");}}

启动类

package org.example;import org.example.bean.Fruit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;@ComponentScan(basePackages = "org.example.bean")
public class AutowiredTestDemo {@Autowiredprivate Fruit fruit;public static void main(String[] args) {AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(AutowiredTestDemo.class);AutowiredTestDemo autowiredTestDemo = app.getBean(AutowiredTestDemo.class);System.out.println(autowiredTestDemo.fruit);}
}

输出结果

Fruit{name='banana', price=null}

第五种情况 上下文中有两个同类型不同名的bean 且都与注入字段名称不一致但注入时使用@Qualifier注解

配置类

package org.example.bean;import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class FruitConfiguration {@Bean("apple")public Fruit apple(){return new Fruit("apple");}@Bean("banana")public Fruit banana(){return new Fruit("banana");}}

启动类

package org.example;import org.example.bean.Fruit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;@ComponentScan(basePackages = "org.example.bean")
public class AutowiredTestDemo {@Autowired@Qualifier("apple")private Fruit fruit;public static void main(String[] args) {AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(AutowiredTestDemo.class);AutowiredTestDemo autowiredTestDemo = app.getBean(AutowiredTestDemo.class);System.out.println(autowiredTestDemo.fruit);}}

输出结果

Fruit{name='apple', price=null}

2.源码分析

启动类

public static void main(String[] args) {//创建应用上下文的同时注册AutowiredTestDemoAnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(AutowiredTestDemo.class);AutowiredTestDemo autowiredTestDemo = app.getBean(AutowiredTestDemo.class);System.out.println(autowiredTestDemo.fruit);}

org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(java.lang.Class<?>…)

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {//调用无参构造方法this();//注册组件//调用 BeanDefinitionReaderUtils.registerBeanDefinition 注册bdregister(componentClasses);//刷新容器refresh();}

无参构造创建了一个AnnotatedBeanDefinitionReader对象与ClassPathBeanDefinitionScanner对象，用于读取和扫描带有注解的Bean定义信息

public AnnotationConfigApplicationContext() {this.reader = new AnnotatedBeanDefinitionReader(this);this.scanner = new ClassPathBeanDefinitionScanner(this);}

AnnotatedBeanDefinitionReader在初始化时将会往BeanFactory注册注解相关的处理器对象

org.springframework.context.annotation.AnnotatedBeanDefinitionReader#AnnotatedBeanDefinitionReader(org.springframework.beans.factory.support.BeanDefinitionRegistry, org.springframework.core.env.Environment)

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {Assert.notNull(registry, "BeanDefinitionRegistry must not be null");Assert.notNull(environment, "Environment must not be null");this.registry = registry;this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);}

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));}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));}// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.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));}

截屏2023-10-31 21.51.35

@Autowired注解是由 AutowiredAnnotationBeanPostProcessor 进行处理，而后者又实现了 InstantiationAwareBeanPostProcessorAdapter 与 MergedBeanDefinitionPostProcessor 两个扩展点接口

重写 MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition，在bean实例化前，合并定义信息后执行。将需要注入的字段和方法与之需要注入的bean建立映射关系并封装成InjectedElement集合，再与class对象建立映射关系封装为InjectionMetadata对象并存入缓冲中

@Overridepublic void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {//遍历类中的字段与方法，如果需要依赖注入，将封装成InjectionMetadata并放入缓冲中InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);//将成员添加到 beanDefinition 中，以便在配置过程中由外部管理器处理该成员的生命周期和依赖注入metadata.checkConfigMembers(beanDefinition);}

重写 InstantiationAwareBeanPostProcessorAdapter.postProcessProperties,此方法将在bean实例化后，属性填充前执行，此时当前bean已经完成了实例化，因此可以通过之前缓冲起来的映射关系，一一找出需要注入的字段和方法以及其对应需要注入的值，通过反射进行赋值操作

	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {//从缓存中获取当前bean字节码对象的注解元信息InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);try {//进行属性注入metadata.inject(bean, beanName, pvs);}catch (BeanCreationException ex) {throw ex;}catch (Throwable ex) {throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);}return pvs;}

大概了解了@Autowired的核心处理类AutowiredAnnotationBeanPostProcessor后，我们进一步分析上述五种情况，再源码底层是怎么处理的

情况一 有且仅有一个候选bean

org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject

Field field = (Field) this.member;Object value;//默认falseif (this.cached) {try {value = resolvedCachedArgument(beanName, this.cachedFieldValue);}catch (NoSuchBeanDefinitionException ex) {// Unexpected removal of target bean for cached argument -> re-resolvevalue = resolveFieldValue(field, bean, beanName);}}else {//处理当前bean所属字段的依赖注入，获取需要注入的对象value = resolveFieldValue(field, bean, beanName);}if (value != null) {//暴力访问ReflectionUtils.makeAccessible(field);//通过反射给当前需要注入的字段设置值field.set(bean, value);}

跟进resolveFieldValue(field, bean, beanName)方法一路往下直到doResolveDependency方法

org.springframework.beans.factory.support.DefaultListableBeanFactory#doResolveDependency

resolveMultipleBeans 方法是处理集合类型的依赖注入，而我们当前是非集合类型，因此会调用

findAutowireCandidates 处理依赖注入

			//集合类型注入Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);if (multipleBeans != null) {return multipleBeans;}//非集合类型注入Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);if (matchingBeans.isEmpty()) {if (isRequired(descriptor)) {raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);}return null;}

protected Map<String, Object> findAutowireCandidates(@Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {//根据需要注入的bean的类型 递归调用 beanNamesForTypeIncludingAncestors 获取父子BeanFactory中 类型的bean的名称// 注入 此处可能返回多个 候选的beanNameString[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this, requiredType, true, descriptor.isEager());Map<String, Object> result = new LinkedHashMap<>(candidateNames.length);// 判断需要的类型是否是内建beanfor (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {Class<?> autowiringType = classObjectEntry.getKey();if (autowiringType.isAssignableFrom(requiredType)) {Object autowiringValue = classObjectEntry.getValue();autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);if (requiredType.isInstance(autowiringValue)) {result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);break;}}}// ，isSelfReference(beanName, candidate) 用于判断候选项是否是自身引用。// isAutowireCandidate(candidate, descriptor) 用于判断候选项是否符合自动装配的条件for (String candidate : candidateNames) {//调用DefaultListableBeanFactory.isAutowireCandidate() 完成@Qualifier注解过滤// 如果不满足将不会添加到候选Map中if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {addCandidateEntry(result, candidate, descriptor, requiredType);}}if (result.isEmpty()) {boolean multiple = indicatesMultipleBeans(requiredType);// Consider fallback matches if the first pass failed to find anything...DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();for (String candidate : candidateNames) {if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor) &&(!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) {addCandidateEntry(result, candidate, descriptor, requiredType);}}if (result.isEmpty() && !multiple) {// Consider self references as a final pass...// but in the case of a dependency collection, not the very same bean itself.for (String candidate : candidateNames) {if (isSelfReference(beanName, candidate) &&(!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) &&isAutowireCandidate(candidate, fallbackDescriptor)) {addCandidateEntry(result, candidate, descriptor, requiredType);}}}}return result;}

此时容器中只有一个Fruit类型的bean，回到doResolveDependency方法中，最终调用descriptor.resolveCandidate获取到bean实例，然后通过反射完成依赖注入

				//匹配到一个beanName 不满足if (matchingBeans.isEmpty()) {if (isRequired(descriptor)) {raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);}return null;}String autowiredBeanName;Object instanceCandidate;//只匹配到一个beanName 不满足if (matchingBeans.size() > 1) {autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);if (autowiredBeanName == null) {if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);}else {// In case of an optional Collection/Map, silently ignore a non-unique case:// possibly it was meant to be an empty collection of multiple regular beans// (before 4.3 in particular when we didn't even look for collection beans).return null;}}instanceCandidate = matchingBeans.get(autowiredBeanName);}//调用 beanFactory.getBean(beanName)  根据名称获取需要注入的bean对象instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);

因此，情况一 容器中只有一个目标类型的bean进行依赖注入就此结束

情况二，三，四 有两个同类型bean的两种情况

org.springframework.beans.factory.support.DefaultListableBeanFactory#doResolveDependency

如果根据类型匹配到两个beanName，将进入此判断语句中

			if (matchingBeans.size() > 1) {autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);if (autowiredBeanName == null) {//是否必须注入if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);}else {// In case of an optional Collection/Map, silently ignore a non-unique case:// possibly it was meant to be an empty collection of multiple regular beans// (before 4.3 in particular when we didn't even look for collection beans).return null;}}instanceCandidate = matchingBeans.get(autowiredBeanName);}

由determineAutowireCandidate方法决定最终注入的beanName，如果无法选择出最合适的，将执行resolveNotUnique方法抛出NoUniqueBeanDefinitionException 异常，也就是我们情况二看到的异常

进入determineAutowireCandidate 方法

Class<?> requiredType = descriptor.getDependencyType();//@Primary 注解处理  是否有标记了@Primary注解String primaryCandidate = determinePrimaryCandidate(candidates, requiredType);if (primaryCandidate != null) {return primaryCandidate;}//javax.annotation.Priority 优先级匹配 值越小 优先级越高String priorityCandidate = determineHighestPriorityCandidate(candidates, requiredType);if (priorityCandidate != null) {return priorityCandidate;}// Fallbackfor (Map.Entry<String, Object> entry : candidates.entrySet()) {String candidateName = entry.getKey();Object beanInstance = entry.getValue();if ((beanInstance != null && this.resolvableDependencies.containsValue(beanInstance)) ||//将候选的beanName与依赖注入的字段名称进行匹配matchesBeanName(candidateName, descriptor.getDependencyName())) {return candidateName;}}return null;

首先针对第四种情况，如果有标记了@Primary注解的bean，将优先采用，如果都没有 ,则根据javax.annotation.Priority 注解的值选最小，值越小优先级越高。如果没有使用@Priority注解，将采用兜底方法

matchesBeanName()，哪一个候选的beanName与需要依赖注入的字段名称一致就使用谁

protected boolean matchesBeanName(String beanName, @Nullable String candidateName) {return (candidateName != null &&(candidateName.equals(beanName) || ObjectUtils.containsElement(getAliases(beanName), candidateName)));}

此时就是情况三 候选的beanName的名称与需要依赖注入的字段名称一致，依然能完成注入。

情况五 注入时使用@Qualifier注解

回到

org.springframework.beans.factory.support.DefaultListableBeanFactory#findAutowireCandidates

在获取到多个候选的beanName后，将会遍历集合，调用isSelfReference，isAutowireCandidate进行筛选，

而Qualifier注解的处理就在isAutowireCandidate方法中

for (String candidate : candidateNames) {//调用DefaultListableBeanFactory.isAutowireCandidate() 完成@Qualifier注解过滤// 如果不满足将不会添加到候选Map中if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {addCandidateEntry(result, candidate, descriptor, requiredType);}}

跟进来到

org.springframework.beans.factory.annotation.QualifierAnnotationAutowireCandidateResolver#isAutowireCandidate

public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {boolean match = super.isAutowireCandidate(bdHolder, descriptor);if (match) {//Qualifier 注解匹配 获取对象标准的Qualifier注解的值与候选的beanName进行匹配//有Qualifier注解才进行比较判断//否则直接返回truematch = checkQualifiers(bdHolder, descriptor.getAnnotations());if (match) {MethodParameter methodParam = descriptor.getMethodParameter();if (methodParam != null) {Method method = methodParam.getMethod();if (method == null || void.class == method.getReturnType()) {match = checkQualifiers(bdHolder, methodParam.getMethodAnnotations());}}}}return match;}

{if (ObjectUtils.isEmpty(annotationsToSearch)) {return true;}SimpleTypeConverter typeConverter = new SimpleTypeConverter();for (Annotation annotation : annotationsToSearch) {Class<? extends Annotation> type = annotation.annotationType();boolean checkMeta = true;boolean fallbackToMeta = false;//有Qualifier注解才进行比较判断if (isQualifier(type)) {if (!checkQualifier(bdHolder, annotation, typeConverter)) {fallbackToMeta = true;}else {checkMeta = false;}}if (checkMeta) {boolean foundMeta = false;for (Annotation metaAnn : type.getAnnotations()) {Class<? extends Annotation> metaType = metaAnn.annotationType();if (isQualifier(metaType)) {foundMeta = true;// Only accept fallback match if @Qualifier annotation has a value...// Otherwise it is just a marker for a custom qualifier annotation.if ((fallbackToMeta && StringUtils.isEmpty(AnnotationUtils.getValue(metaAnn))) ||!checkQualifier(bdHolder, metaAnn, typeConverter)) {return false;}}}if (fallbackToMeta && !foundMeta) {return false;}}}return true;}

至此，Spring针对 @Autowired 注解在五种不同的情况下进行依赖注入我们已经分析完毕

3. 结论

@Autowired 首先会通过 BeanFactoryUtils.beanNamesForTypeIncludingAncestors （递归获取父子BeanFactory调用getBeanNamesForType方法），根据需要进行依赖注入的字段的类型或者方法参数的类型取获取相应的beanName,如果注入的是非集合类型的对象，并且找到了一个以上的候选beanName，则下一步会去判断是否有标记优先级，如果都没有则会进行名称匹配，也就是将候选的beanName与字段名或参数名进行equals比较

byType -> 优先级比较 -> byName

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

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

OpenAI 官方 Prompt 工程指南：写好 Prompt 的六个策略

OpenAI 官方 Prompt 工程指南：写好 Prompt 的六个策略

其实一直有很多人问我&#xff0c;Prompt 要怎么写效果才好&#xff0c;有没有模板。 我每次都会说&#xff0c;能清晰的表达你的想法&#xff0c;才是最重要的&#xff0c;各种技巧都是其次。但是&#xff0c;我还是希望发给他们一些靠谱的文档。 但是&#xff0c;网上各种所…
阅读更多...
手绘风格绘画白板：自由创作艺术空间 | 开源日报 No.118

手绘风格绘画白板：自由创作艺术空间 | 开源日报 No.118

firebase/firebase-ios-sdk Stars: 4.8k License: Apache-2.0 这个项目是 Firebase 苹果开源开发平台&#xff0c;包含了除 FirebaseAnalytics 之外的所有 Apple 平台 Firebase SDKs 的源代码。它提供了一系列工具来帮助你构建、增长和盈利你的应用程序。主要功能和核心优势如…
阅读更多...
NC65 查询单据所处的流程状态以及流程平台客户端工具类

NC65 查询单据所处的流程状态以及流程平台客户端工具类

1、查询单据所处的流程状态 nc.bs.wfengine.engine.EngineService的queryFlowStatus()方法 /*** 查询单据所处的流程状态* * param billId* param billType* param result* return* throws DbException*/public int queryFlowStatus(String billId, String billType, int flo…
阅读更多...
『番外篇五』SwiftUI 进阶之如何动态获取任意视图的 tag 和 id 值

『番外篇五』SwiftUI 进阶之如何动态获取任意视图的 tag 和 id 值

概览 在某些场景下，我们需要用代码动态去探查 SwiftUI 视图的信息。比如任意视图的 id 或 tag 值： 如上图所示：我们通过动态探查技术在运行时将 SwiftUI 特定视图的 tag 和 id 值显示在了屏幕上。 这是如何做到的呢？ 在本篇博文，您将学到如下内容： 概览1. “如意如意，…
阅读更多...
Mybatis的关联查询（association和collection）

Mybatis的关联查询（association和collection）

关联查询 实体间的关系&#xff08;拥有 has、属于 belong&#xff09; OneToOne&#xff1a;一对一关系&#xff08;account ←→ user&#xff09; OneToMany&#xff1a;一对多关系&#xff08;user ←→ account&#xff09; ManyToMany&#xff1a;多对多关系&#xff0…
阅读更多...
【递归 回溯】LeetCode-17. 电话号码的字母组合

【递归 回溯】LeetCode-17. 电话号码的字母组合

17. 电话号码的字母组合。 给定一个仅包含数字 2-9 的字符串&#xff0c;返回所有它能表示的字母组合。答案可以按 任意顺序 返回。 给出数字到字母的映射如下&#xff08;与电话按键相同&#xff09;。注意 1 不对应任何字母。 示例 1&#xff1a; 输入&#xff1a;digit…
阅读更多...
Arduino中使用步进电机

Arduino中使用步进电机

目录 一、硬件介绍 1、型号 &#xff08;1&#xff09;步进电机 &#xff08;2&#xff09;驱动器 2、接线图 3、电机旋转圈速和位置 &#xff08;1&#xff09;电机旋转一圈对应脉冲数设置 &#xff08;2&#xff09;电机旋转速度设置 二、功能代码和测试 1、代码 …
阅读更多...
【排序算法】C语言实现选择排序与冒泡排序

【排序算法】C语言实现选择排序与冒泡排序

文章目录 &#x1f680;前言&#x1f680;冒泡排序✈️冒泡排序的逻辑✈️冒泡排序coding &#x1f680;选择排序✈️选择排序的逻辑✈️选择排序coding &#x1f680;前言 这里是阿辉算法与数据结构专栏的第一篇文章&#xff0c;咱们就从排序算法开始讲起&#xff0c;排序算法…
阅读更多...
【ARMv8M Cortex-M33 系列 1 -- SAU 介绍】

【ARMv8M Cortex-M33 系列 1 -- SAU 介绍】

文章目录 Cortex-M33 SAU 介绍SAU 的主要功能包括SAU 寄存器配置示例 Cortex-M33 SAU 介绍 在 ARMv8-M 架构中&#xff0c;SAU&#xff08;Security Attribution Unit&#xff09;是安全属性单元&#xff0c;用于配置和管理内存区域的安全属性。SAU 是 ARM TrustZone 技术的一…
阅读更多...
1.使用 Blazor 利用 ASP.NET Core 生成第一个 Web 应用

1.使用 Blazor 利用 ASP.NET Core 生成第一个 Web 应用

参考 https://dotnet.microsoft.com/zh-cn/learn/aspnet/blazor-tutorial/create 1.使用vs2022创建新项目 选择 C# -> Windows -> Blzxor Server 应用模板 2.项目名称BlazorApp下一步 3.选择 .NET6.0 或 .NET7.0 或 .NET8.0 创建 4.运行BlazorApp 5.全部选择是。 信…
阅读更多...
页面级UI状态存储LocalStorage

页面级UI状态存储LocalStorage

目录 1、LocalStorageProp 2、LocalStorageLink 3、LocalStorage的使用 4、从UI内部使用LocalStorage 5、LocalStorageProp和LocalStorage单向同步的简单场景 6、LocalStorageLink和LocalStorage双向同步的简单场景 7、兄弟节点之间同步状态变量 LocalStorage是页面级的…
阅读更多...
Python中__getitem__的奇妙应用

Python中__getitem__的奇妙应用

更多资料获取 &#x1f4da; 个人网站&#xff1a;ipengtao.com 理解 __getitem__ 方法 1 基本概念 在Python中&#xff0c;__getitem__ 是一个重要的魔法方法&#xff0c;用于实现对象的索引访问。当使用类似 obj[index] 的方式访问对象时&#xff0c;Python 解释器会自动调…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023