寿命齿轮
寿命齿轮

SpringBoot自动装配源码解析（40000字大章）

 CSDN里貌似没法搞代码的自动换行，嫌看着麻烦的话可以直接看我的笔记里的版本，排版会更舒服些https://note.youdao.com/s/IgsPbrpd。

目录

一、原理说明

二、源码讲解

2.1@SpringBootApplication

2.2@SpringBootConfiguration

2.3@ComponentScan

2.4@EnableAutoConfiguration

2.5AutoConfigurationImportSelector.class

2.5.1selectImports函数

2.5.2getAutoConfigurationEntry函数

2.5.3AutoConfigurationGroup

2.5.4Spring IOC源码

2.6@AutoConfigurationPackage

2.7TypeExcludeFilter、AutoConfigurationExcludeFilter

2.7.1AutoConfigurationExcludeFilter.class

2.7.2TypeExcludeFilter

三、代码举例

3.1自定义ImportBeanDefinitionRegistrar实现、自定义ImportSelector实现、自定义注解，以通过一个注解实现一堆Bean的功能。

3.2自定义Starter

3.2.1实现Starter

3.2.2测试Starter

一、原理说明

在Spring的学习过程中，我们已经了解到了IOC控制反转的含义，通过将组件的控制权从应用程序代码中转移到框架或容器中的机制（由Spring代替我们进行组件的初始化、获得实例、销毁等），从而使应用程序只需关注业务逻辑，不需要关心对象的创建和管理，实现了解耦和可维护性的目标。

在Bean的生命周期中，bean类被加载到JVM中时，会被Spring扫描并存入到一个Map中（比如Person.class，存入），然后BeanFactoryPostProcessor可以对其中某些BeanDefinition进行一些修改，然后使用 ClassLoader 加载BeanDefinition中的类名对应的类，再 利用类的构造函数创建一个新的实例，就此Bean的实例化就完成了。

更详细的Bean生命周期：

  1. 加载到 JVM： Spring 容器在启动时，会解析配置文件或扫描注解，创建相应的 BeanDefinition，并将其存储在 BeanDefinitionMap 中。BeanDefinitionMap 是一个 Map，它将 Bean 的名称映射到 BeanDefinition 实例。BeanFactoryPostProcessor 中的方法 postProcessBeanFactory() 在 Spring 容器加载 Bean 的定义信息后、实例化 Bean 之前被调用。这个方法可以获取到 Bean 的定义信息，从而可以在实例化之前对这些定义信息进行修改。一般来说，这些修改可能涉及属性值的更改、添加新的 Bean 定义、移除不需要的 Bean 定义等。
  2. 实例化：当容器需要创建 Bean 时，它会根据 BeanDefinition 的信息创建相应的 Bean 实例。这一步骤通常由 BeanDefinitionReader 和 BeanFactory 负责。BeanFactory 是容器的核心接口，它实际上是一个工厂模式的实现，用于实例化和管理 Bean。在容器启动时，会初始化 BeanFactory，BeanFactory 会根据 BeanDefinition 创建 Bean 实例。
  3. 属性注入：在实例化后，容器会根据 BeanDefinition 中的属性值配置来进行属性注入。这一过程由 BeanDefinitionMap 中的 BeanDefinition 实例提供的属性信息来完成。
  4. 初始化前的函数调用：如果 Bean 实现了 BeanNameAware 或 BeanFactoryAware 接口，容器会在实例化后，但在初始化之前，调用相应的方法，使 Bean 可以获取 Bean 的名称或容器的引用；BeanPostProcessor 的实现类也会被调用，允许对 Bean 进行一些前置处理，这一阶段的处理由 AbstractAutowireCapableBeanFactory 的 applyBeanPostProcessorsBeforeInitialization 方法负责。
  5. 初始化：如果 Bean 实现了 InitializingBean 接口或在 BeanDefinition 中通过 init-method 属性指定了初始化方法，容器会在 Bean 实例化和属性注入之后调用相应的方法，执行 Bean 的初始化逻辑。
  6. 初始化后的函数调用：在 Bean 初始化之后，BeanPostProcessor 的实现类会被调用，允许对 Bean 进行一些后置处理。这一阶段的处理由 AbstractAutowireCapableBeanFactory 的 applyBeanPostProcessorsAfterInitialization 方法负责。
  7. Bean使用。
  8. 销毁：如果 Bean 实现了 DisposableBean 接口，或者在配置中通过 destroy-method 属性指定了销毁方法，容器会在 Bean 销毁阶段调用相应的方法，执行 Bean 的销毁逻辑。这一过程由 DisposableBean 接口的 destroy 方法或在 BeanDefinition 中指定的 destroy-method 属性负责。

那么为什么要回顾这个呢？因为自动装配涉及到这个过程，并且其实质就是更改BeanDefinition。

比如，我们发现在实例化过程中，实现BeanDefinition接口的抽象类AbstractBeanDefinition中包含了一个int属性autowireMode，该属性的作用是设置是否启用自动装配：

  • autowireMode包含4个“枚举”，依次为NO/BYNAME/BYTYPE/CONSTRUCTOR，在AbstractApplicationContext类执行refresh方法时，会根据此属性决定是否进行自动装配。
  • 如A是一个Component，B也是一个Component，A是B的一个字段：
@Component
public class TestB {
    //@Autowire
    public TestA testA;
    public void setTestA(TestA testA) {
        this.testA = testA;
    }
    //......
}

 平时我们自己进行配置时，需要给TestA类加上@Autowire注解（或使用xml配置文件），这样TestA的Bean才会注入到TestB的Bean中，否则此属性实际为Null。

  • 但是如果在BeanFactoryPostProcessor中将TestB的BeanDefinition的autowireMode属性更改为非默认值（默认为NO，即不开启自动装配）：
@Configuration
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        GenericBeanDefinition defA = (GenericBeanDefinition) beanFactory.getBeanDefinition("testB");
        defA.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
    }
}

那么就不需要@Autowire注解了，再执行refresh方法，其会自动将用到的属性配置好。

我们已经初步了解到自动装配与BeanDefinition的关联，但是这和我们的目的还差得远：我们希望有一个可以不需要任何配置文件，开箱即用，按需装配的开发框架，而不仅仅局限于Spring的Bean管理功能。我们需要从「控制反转」递进到『开箱即用』。

正常情况下，我们使用Bean对象，需要@Import该类，不过上述的A类B类都是在SpringBootApplication同一个目录下的，所以不需要Import就能被扫描到。我们现在已经知道将一个Bean加载到Spring容器的过程，但是讲所需要的Class全部使用@Import进行导入过于麻烦。

我们的希望是仅使用一个@SpringBootApplication注解，就能按需将合适的Bean进行加载。

（前文内容只是一个引子，与自动装配关联不大，着重看接下来的内容）

在这个逐步优化的过程中，需要提到两个特殊的接口——ImportBeanDefinitionRegistrar和ImportSelector。

ImportBeanDefinitionRegistrar是用于动态将额外的 bean 定义注册到容器中的接口，使用方式是@Import一个实现了ImportBeanDefinitionRegistrar接口的registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry)方法的类，该方法可以使用函数形参BeanDefinitionRegistry来向容器注册和管理 bean 定义，比如注册是void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)。

ImportSelector是用于在配置类中根据条件选择性地导入其他的配置类或组件的接口，使用方式也是@Import一个实现了ImportSelector接口的selectImports方法的类，在该方法中可以加入各种条件判断来生成一个String[]，该数组中的元素就是一个个配置类，Spring容器会加载该函数返回的String数组中的配置类。

说到这里，想必大家就有了一些思路：可以自定义一个@EnableAutoConfiguration注解，该注解中包含了一些@Import注解，这些@Import注解就用来导入ImportBeanDefinitionRegistrar和ImportSelector的实现类，以此，我们在写新项目时，只需要加上@EnableAutoConfiguration注解，即可自动装配一大堆Bean对象。（建议查看举例代码3.1）

@MyEnableAutoConfiguration实现思路：

SpringBoot自动装配源码解析（40000字大章）_第1张图片

虽然我们可以直接在@MyEnableAutoConfiguration注解中加入一堆@Import来将所有需要的Bean都进行注入，但是ImportBeanDefinitionRegistrar和ImportSelector的优点就是可以根据条件进行装载，并且是直接根据代码中的逻辑进行动态装载，则为后续的按需装配做好了准备。

我们现在已经实现了使用一个注解来加载一堆Bean到Spring容器，但是整个过程是写死在代码中的，并且无法做到按需装配，目前的自定义注解会将所有Bean都进行注入。因此需要继续优化。

我们可以考虑使用Spring的PropertySource机制，将配置文件中的String数组作为一个属性值进行读取。这样可以方便地进行配置文件的修改和维护，同时也提高了代码的可读性和可维护性。

也可以通过扫描指定的包路径来获取SpringBootApplication中导入的所有类，然后在配置文件中描述根据这些路径加载需要的配置类的规则，从而实现按需装配和开箱即用的效果。接下来我们需要查看源码以深入了解实现细节。

二、源码讲解

我们从@SpringBootApplication注解入手，一层层看它是如何实现开箱即用的。（建议查看此章节时一边Debug一边看）

2.1@SpringBootApplication

@SpringBootApplication可以被拆解为这7个注解：前4个注解不用在意；注解中也只是给包含的注解属性加上别名，不用在意。重点是包含的@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan三个注解。

@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 {//...
}

2.2@SpringBootConfiguration

@SpringBootConfiguration就是@Configuration注解的别名，用于指定一个类是配置类，因此使用了@SpringBootApplication注解后，启动类中也可加入@Bean。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@Indexed
public @interface SpringBootConfiguration {//...
}

2.3@ComponentScan

@ComponentScan注解中使用了两个过滤器TypeExcludeFilter 和 AutoConfigurationExcludeFilter，来排除一些类型的组件。由于@ComponentScan中没有使用其他参数，所以默认开启扫描的范围为当前注解所在类所在的包及其子包下的所有类。
TypeExcludeFilter：这个过滤器用于在组件扫描过程中排除特定类型的类。
AutoConfigurationExcludeFilter：这个过滤器用于在自动配置过程中排除特定的自动配置类。自动配置类是 Spring Boot 应用启动时自动加载的，通过排除某些自动配置类，可以控制哪些自动配置应该被应用，哪些应该被排除。
TypeExcludeFilter和AutoConfigurationExcludeFilter的源码讲解在后续内容，现在先继续讲@EnableAutoConfiguration注解。

2.4@EnableAutoConfiguration

看一眼@EnableAutoConfiguration注解：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    //...
}

@AutoConfigurationPackage注解的作用是显式地指定自动配置的基础包。这个注解的细节我们也后续在讲，先关注最重要的注解：@Import(AutoConfigurationImportSelector.class)。

2.5AutoConfigurationImportSelector.class

AutoConfigurationImportSelector的作用是根据项目的依赖和配置情况，动态地选择并加载适合的自动配置类。

2.5.1selectImports函数

AutoConfigurationImportSelector的源码是真的超级大一堆，从每个函数出发太复杂了，我们就先从其根本目的出发。看这个类的后缀名为ImportSelector，并且实现了DeferredImportSelector接口，而DeferredImportSelector接口又继承了ImportSelector，说明我们的中心还是要放到selectImports函数上，毕竟是这个函数决定了哪些配置类会被自动装载。

@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
   if (!isEnabled(annotationMetadata)) {
      return NO_IMPORTS;
   }
   AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
   return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

单看方法很简单，就是判断注解元数据是否启用，不启用则直接返回空数组，不载入配置类；如果启用则从注解元数据中获得需要启用的配置类数组，进行自动装载。

isEnabled函数的逻辑很简单：

    protected boolean isEnabled(AnnotationMetadata metadata) {
        if (getClass() == AutoConfigurationImportSelector.class) {
            return getEnvironment().getProperty(EnableAutoConfiguration.ENABLED_OVERRIDE_PROPERTY, Boolean.class, true);
        }
        return true;
    }

先判断当前类是否是AutoConfigurationImportSelector.class，如果是就从配置文件中获得spring.boot.enableautoconfiguration属性，该属性用于决定是否启用自动装配，默认为启用。

isEnabled判断为true，然后就执行

AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);

查看该语句，使用了getAutoConfigurationEntry函数，我们就从这个函数入手，看他是怎么获得需要自动装配的配置类的。

2.5.2getAutoConfigurationEntry函数

这个函数的作用是选择适合的自动配置类作为入口，并将其返回供后续处理使用，它决定了哪些自动配置会在应用中生效。

看源码：

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
   if (!isEnabled(annotationMetadata)) {
      return EMPTY_ENTRY;
   }
   AnnotationAttributes attributes = getAttributes(annotationMetadata);
   List configurations = getCandidateConfigurations(annotationMetadata, attributes);
   configurations = removeDuplicates(configurations);
   Set exclusions = getExclusions(annotationMetadata, attributes);
   checkExcludedClasses(configurations, exclusions);
   configurations.removeAll(exclusions);
   configurations = getConfigurationClassFilter().filter(configurations);
   fireAutoConfigurationImportEvents(configurations, exclusions);
   return new AutoConfigurationEntry(configurations, exclusions);
}

接下来对这个源码进行分析：

  • 第二行依旧是一个判断是否启用自动装配的if语句，当然是启用，忽略！
  • 第五行「AnnotationAttributes attributes = getAttributes(annotationMetadata);」调用了getAttributes函数，这个方法的主要作用是从给定的注解元数据中获取自动配置的属性值，并确保属性值不为 null。这里补充一下AnnotationMetadata是啥，这是一个数据结构，用来存储各个类和它们的注解之间的对应关系，我们可以从中获得指定类的指定注解的属性等。好了我们现在已经获得了@EnableAutoConfiguration注解的属性值，其实就是两个属性，exclude和excludeName。
  • 第六行「List configurations = getCandidateConfigurations(annotationMetadata, attributes);」调用了getCandidateConfigurations函数，该函数的作用是获取所有候选的自动配置类。看一下源码解析：
protected List getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
   List configurations = new ArrayList<>(
         SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader()));
//loadFactoryNames会使用给定的类加载器，从所有的“META-INF/spring.factories”文件中加载给定类型的工厂实现的完全限定类名，该函数源码在后面。
   ImportCandidates.load(AutoConfiguration.class, getBeanClassLoader()).forEach(configurations::add);
//加载与 AutoConfiguration 注解相关的配置类，这些类同样也会被添加到候选配置类列表中，该函数源码在后面。
   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.");
//断言，判断configurations是否为空，为空说明加载配置类失败，报错
   return configurations;
}

 SpringFactoriesLoader.loadFactoryNames源码：

public static List loadFactoryNames(Class factoryType, @Nullable ClassLoader classLoader) {
   ClassLoader classLoaderToUse = classLoader;
   if (classLoaderToUse == null) {
      classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
   }
   String factoryTypeName = factoryType.getName();
   //此次执行，factoryTypeName即为getSpringFactoriesLoaderFactoryClass()的返回结果，“org.springframework.boot.autoconfigure.EnableAutoConfiguration”。
   return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
}
private static Map> loadSpringFactories(ClassLoader classLoader) {
   Map> result = cache.get(classLoader);
   if (result != null) {//由于并不是首次执行，所以会直接从cache中获得结果，但是我们还是要看result的加载过程
      return result;
   }

   result = new HashMap<>();
   try {
      Enumeration urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);//FACTORIES_RESOURCE_LOCATION即"META-INF/spring.factories"，此行代码的意思是通过类加载器获取指定路径下的所有资源，就是所有的被导入的jar包的各种META-INF/spring.factories文件都会被加载一遍
      while (urls.hasMoreElements()) {//遍历所有找到的资源
         URL url = urls.nextElement();//获取下一个资源的URL
         UrlResource resource = new UrlResource(url);//将URL转换为UrlResource对象，以便于加载资源内容
         Properties properties = PropertiesLoaderUtils.loadProperties(resource);//使用PropertiesLoaderUtils加载资源内容为属性对象。
         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);//如果在加载资源时出现异常，抛出IllegalArgumentException异常。
   }
   return result;
}

ImportCandidates.load源码：

public static ImportCandidates load(Class annotation, ClassLoader classLoader) {
   Assert.notNull(annotation, "'annotation' must not be null");//确保传入的注解参数不为null。
   ClassLoader classLoaderToUse = decideClassloader(classLoader);//若传入的classLoader为空，则使用当前类的类加载器；否则使用传入的类加载器
   String location = String.format(LOCATION, annotation.getName());//location为"META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports"
   Enumeration urls = findUrlsInClasspath(classLoaderToUse, location);//从类路径中搜索所有导入的 JAR 包，并尝试在每个 JAR 包中查找 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件。
   List importCandidates = new ArrayList<>();//创建一个空的列表，用于存储读取到的候选导入类。
   while (urls.hasMoreElements()) {//遍历所有找到的资源文件。
      URL url = urls.nextElement();//获取下一个资源文件的URL。
      importCandidates.addAll(readCandidateConfigurations(url));//读取并添加从资源文件中提取的候选导入类列表。
   }
   return new ImportCandidates(importCandidates);//将读取到的候选导入类列表包装成 ImportCandidates 对象并返回。
}
  • 第七行「configurations = removeDuplicates(configurations);」的作用是去除重复的自动配置类名。实现很简单，return new ArrayList<>(new LinkedHashSet<>(list))即可。
  • 第八行「Set exclusions = getExclusions(annotationMetadata, attributes);」的作用是获取需要排除的自动配置类名集合。之前我们提到，AnnotationAttributes即为exclude和excludeName两个属性，这里就会将这两个属性中的值并入到一个Set集合中。此外，还会使用getExcludeAutoConfigurationsProperty方法获取在应用程序的配置文件中指定排除自动配置的属性名称。看源码：
protected Set getExclusions(AnnotationMetadata metadata, AnnotationAttributes attributes) {
   Set excluded = new LinkedHashSet<>();
   excluded.addAll(asList(attributes, "exclude"));// 将 "exclude" 属性的值加入到排除集合中
   excluded.addAll(asList(attributes, "excludeName"));// 将 "excludeName" 属性的值加入到排除集合中
   excluded.addAll(getExcludeAutoConfigurationsProperty());// 获取从属性中获取的需要排除的自动配置类名列表，并加入到排除集合中
   return excluded;// 返回最终的排除集合
}
protected List getExcludeAutoConfigurationsProperty() {
   Environment environment = getEnvironment();// 获取应用程序的环境对象
   if (environment == null) {
      return Collections.emptyList();// 如果环境对象为空，则返回空列表
   }
   if (environment instanceof ConfigurableEnvironment) {
      Binder binder = Binder.get(environment);// 如果环境对象是可配置的环境，使用 Binder 来绑定属性值
      return binder.bind(PROPERTY_NAME_AUTOCONFIGURE_EXCLUDE, String[].class)
         .map(Arrays::asList)
         .orElse(Collections.emptyList());//PROPERTY_NAME_AUTOCONFIGURE_EXCLUDE即"spring.autoconfigure.exclude"，从配置文件中读取该数组类属性，生成List并返回
   }
   String[] excludes = environment.getProperty(PROPERTY_NAME_AUTOCONFIGURE_EXCLUDE, String[].class);// 如果环境对象不是可配置的环境，直接从环境中获取属性值
   return (excludes != null) ? Arrays.asList(excludes) : Collections.emptyList();
}
  • 第⑨行「checkExcludedClasses(configurations, exclusions);」检查是否有被排除的类不存在于候选自动配置类中。看源码：
private void checkExcludedClasses(List configurations, Set exclusions) {
   List invalidExcludes = new ArrayList<>(exclusions.size());//invalidExcludes 是一个用于存储无效的排除类名的列表，初始容量与排除集合大小相同。
   for (String exclusion : exclusions) {// 遍历排除集合中的每个类名
      if (ClassUtils.isPresent(exclusion, getClass().getClassLoader()) && !configurations.contains(exclusion)) {//如果这个类存在，且不包含在configuration类中
         invalidExcludes.add(exclusion);//则添加到无效排除类
      }
   }
   if (!invalidExcludes.isEmpty()) {
      handleInvalidExcludes(invalidExcludes);//处理无效排除类
   }
}
//handleInvalidExcludes函数的作用是发现无效的被排除类名时，抛出一个 IllegalStateException 异常，其中包含了详细的错误信息，指明哪些类不能被排除，因为它们不是自动配置类。
protected void handleInvalidExcludes(List invalidExcludes) {
   StringBuilder message = new StringBuilder();
   for (String exclude : invalidExcludes) {
      message.append("\t- ").append(exclude).append(String.format("%n"));
   }
   throw new IllegalStateException(String.format(
         "The following classes could not be excluded because they are not auto-configuration classes:%n%s",
         message));
}
  • 第十行「configurations.removeAll(exclusions);」的作用是从候选配置中移除被排除的配置类。
  • 第十一行「configurations = getConfigurationClassFilter().filter(configurations);」的作用是使用配置类过滤器来对候选的自动配置类列表进行过滤，以最终得到符合条件的自动配置类列表。getConfigurationClassFilter()用于获取配置类过滤器（ConfigurationClassFilter）的实例，可以根据一定的条件来决定哪些类应该被包含，哪些类应该被排除。filter 方法将遍历候选列表中的每个类，根据过滤器的条件来判断是否应该将这个类包含在最终的自动配置类列表中。先看一下getConfigurationClassFilter的源码：
private ConfigurationClassFilter getConfigurationClassFilter() {
   if (this.configurationClassFilter == null) {//如果 this.configurationClassFilter 尚未初始化（为 null）则执行以下操作
      List filters = getAutoConfigurationImportFilters();//获取自动配置导入过滤器的列表。这些过滤器用于决定哪些自动配置应该被包含，哪些应该被排除。
      for (AutoConfigurationImportFilter filter : filters) {//遍历自动配置导入过滤器列表。
         invokeAwareMethods(filter);//对于每个过滤器，调用可能的 Aware 接口方法，将相关的信息传递给过滤器。invokeAwareMethods函数的实现就是使用各类set函数将一些环境之类的属性传递过去，不用在意。
      }
      this.configurationClassFilter = new ConfigurationClassFilter(this.beanClassLoader, filters);//使用自动配置导入过滤器列表创建配置类过滤器的实例
   }
   return this.configurationClassFilter;
}
protected List getAutoConfigurationImportFilters() {
   return SpringFactoriesLoader.loadFactories(AutoConfigurationImportFilter.class, this.beanClassLoader);//又使用到SpringFactoriesLoader了，说明过滤器的配置文件可能也在spring.factories中
}

SpringFactoriesLoader.loadFactories源码：

public static  List loadFactories(Class factoryType, @Nullable ClassLoader classLoader) {
   Assert.notNull(factoryType, "'factoryType' must not be null");//factoryType为"org.springframework.boot.autoconfigure.AutoConfigurationImportFilter"，
   ClassLoader classLoaderToUse = classLoader;// 获取用于加载类的类加载器
   if (classLoaderToUse == null) {
      classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
   }
   List factoryImplementationNames = loadFactoryNames(factoryType, classLoaderToUse);//这里调用了loadFactoryNames函数，该函数的作用之前已经介绍过了，可以从之前已经加载过的所有spring.factories中获得指定"org.springframework.boot.autoconfigure.AutoConfigurationImportFilter"接口对应的自动配置导入过滤器，即OnBeanCondition、OnClassCondition和OnWebApplication。
   if (logger.isTraceEnabled()) {//这是看日志级别决定是否进行输出
      logger.trace("Loaded [" + factoryType.getName() + "] names: " + factoryImplementationNames);
   }
   List result = new ArrayList<>(factoryImplementationNames.size());
   for (String factoryImplementationName : factoryImplementationNames) {
      result.add(instantiateFactory(factoryImplementationName, factoryType, classLoaderToUse));
   }//instantiateFactory函数是用来实例化过滤器的方法，将上面提到的3个类进行实例化，然后加到List集合中
   AnnotationAwareOrderComparator.sort(result);// 使用AnnotationAwareOrderComparator对结果列表进行排序
   return result;
}

org.springframework.boot.autoconfigure.AutoConfigurationImportFilter接口的三个相关类。

SpringBoot自动装配源码解析（40000字大章）_第2张图片

 然后是filter函数执行的源码，但是我们先看构造器函数：

private static class ConfigurationClassFilter {
    
   private final AutoConfigurationMetadata autoConfigurationMetadata;
   private final List filters;
   
   ConfigurationClassFilter(ClassLoader classLoader, List filters) {
      this.autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(classLoader);
      this.filters = filters;
   }
   //...
}

发现他调用了AutoConfigurationMetadataLoader类的静态方法loadMetadata，看一下这个静态方法的源码：

static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader) {
   return loadMetadata(classLoader, PATH);//PATH就是"META-INF/spring-autoconfigure-metadata.properties"。该文件帮助应用程序在启动时智能地选择和应用自动配置类，以及提供开发体验的改进，其中记录了每个自动配置类的名称、包路径、条件等信息。
}
static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader, String path) {
   try {
      Enumeration urls = (classLoader != null) ? classLoader.getResources(path)
            : ClassLoader.getSystemResources(path);//似曾相识的代码，用于获得所有jar包中的所有META-INF/spring-autoconfigure-metadata.properties文件。
      Properties properties = new Properties();
      while (urls.hasMoreElements()) {
         properties.putAll(PropertiesLoaderUtils.loadProperties(new UrlResource(urls.nextElement())));
      }//将所有的META-INF/spring-autoconfigure-metadata.properties文件转换为属性键值对，存入properties中。
      return loadMetadata(properties);
   }
   catch (IOException ex) {
      throw new IllegalArgumentException("Unable to load @ConditionalOnClass location [" + path + "]", ex);
   }
}
static AutoConfigurationMetadata loadMetadata(Properties properties) {
   return new PropertiesAutoConfigurationMetadata(properties);//就此生成autoConfigurationMetadata
}

autoConfigurationMetadata中存储了所有的自动配置类装载的条件信息，随便看一个文件：

SpringBoot自动装配源码解析（40000字大章）_第3张图片

 现在再看filter函数的源码：

List filter(List configurations) {
   long startTime = System.nanoTime();//记录开始时间
   String[] candidates = StringUtils.toStringArray(configurations);//将配置类列表转换为String数组
   boolean skipped = false;//标记是否有类被过滤掉
   for (AutoConfigurationImportFilter filter : this.filters) {//遍历所有的自动配置导入过滤器
      boolean[] match = filter.match(candidates, this.autoConfigurationMetadata);
      for (int i = 0; i < match.length; i++) {
         if (!match[i]) {//对未匹配的类置为空，并且设置标记为true
            candidates[i] = null;
            skipped = true;
         }
      }
   }
   if (!skipped) {//如果没有类被过滤掉，直接返回
      return configurations;
   }
   List result = new ArrayList<>(candidates.length);//如果有类被过滤掉，重新构建没有被过滤的类的列表
   for (String candidate : candidates) {
      if (candidate != null) {
         result.add(candidate);
      }
   }
   if (logger.isTraceEnabled()) {//如果日志级别为TRACE，记录被过滤掉的类的数量和过滤时间，可忽略
      int numberFiltered = configurations.size() - result.size();
      logger.trace("Filtered " + numberFiltered + " auto configuration class in "
            + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime) + " ms");
   }
   return result;
}

看了代码，发现还是得看具体的三个过滤器实现类中的match函数，因为这里的match只是接口：三个过滤器（OnBeanCondition、OnClassCondition和OnWebApplication）的实现类都是很大一坨，看着就头疼，不过好在他们都没重写父类FilteringSpringBootCondition的match方法，我们看父类的match方法源码：

public boolean[] match(String[] autoConfigurationClasses, AutoConfigurationMetadata autoConfigurationMetadata) {
   ConditionEvaluationReport report = ConditionEvaluationReport.find(this.beanFactory);//尝试查找与条件评估相关的报告，这个报告用于记录条件的评估结果。
   ConditionOutcome[] outcomes = getOutcomes(autoConfigurationClasses, autoConfigurationMetadata);//调用getOutcomes方法获取配置类的条件评估结果，这些结果表示每个配置类是否满足条件。
   boolean[] match = new boolean[outcomes.length];//创建一个布尔数组 match，用于记录每个配置类是否满足条件。
   for (int i = 0; i < outcomes.length; i++) {
      match[i] = (outcomes[i] == null || outcomes[i].isMatch());//如果条件结果为空（没有条件）或为匹配，则将对应位置的布尔值标记为 true，表示满足条件。
      if (!match[i] && outcomes[i] != null) {// 如果不匹配且结果不为空，记录日志并将评估结果添加到报告中
         logOutcome(autoConfigurationClasses[i], outcomes[i]);
         if (report != null) {
            report.recordConditionEvaluation(autoConfigurationClasses[i], this, outcomes[i]);
         }
      }
   }
   return match;// 返回每个配置类是否匹配条件的布尔数组
}

然而繁琐的是每个实现类都有一个自己的getOutcomes函数，而且源码略微有些复杂...部分函数只说明功能，不做具体解析了。

  1. OnBeanCondition：基于 @ConditionalOnBean 注解和 @ConditionalOnSingleCandidate 注解。 
    @Override
protected final ConditionOutcome[] getOutcomes(String[] autoConfigurationClasses,
      AutoConfigurationMetadata autoConfigurationMetadata) {
   ConditionOutcome[] outcomes = new ConditionOutcome[autoConfigurationClasses.length];//存储每个自动配置类的条件判断结果。
   for (int i = 0; i < outcomes.length; i++) {//遍历每个自动配置类名。
      String autoConfigurationClass = autoConfigurationClasses[i];
      if (autoConfigurationClass != null) {
         Set onBeanTypes = autoConfigurationMetadata.getSet(autoConfigurationClass, "ConditionalOnBean");//获取条件注解 @ConditionalOnBean 中定义的 bean 类型集合。
         outcomes[i] = getOutcome(onBeanTypes, ConditionalOnBean.class);//使用 getOutcome 方法判断是否满足 @ConditionalOnBean 的条件。如果满足，直接存储在 outcomes 数组中。
         if (outcomes[i] == null) {//如果不满足，获取条件注解 @ConditionalOnSingleCandidate。
            Set onSingleCandidateTypes = autoConfigurationMetadata.getSet(autoConfigurationClass,
                  "ConditionalOnSingleCandidate");
            outcomes[i] = getOutcome(onSingleCandidateTypes, ConditionalOnSingleCandidate.class);//使用 getOutcome 方法判断是否满足 @ConditionalOnSingleCandidate 的条件。如果满足，存储到 outcomes 数组。
         }
      }
   }
   return outcomes;
}
private ConditionOutcome getOutcome(Set requiredBeanTypes, Class annotation) {
   List missing = filter(requiredBeanTypes, ClassNameFilter.MISSING, getBeanClassLoader());//过滤出在给定的 bean 类型集合中不存在的 bean 类型，并将结果存储在 missing 列表中。filter实际上是调用matches函数，matches函数再调用isPresent函数，isPresent函数在调用resolve函数，resolve中会使用Class.forName(className, false, classLoader)来判断，如果加载成功，就说明该类存在。
   if (!missing.isEmpty()) {//如果 missing 列表不为空，说明存在某些 bean 类型在当前 Spring 容器中不存在。使用 ConditionMessage 来创建条件判断失败的消息，指出找不到所需的 bean 类型。
      ConditionMessage message = ConditionMessage.forCondition(annotation)
         .didNotFind("required type", "required types")
         .items(Style.QUOTE, missing);
      return ConditionOutcome.noMatch(message);
   }
   return null;
}
  2. OnClassCondition ：基于 @ConditionalOnClass 注解 
    @Override
protected final ConditionOutcome[] getOutcomes(String[] autoConfigurationClasses,
      AutoConfigurationMetadata autoConfigurationMetadata) {
   if (autoConfigurationClasses.length > 1 && Runtime.getRuntime().availableProcessors() > 1) {//如果autoConfigurationClasses 数组的长度大于 1，且当前运行时的可用处理器数量大于 1，说明可以使用多线程来执行，调用 resolveOutcomesThreaded 方法。
      return resolveOutcomesThreaded(autoConfigurationClasses, autoConfigurationMetadata);
   }
   else {//否则直接创建一个 StandardOutcomesResolver 实例，并调用 resolveOutcomes 方法，获取条件判断结果的数组。
      OutcomesResolver outcomesResolver = new StandardOutcomesResolver(autoConfigurationClasses, 0,
            autoConfigurationClasses.length, autoConfigurationMetadata, getBeanClassLoader());
      return outcomesResolver.resolveOutcomes();
   }
}
//两个方法应该是类似的，我们直接看单线程的那个方法。resolveOutcomes直接调用getOutcomes，所以直接看StandardOutcomesResolver类的getOutcomes方法：逻辑和上面OnBeanCondition的getOutcomes函数很类似，就不做赘述了。
private ConditionOutcome[] getOutcomes(String[] autoConfigurationClasses, int start, int end,
      AutoConfigurationMetadata autoConfigurationMetadata) {
   ConditionOutcome[] outcomes = new ConditionOutcome[end - start];
   for (int i = start; i < end; i++) {
      String autoConfigurationClass = autoConfigurationClasses[i];
      if (autoConfigurationClass != null) {
         String candidates = autoConfigurationMetadata.get(autoConfigurationClass, "ConditionalOnClass");
         if (candidates != null) {
            outcomes[i - start] = getOutcome(candidates);
         }
      }
   }
   return outcomes;
}
  3. OnWebApplicationCondition：基于应用程序是否是 Web 应用程序的条件 
    //逻辑和上面OnBeanCondition的getOutcomes函数也很类似，就不做赘述了。
@Override
protected ConditionOutcome[] getOutcomes(String[] autoConfigurationClasses,
      AutoConfigurationMetadata autoConfigurationMetadata) {
   ConditionOutcome[] outcomes = new ConditionOutcome[autoConfigurationClasses.length];
   for (int i = 0; i < outcomes.length; i++) {
      String autoConfigurationClass = autoConfigurationClasses[i];
      if (autoConfigurationClass != null) {
         outcomes[i] = getOutcome(autoConfigurationMetadata.get(autoConfigurationClass, "ConditionalOnWebApplication"));//getOutcome函数的作用是检查是否存在指定的 Web 应用类（Servlet Web、Reactive Web），如果都不存在，再用ClassNameFilter.isPresent 方法检查是否存在 SERVLET_WEB_APPLICATION_CLASS 类，用 ClassUtils.isPresent 方法检查是否存在 REACTIVE_WEB_APPLICATION_CLASS 类，如果以上条件都不满足，说明不是Web应用，返回NULL。
      }
   }
   return outcomes;
}

    在获得了判断结果后，即可获得过滤完成的configurations。

  • 第十二行「fireAutoConfigurationImportEvents(configurations, exclusions);」用于在 Spring Boot 中触发自动配置导入事件。在 Spring Boot 的自动配置过程中，当自动配置类被加载和应用时，可以触发一系列事件，这些事件通常用于通知监听器或其他组件，某些自动配置已经被应用。这个方法会创建一个 AutoConfigurationImportEvent 对象，然后将它发送到 Spring 应用程序上下文中。通过监听这个事件，就可以在自动配置过程中执行自定义逻辑，或者根据配置的情况进行一些额外的处理。看源码：
private void fireAutoConfigurationImportEvents(List configurations, Set exclusions) {
        List listeners = getAutoConfigurationImportListeners();//获取所有已注册的 AutoConfigurationImportListener 监听器，思路和获得过滤器的思路一样，都是调用SpringFactoriesLoader.loadFactories方法。
        if (!listeners.isEmpty()) {//如果不为空，说明存在监听器需要处理自动配置导入事件。
            AutoConfigurationImportEvent event = new AutoConfigurationImportEvent(this, configurations, exclusions);//创建一个 AutoConfigurationImportEvent 对象，该对象包含了触发事件的上下文信息，包括被导入的自动配置类列表 configurations 和被排除的自动配置类列表 exclusions。
            for (AutoConfigurationImportListener listener : listeners) {//遍历所有的监听器，逐个调用它们的 onAutoConfigurationImportEvent 方法，将创建的事件对象传递给监听器。
                invokeAwareMethods(listener);//确保监听器可以获取必要的上下文信息。
                listener.onAutoConfigurationImportEvent(event);
            }
        }
    }
  • 第十三行「return new AutoConfigurationEntry(configurations, exclusions);」就是返回最终的自动配置类名列表和排除列表。

好了，selectImports函数终于讲完了，好大一串玩意，但是AutoConfigurationImportSelector类还并没有讲完呢......

2.5.3AutoConfigurationGroup

当我们进行debug时，会发现如果断点直接打在selectImports方法上时，是没有反应的；而如果将断点打在内部代码上，Step out一下，就会发现实际上跑的是AutoConfigurationGroup的process函数。

那么我们就再讲讲为什么是这个process函数。如果我们一层层看上去，可以一直追溯到AbstractApplicationContext的refresh()，但是我们不用管那么多，先搞明白AutoConfigurationGroup的功能。

AutoConfigurationGroup 是 AutoConfigurationImportSelector 的内部类，用于协调和管理多个导入选择器的行为。（这种设计是为了更加灵活地处理自动配置的导入，并且允许根据条件进行分组管理。

在 Spring Boot 的自动配置导入过程中，会先解析 AutoConfigurationImportSelector，然后在其内部实例化 AutoConfigurationGroup，并最终调用 AutoConfigurationGroup 的 process 方法。

然后我们要了解一下ConfigurationClassParser的工作流程（但这个不是现在的重点）：

  1. parse() 方法是入口，调用 doProcessConfigurationClass() 处理配置类的元数据。
  2. 在 doProcessConfigurationClass() 方法中，依次调用 processConfigurationClass()、processImports()、processMemberClasses()、processBeanMethods() 处理不同的元数据信息。
  3. 在 ConfigurationClassParser 的 doProcessConfigurationClass() 方法中，会调用 processImports() 方法，而在 processImports() 方法内部，会调用 processGroupImports() 方法来处理所有的分组导入选择器，而 processGroupImports() 方法会调用 getImports()，然后再调用selectImports()。

 看一下getImports函数的源码：

public Iterable getImports() {
   for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
      this.group.process(deferredImport.getConfigurationClass().getMetadata(),
            deferredImport.getImportSelector());
   }
   return this.group.selectImports();
}

getImports 方法会遍历 this.deferredImports 列表，对每个 DeferredImportSelectorHolder 调用其 getConfigurationClass().getMetadata() 来获取配置类的元数据，并调用 deferredImport.getImportSelector() 来获取相关的导入选择器。随后，将这些信息传递给 this.group.process 方法，最后再调用 selectImports 方法获得确定需要导入的自动配置类。

所以执行的实际上是AutoConfigurationGroup的process方法和selectImports方法。看一眼这两个方法的源码：

    @Override
        public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
            Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,
                    () -> String.format("Only %s implementations are supported, got %s",
                            AutoConfigurationImportSelector.class.getSimpleName(),
                            deferredImportSelector.getClass().getName()));//使用断言来确保 deferredImportSelector 是 AutoConfigurationImportSelector 的实例，因为 AutoConfigurationGroup 只支持处理这种类型的导入选择器。
            AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector).getAutoConfigurationEntry(annotationMetadata);//通过调用 getAutoConfigurationEntry() 方法来获取导入选择器中的自动配置信息，其中包括了导入的自动配置类以及其对应的排除类。（其实和selectImports函数中的逻辑是一样的）
            this.autoConfigurationEntries.add(autoConfigurationEntry);//将获取的 AutoConfigurationEntry 对象添加到 autoConfigurationEntries 列表中，这个列表用于后续选择导入的自动配置。
            for (String importClassName : autoConfigurationEntry.getConfigurations()) {
                this.entries.putIfAbsent(importClassName, annotationMetadata);
            }//将自动配置类名作为键，将对应的注解元数据作为值，存储到 entries 集合中。这个集合用于后续选择导入的自动配置时查找对应的元数据。
        }
  @Override
        public Iterable selectImports() {
            if (this.autoConfigurationEntries.isEmpty()) {//检查 autoConfigurationEntries 是否为空。如果为空，表示没有任何自动配置条目，直接返回一个空集合。
                return Collections.emptyList();
            }
            Set allExclusions = this.autoConfigurationEntries.stream()
                .map(AutoConfigurationEntry::getExclusions)
                .flatMap(Collection::stream)
                .collect(Collectors.toSet());//对所有自动配置条目中的排除项进行合并，得到一个包含所有要排除的自动配置类的集合 allExclusions。
            Set processedConfigurations = this.autoConfigurationEntries.stream()
                .map(AutoConfigurationEntry::getConfigurations)
                .flatMap(Collection::stream)
                .collect(Collectors.toCollection(LinkedHashSet::new));//遍历所有自动配置条目，将每个条目中的配置类合并到一个 processedConfigurations 集合中。
            processedConfigurations.removeAll(allExclusions);//排除已经在 allExclusions 中的配置类。

            return sortAutoConfigurations(processedConfigurations, getAutoConfigurationMetadata()).stream()
                .map((importClassName) -> new Entry(this.entries.get(importClassName), importClassName))
                .collect(Collectors.toList());//使用 sortAutoConfigurations 方法对 processedConfigurations 进行排序，以便确定自动配置的加载顺序；再遍历排序后的自动配置类名，将每个自动配置类名与对应的 Entry 对象关联起来，形成最终的导入项集合，并返回。
        }

看完了这个逻辑之后，我们就发现，AutoConfigurationGroup 的process+selectImports的逻辑其实和原先 AutoConfigurationImportSelector 的 selectImports 的逻辑是一致的，只是 selectImports 是直接返回String[]，Spring容器对返回的配置类进行实例化；而process是将所有成员的autoConfigurationEntry放入到一个List中，等所有组成员的autoConfigurationEntry都收集好后，调用selectImports将最终要导入的自动配置类返回回去，供后续的自动装配过程中使用。

2.5.4Spring IOC源码

如果要理解为什么自定义的Bean生效了，自动装配功能就不会将其再次实例化，就必须要去看Spring IOC的源码，但是这已经超出了本文的范畴了，请读者课外了解吧。（如果有读者知道相关文章，希望可以在评论区指一下路。）

2.6@AutoConfigurationPackage

好了现在我们已经大致了解了@Import(AutoConfigurationImportSelector.class)的工作流程，我们回到这个注解的上一个注解：@AutoConfigurationPackage。

@AutoConfigurationPackage用于指示 Spring Boot 在自动配置时要扫描的基础包，可以告诉 Spring Boot 在进行自动装配时应该扫描哪些包来寻找需要自动配置的类。比如我们可能希望自动装配的范围更广，可能需要在多个模块或不同的包中进行自动配置。这时就可以使用 @AutoConfigurationPackage 注解来显式地指定一个基础包，使 Spring Boot 在自动装配时也会扫描该包及其子包下的类。看一下源码：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
    String[] basePackages() default {};
    Class[] basePackageClasses() default {};
}

发现@Import了一个AutoConfigurationPackages的内部类Registrar。看一下他的源码：我们又看到了一个很熟悉的东西——ImportBeanDefinitionRegistrar，我们之前介绍过，这个类是用来以编程方式注册额外的 bean 定义的。

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {//这两个接口用于处理 bean 定义的注册和导入操作
   @Override
   public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
      register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
   }//ImportBeanDefinitionRegistrar接口的方法。
   @Override
   public Set determineImports(AnnotationMetadata metadata) {
      return Collections.singleton(new PackageImports(metadata));
   }//DeterminableImports接口的方法。这个接口的作用是返回一个包含导入信息的集合，以告诉 Spring 容器需要导入哪些额外的类或配置。即在 Spring 容器中注册一个 PackageImports 对象，以供 Spring Boot 的自动配置过程使用，帮助确定需要扫描的基础包范围。
}
public static void register(BeanDefinitionRegistry registry, String... packageNames) {
   if (registry.containsBeanDefinition(BEAN)) {//检查 BeanDefinitionRegistry 是否已经包含名为 BEAN 的 bean 定义，Bean即为"org.springframework.boot.autoconfigure.AutoConfigurationPackage"
      BasePackagesBeanDefinition beanDefinition = (BasePackagesBeanDefinition) registry.getBeanDefinition(BEAN);
      beanDefinition.addBasePackages(packageNames);//如果已存在，则尝试将传入的包名数组添加到现有的 bean 定义中。尝试将传入的包名数组添加到现有的 bean 定义中。
   }
   else {//如果不存在，就创建一个新的 BasePackagesBeanDefinition 对象，并将传入的包名数组作为参数传递给构造函数。然后，使用 BeanDefinitionRegistry 的 registerBeanDefinition 方法将这个新的 bean 定义注册到容器中。
      registry.registerBeanDefinition(BEAN, new BasePackagesBeanDefinition(packageNames));
   }
}
 static final class BasePackagesBeanDefinition extends GenericBeanDefinition {

   private final Set basePackages = new LinkedHashSet<>();

   BasePackagesBeanDefinition(String... basePackages) {
      setBeanClass(BasePackages.class);//设置 bean 类型为 BasePackages.class。这意味着这个 bean 实际上是一个 BasePackages 类型的实例。
      setRole(BeanDefinition.ROLE_INFRASTRUCTURE);//设置 bean 的角色为基础设施（ROLE_INFRASTRUCTURE）。这意味着这个 bean 是一个基础设施类，可能不会被用户直接访问，而是用于内部处理。
      addBasePackages(basePackages);//调用 addBasePackages 方法，将传入的基础包名数组添加到 basePackages 集合中。
   }

   @Override
   public Supplier getInstanceSupplier() {
      return () -> new BasePackages(StringUtils.toStringArray(this.basePackages));
   }

   private void addBasePackages(String[] additionalBasePackages) {
      this.basePackages.addAll(Arrays.asList(additionalBasePackages));
   }

} 
  
看完源码，我们发现他很奇怪地将一个基础包的包名加到了AutoConfigurationPackage的Bean定义中，Spring容器其实会根据这个基础包名进行扫描，并扫描其子包中的类，将这些类进行自动装配。（如何使用BeanDefinition中的包名进行自动装配就是Spring IOC的任务了，这里就省略了。）
 
  
这里的@AutoConfigurationPackage没有加任何参数，说明他就是直接将主启动类的所在的包作为扫描的基础包。其实这个注解不是为了扫描当前包而使用的，因为@ComponentScan已经有这个作用了，其实他的作用就是单纯地把包路径放到Bean容器中，以备后续的使用...（determineImports 方法和 registerBeanDefinitions 其实也有重复的功能，但是它们是在不同的上下文中使用的，这种设计可能是为了让 Spring Boot 的自动配置更加内聚和灵活。）
 
  
2.7TypeExcludeFilter、AutoConfigurationExcludeFilter
 
  
接下来还差一个@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })没有讲，那么就最后讲一下这个注解和这两个过滤器。
 
  
先提到一点，就是其实@AutoConfigurationPackage和@ComponentScan的作用是有重复的，但是他们之间也是有区别的：
 
  
     
   
  • 扫描方式：@ComponentScan 扫描通过 ClassPathBeanDefinitionScanner 类实现扫描；@AutoConfigurationPackage通过注册一个特殊的 BasePackagesBeanDefinition bean 定义来实现，该 bean 存储了需要扫描的基础包名。
    •  
   
  • 使用场景：@ComponentScan 适用于寻找和注册自定义的 Spring 组件，如带有 @Component、@Service、@Repository、@Controller 等注解的类。也可以用于注册带有其他自定义注解的类为 Spring bean；@AutoConfigurationPackage适用于 Spring Boot 自动配置过程，用于控制自动配置时需要扫描的基础包。可以用于在项目中扩展自动配置范围，使得自动装配能够更好地适应多模块或跨包的项目结构。
    •  
  
 
  
这个注解的扫描功能大家都知道，而且是SpringIOC的功能，这里就不讲了，主要还是讲讲两个过滤器的功能。
 
  
2.7.1AutoConfigurationExcludeFilter.class
 
  
还是先讲AutoConfigurationExcludeFilter.class吧，这个简单一点，看源码：AutoConfigurationExcludeFilter的match会对@ComponentScan扫描到的类进行过滤。
 
  
public class AutoConfigurationExcludeFilter implements TypeFilter, BeanClassLoaderAware {
//实现了TypeFilter接口，说明该类是用来过滤被扫描类的。
    private ClassLoader beanClassLoader;

    private volatile List autoConfigurations;

    @Override
    public void setBeanClassLoader(ClassLoader beanClassLoader) {//设置类加载器
        this.beanClassLoader = beanClassLoader;
    }

    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
            throws IOException {
        return isConfiguration(metadataReader) && isAutoConfiguration(metadataReader);
    }

    private boolean isConfiguration(MetadataReader metadataReader) {//判断是否是配置类
        return metadataReader.getAnnotationMetadata().isAnnotated(Configuration.class.getName());//判断有无 @Configuration 注解
    }

    private boolean isAutoConfiguration(MetadataReader metadataReader) {//判断是否是自动配置类或者在自动配置列表中
        boolean annotatedWithAutoConfiguration = metadataReader.getAnnotationMetadata()
            .isAnnotated(AutoConfiguration.class.getName());//判断有无 @AutoConfiguration 注解
        return annotatedWithAutoConfiguration
                || getAutoConfigurations().contains(metadataReader.getClassMetadata().getClassName());//判断是否在自动配置列表中
    }

    protected List getAutoConfigurations() {//这个和之前的EnableAutoConfiguration.class的selectImports函数的getCandidateConfigurations的逻辑是一样的，获得spring.factories和org.springframework.boot.autoconfigure.AutoConfiguration.imports文件中的类。
        if (this.autoConfigurations == null) {
            List autoConfigurations = new ArrayList<>(
                    SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class, this.beanClassLoader));
            ImportCandidates.load(AutoConfiguration.class, this.beanClassLoader).forEach(autoConfigurations::add);
            this.autoConfigurations = autoConfigurations;
        }
        return this.autoConfigurations;
    }

}
 
  
根据上述源码，我们可以得出结论，AutoConfigurationExcludeFilter用于过滤调用同时是@Configuration和自动装配的类，避免可能发生的重复实例化同一个类的 Bean。
 
  
2.7.2TypeExcludeFilter
 
  
TypeExcludeFilter的match同样会对@ComponentScan扫描到的类进行过滤。
 
  
public class TypeExcludeFilter implements TypeFilter, BeanFactoryAware {

   private BeanFactory beanFactory;
   private Collection delegates;

   @Override
   public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
         throws IOException {
      //如果当前的 TypeExcludeFilter 是 TypeExcludeFilter 类的实例，并且 beanFactory 是 ListableBeanFactory，那么会调用其他实现了 TypeExcludeFilter 接口的类的 match 方法来判断是否应该排除当前类。
      if (this.beanFactory instanceof ListableBeanFactory && getClass() == TypeExcludeFilter.class) {
         for (TypeExcludeFilter delegate : getDelegates()) {
            if (delegate.match(metadataReader, metadataReaderFactory)) {
               return true;
            }
         }
      }
      return false;
   }
   private Collection getDelegates() {
      // 获取其他 TypeExcludeFilter 实例的集合。如果 delegates 为空，那么会从 beanFactory 中获取所有实现了 TypeExcludeFilter 接口的 Bean。
      Collection delegates = this.delegates;
      if (delegates == null) {
         delegates = ((ListableBeanFactory) this.beanFactory).getBeansOfType(TypeExcludeFilter.class).values();
         this.delegates = delegates;
      }
      return delegates;
   }
   //...
}
 
  
观察源码，我们发现TypeExcludeFilter 类的match用于统筹所有Bean容器中的TypeExcludeFilter 实例一起进行过滤，但是默认情况下是不会自动注册其他的 TypeExcludeFilter 实例，所以可以忽略。
 
  
补充：自定义的TypeExcludeFilter不能直接使用@Component注解进行配置，因为TypeExcludeFilter要求在@ComponentScan开始扫描前就已经加载包，所以他需要先在spring.factories中添加初始化器，然后再在初始化器中添加自定义TypeExcludeFilter，将其注册到spring容器才行。
 
  
三、代码举例
 
  
3.1自定义ImportBeanDefinitionRegistrar实现、自定义ImportSelector实现、自定义注解，以通过一个注解实现一堆Bean的功能。
 
  
项目结构为
 
  
SpringBoot自动装配源码解析（40000字大章）_第4张图片
 
  
 @SpringBootApplication注解在Main中，会不自动扫描到chilun2包中的组件。在MyController中添加注解@MyEnableAutoConfiguration，将注入pojo类TestC和TestD。
 
  
 
  
先定义两个pojo：我们将会使用ImportBeanDefinitionRegistrar的实现类对TestC进行注入，使用ImportSelector和对应的配置类对TestD进行注入。
 
  
public class TestC {
    @Value("CCC")
    public String name;

    @Override
    public String toString() {
        return "TestC{name='" + name + "\'}";
    }
}
public class TestD {
    @Value("DDD")
    public String name;

    @Override
    public String toString() {
        return "TestD{name='" + name + "\'}";
    }
}
 
  
 
  
然后先是ImportBeanDefinitionRegistrar的动态注入Bean功能：注入了TestC。
 
  
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        registry.registerBeanDefinition("testC",BeanDefinitionBuilder.genericBeanDefinition(TestC.class).getBeanDefinition());
    }
}
 
  
 
  
然后是使用ImportSelector注入配置类，再使用配置类MyConfig注入TestD：
 
  
public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.chilun2.TestMyEnableAutoConfiguration.config.MyConfig"};
    }
}
@Configuration
public class MyConfig {
    @Bean
    public TestD getTestD(){
        return new TestD();
    }
}
 
  
 
  
最后是自定义注解：
 
  
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({MyImportBeanDefinitionRegistrar.class, MyImportSelector.class})
public @interface MyEnableAutoConfiguration {
}
 
  
 
  
然后我们就能直接使用@MyEnableAutoConfiguration来获得TestC和TestD的实例：
 
  
@RestController
@MyEnableAutoConfiguration
public class MyController {
    @Autowired
    TestC testC;

    @Autowired
    TestD testD;

    @GetMapping("/test2")
    public String test2(){
        return testC.toString()+testD.toString();
    }
}
 
  
 
  
执行效果：
 
  
SpringBoot自动装配源码解析（40000字大章）_第5张图片
 
  
3.2自定义Starter
 
  
我们尝试性地写一个很简单很简单的Starter，他的作用是单纯的将一个TestE类的Bean实例进行自动装载（何为自动装载？就是我在测试项目中只需要把那个Starter的依赖导入，然后@Autowired TestE testE，我就能拿到一个完整的testE）。
 
  
3.2.1实现Starter
 
  
好，那就先把Starter写好。
 
  
使用Maven创建一个项目，这是项目结构：
 
  
SpringBoot自动装配源码解析（40000字大章）_第6张图片
 
  
然后是两个pojo的代码，待会测试就是测试这两个pojo能不能直接注入：（已省略getset函数）
 
  
public class TestF {
    @Value("FFF")
    private String name;

}
public class TestE {
    @Value("EEE")
    private String name;

    @Autowired
    private TestF testF;

}
 
  
 然后是自动配置类：（注意看，我们并没有使用什么ConditionOnClass之类的注解，因为那是用来过滤的，我们要的是直接加载，不需要过滤，只需要将这个类写到spring.factories或.imports文件中即可）
 
  
@Configuration
public class MyAutoConfig {

    @Bean
    public TestE testE(){
        return new TestE();
    }

    @Bean
    public TestF testF(){
        return new TestF();
    }
}
 
  
然后是spring.factories文件：
 
  
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.chilun.starter.config.MyAutoConfig
 
  
然后使用maven进行构建一下，把jar包放到本地仓库：（直接在终端输入 mvn install）
 
  
补充一下pom.xml文件，就是加入spring-boot-autoconfigure的依赖即可：
 
  


    4.0.0

    org.example
    MyStarter-spring-boot-starter
    1.0-SNAPSHOT

    
        17
        17
    

    
        
            org.springframework.boot
            spring-boot-autoconfigure
        
    


    
        
            
                
                org.springframework.boot
                spring-boot-dependencies
                2.7.9
                pom
                import
            
        
    

 
  
这是终端输出的结果。
 
  
SpringBoot自动装配源码解析（40000字大章）_第7张图片
 
  
3.2.2测试Starter
 
  

    org.example
    MyStarter-spring-boot-starter
    1.0-SNAPSHOT

 
  
看一下项目结构有没有问题：
 
  
SpringBoot自动装配源码解析（40000字大章）_第8张图片
 
  
 没有什么问题，然后就直接测试：（在RestController中进行测试）
 
  
public class MyController {
    @Autowired
    TestE testE;

    @GetMapping("/test3")
    public String test3(){
        return testE.getTestF().getName();
    }
}
 
  
访问一下：
 
  
SpringBoot自动装配源码解析（40000字大章）_第9张图片
 
  
 很完美，说明自动装配成功。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(SpringBoot框架学习,spring,boot,后端,java)

        

            

                
    
                    
  • 5个月的精华：Spring/SpringBoot扩展点手册：手册在手，编码无忧：全网独一份 - 第451篇
                        悟纤
从零开始学SpringBootspringbootspringspringbootmybatis
                        
    历史文章（文章累计450+）《国内最全的SpringBoot系列之一》《国内最全的SpringBoot系列之二》《国内最全的SpringBoot系列之三》《国内最全的SpringBoot系列之四》《国内最全的SpringBoot系列之五》导读第一篇扩展点文章发表于2022-05-16，至今到这一篇文章耗时5个月左右一方面是总结之前的文章，本文主要是对于这系列的扩展点概念和实战做个汇总。对于Spri
    
                    
    • 
                    
  • Spring容器初始化之BeanFactoryPostProcessor和BeanPostProcessor
                        eighthspace
Spring源码分析记录javaspring
                        
    本文仍然以ClasspathXmlApplicationContext为入口进行记录，通过之前对Spring的学习，我们已知ClasspathXmlApplicationContext构造方法中调用的this.refresh()方法是整个Spring容器初始化的核心方法，refresh()方法调用过程如下：publicvoidrefresh()throwsBeansException,Illega
    
                    
    • 
                    
  • Spring组件初始化扩展点：BeanPostProcessor
                        冬天vs不冷
springspringjava后端
                        
    目录一、概述二、BeanPostProcessor的作用三、核心方法解析1、postProcessBeforeInitialization2、postProcessAfterInitialization四、实战案例案例1：实现简单的属性打印案例2：动态代理增强（模拟AOP）五、常见应用场景六、注意事项七、总结一、概述  在Spring框架中，BeanPostProcessor是一个强大的扩展接口，
    
                    
    • 
                    
  • spring boot 拦截器简单demo
                        测试开发小白变怪兽
服务端springboot后端java
                        
    拦截器（Interceptor）与过滤器的区别特性过滤器（Filter）拦截器（Interceptor）所属规范Servlet规范（javax.servlet）SpringMVC框架（基于AOP实现）作用范围所有请求（包括静态资源）仅拦截Controller的请求执行时机在DispatcherServlet之前执行在Controller方法前后执行访问上下文无法直接获取Spring的Bean或注解
    
                    
    • 
                    
  • Spring Boot 启动报错：Field testMapper in *** required a bean of type ‘***‘ that could not be found.
                        测试开发小白变怪兽
服务端
                        
    SpringBoot工程构建时报错：ErrorstartingApplicationContext.Todisplaytheconditionsreportre-runyourapplicationwith'debug'enabled.2021-03-2310:10:52.451ERROR55881---[main]o.s.b.d.LoggingFailureAnalysisReporter:**
    
                    
    • 
                    
  • 使用MyBatis返回数据为null
                        测试开发小白变怪兽
服务端
                        
    问题：程序里面写的sql语句放到数据库控制台里能查询到数据，但是在MyBatis里查询结果为null。原因：查询出来的字段名与Java实体类的属性名没有一一对应。解决办法：在XML映射文件中使用resultMap将数据库属性名与实体类属性名映射：使用resultMap表明返回类型：select*fromuser_info;
    
                    
    • 
                    
  • Spring Boot 动态配置管理：ZooKeeper 集成与 Redis 配置覆盖实践
                        weixin_43833540
java-zookeeperspringbootzookeeper
                        
    一、引言在微服务架构中，配置管理的动态性与灵活性至关重要。传统通过application.properties/application.yml进行静态配置的方式，已难以满足实时更新需求。本文将详细介绍如何通过ZooKeeper实现SpringBoot应用的Redis配置动态管理，并支持配置热刷新。二、核心实现方案1整体架构设计ZooKeeper作为配置中心存储Redis配置SpringBoot应用
    
                    
    • 
                    
  • Java 分布式高并发重试方案及实现
                        可乐加.糖
java分布式开发语言springbootredis
                        
    文章目录Java分布式高并发重试方案及实现一、重试机制的背景和意义二、基于SpringBoot的重试方案实现1.使用SpringRetry实现重试机制添加依赖开启重试功能定义重试逻辑使用重试服务2.使用Fast-Retry实现高性能重试引入依赖编程式重试注解式重试三、重试机制的注意事项四、总结Java分布式高并发重试方案及实现在分布式系统中，高并发场景下接口调用的稳定性至关重要。为了应对接口调用失
    
                    
    • 
                    
  • 在 Linux 上使用 Docker 部署 Spring Boot 项目
                        ( •̀∀•́ )920
linuxdockerspringboot
                        
    目录1.准备工作1.1SpringBoot项目打包1.2安装Docker2.编写Dockerfile3.构建Docker镜像4.运行Docker容器5.使用DockerCompose（可选）5.1安装DockerCompose5.2编写`docker-compose.yml`5.3启动DockerCompose6.常用管理命令7.高级配置（可选）7.1设置时区7.2使用多阶段构建减少镜像体积8.验
    
                    
    • 
                    
  • Node.js和webpack入门-个人学习笔记
                        ksmswq
node.jswebpack学习
                        
    Node.js-入门Node.js基础概念Node.js是一个跨平台JavaScript运行环境，是开发者可以搭建服务器端的JavaStript应用程序。作用1.编写服务端程序2.编写数据接口，提供网页浏览资源等等3.实现“前端工程化”，为Vue和React等框架做铺垫前端工程化-概念开发项目直到上线，过程中集成的所有工具和技术。（Node.js是前端工程化的基础（因为Node.js可以主动读取前
    
                    
    • 
                    
  • token升级（考虑在分布式环境中布置token，结合session保证请求调用过程中token不会过期。）
                        推荐爱你Jonah
分布式redisjava
                        
    思路：首先，用户的需求是确保使用同一个Token的外部调用都在一个Session中处理。之前的回答提到了Token与Session绑定、安全措施、Session管理、分布式处理等。现在需要用Java来展示这些步骤。我需要考虑Java中常用的框架，比如SpringBoot，因为它广泛用于API开发。同时，使用Redis作为Session存储，这在Java中通常通过SpringDataRedis或Le
    
                    
    • 
                    
  • JAVA 你应该有所了解的布隆过滤器
                        2401_87389661
java开发语言
                        
    该篇文章将会使用最精简易懂的文字以及小图来给大家介绍讲解（不对哈希策略计算进行详解）一.布隆过滤器有啥用？二.布隆过滤器原理是什么？三.java中怎么使用布隆过滤器？本篇文章内容可能较多，所以还请耐心。一.布隆过滤器有啥用简单两点叙述：1.存值存值，就是把值存进去，类似于我们很常用的map，set等；2.检验值是否存在检验，也就是我们想知道某个值是否存在于布隆过滤器里面，调用相关的检验方法，我们会
    
                    
    • 
                    
  • 基于Java的京东电商系统的设计与实现
                        代论文网课招代理
java开发语言
                        
    摘要：近十多年来，因为移动互联网发展迅猛，除了通常的查阅网页，搜索数据和发送电子邮件外，大多数国内网民还将采用以下传统功能，如购物，电信，旅游和娱乐我逐渐习惯了互联网。包括使用在线购物在内的新服务模式正在成为人们生活中一种重要的购物形式。互联网的发展迅猛，是网上购物系统发展的基础。除此之外，网络购物营商环境也在逐渐的在改善。移动互联网设备（手机，平板电脑）使互联网用户越来越多。付款和结算方式变得更
    
                    
    • 
                    
  • LeetCode——5840. 使字符串平衡的最小交换次数(Minimum Number of Swaps to Make the String Balanced)[中等]——分析及代码（Java）
                        江南土豆
数据结构与算法LeetCodeJava题解
                        
    LeetCode——5840.使字符串平衡的最小交换次数[MinimumNumberofSwapstoMaketheStringBalanced][中等]——分析及代码[Java]一、题目二、分析及代码1.贪心（1）思路（2）代码（3）结果三、其他一、题目给你一个字符串s，下标从0开始，且长度为偶数n。字符串恰好由n/2个开括号‘[’和n/2个闭括号‘]’组成。只有能满足下述所有条件的字符串才能称
    
                    
    • 
                    
  • 深入理解Java工厂方法模式：原理剖析与实战应用
                        小诸葛IT课堂
java工厂方法模式开发语言
                        
    一、为什么要学习工厂方法模式？在软件开发中，对象创建是最常见的操作之一。当我们需要创建的对象类型存在多种可能，或者对象的创建过程较为复杂时，如果直接在业务代码中使用new关键字进行实例化，会导致以下问题：代码耦合度高难以扩展新的产品类型违反开闭原则（对扩展开放，对修改关闭）代码重复和可维护性差工厂方法模式（FactoryMethodPattern）正是为了解决这些问题而诞生的经典设计模式。它被广泛
    
                    
    • 
                    
  • 基于python+django+vue.js开发的社区养老管理系统源码+运行步骤
                        冷琴1996
Python系统设计pythondjangovue.js
                        
    业余时间开发的社区养老系统，基于python/vue技术开发。学习过程问题可以留言。功能介绍平台采用B/S结构，后端采用主流的Python语言进行开发，前端采用主流的Vue.js进行开发。功能包括：老人管理、护工管理、亲属管理、病史管理、房间管理、活动管理、用户管理、日志管理、系统信息模块。源码地址https://github.com/geeeeeeeek/python_yanglao演示地址ht
    
                    
    • 
                    
  • 基于 Vue 和 Element Plus 的时间范围控制与数据展示
                        奶糖 肥晨
vuevue.jselementui前端
                        
    文章目录1.核心功能2.实现效果3.代码实现️3.1HTML部分3.2JavaScript部分3.3CSS部分本文将重点讲解如何在Vue项目中使用ElementPlus的el-date-picker组件实现时间范围选择，并结合“日”、“月”、“年”按钮动态控制时间范围。！1.核心功能时间范围选择：使用el-date-picker实现日期范围选择。快速切换：通过“日”、“月”、“年”按钮快速设置时间
    
                    
    • 
                    
  • Manus工作原理：从“思考”到“执行”的AI智能体革命
                        rider189
杂谈javapython人工智能
                        
    读者专属福利：500G+java从入门到精通全套视频课程，加关注提供免费答疑——解析全球首款通用AI代理的底层逻辑引言：AI智能体的新标杆2025年3月，一款名为Manus的AI智能体横空出世，凭借其“自主思考并执行任务”的能力，迅速引爆科技圈与资本市场。它不仅能在云端异步处理复杂任务，还能交付完整成果，从简历筛选到旅行规划，从股票分析到教育课件制作，其应用场景之广令人惊叹。然而，Manus的爆火
    
                    
    • 
                    
  • LeetCode34. 在排序数组中查找元素的第一个和最后一个位置 - Java & Go - 二分查找改进
                        暴风星云裂之我裂开了
LeetCode题解leetcodejavagolang二分查找
                        
    文章目录LeetCode34.在排序数组中查找元素的第一个和最后一个位置解法11算法2Java3Go解法21算法2Java3GoLeetCode34.在排序数组中查找元素的第一个和最后一个位置LeetCode34.在排序数组中查找元素的第一个和最后一个位置解法11算法算法1.两次二分查找2.第一次二分查找计算mid=(left+right)>>1;，每次mid都偏向左边，可以保证找到的是第一个大于
    
                    
    • 
                    
  • Vue.js 事件处理与修饰符详解
                        vvilkim
vuevue.js前端javascript
                        
    Vue.js是一个流行的前端框架，它提供了强大的事件处理机制，使得开发者可以轻松地处理用户交互。Vue的事件处理通过v-on指令实现，同时还提供了丰富的事件修饰符和按键修饰符，帮助我们更高效地处理事件。本文将详细介绍Vue的事件处理机制、修饰符的使用方法，并结合示例代码展示如何在实际开发中应用这些功能。1.v-on指令与事件处理在Vue中，v-on指令用于监听DOM事件，并在事件触发时执行Java
    
                    
    • 
                    
  • 全栈网络安全-渗透测试-2
                        始终奔跑在路上
网络安全web安全安全网络安全
                        
    web架构&常规化&站库分离&前后端分离1.常规化原理：常规化是指源码和数据都部署在同一服务器上。特点：优势：搭建便捷，自定义程度高。劣势：安全性较低，因为数据库和代码在同一服务器上，容易被攻击。适用场景：适合小型项目或个人开发，对安全性要求不高的场景。2.站库分离原理：源码和数据库分别部署在不同的服务器上。特点：优势：提高了安全性，因为数据库被单独存放，攻击者即使获取了服务器权限，也难以直接访问
    
                    
    • 
                    
  • 海思 HI 35xx u-boot+kernel+rootfs移植
                        晓鹏-King
ARMubootLinuxlinux海思ubootkernelrootfs
                        
    PC端开发环境安装：sudo./sdk.unpack报如下错误：./sdk.unpack:7:./sdk.unpack:WARN:notfound./sdk.unpack:8:./sdk.unpack:ECHO:notfound./sdk.unpack:20:./sdk.unpack:ECHO:notfound./sdk.unpack:22:./sdk.unpack:run_command_pro
    
                    
    • 
                    
  • python 如何引入同一个文件夹下py方法
                        m0_68335176
eclipse
                        
    前言毕业快三年了，前后也待过几家公司，碰到各种各样的同事。见识过各种各样的代码，优秀的、垃圾的、不堪入目的、看了想跑路的等等，所以这篇文章记录一下一个优秀的后端Java开发应该有哪些好的开发习惯。拆分合理的目录结构受传统的MVC模式影响，传统做法大多是几个固定的文件夹controller、service、mapper、entity，然后无限制添加，到最后你就会发现一个service文件夹下面有几十
    
                    
    • 
                    
  • B/S vs C/S架构：技术选型与实战对比
                        码农阿豪@新空间
包罗万象c语言架构开发语言
                        
    个人名片作者简介：java领域优质创作者个人主页：码农阿豪工作室：新空间代码工作室（提供各种软件服务)个人邮箱：[[email protected]]个人微信：15279484656个人导航网站：www.forff.top座右铭：总有人要赢。为什么不能是我呢？专栏导航：码农阿豪系列专栏导航面试专栏：收集了java相关高频面试题，面试实战总结️Spring5系列专栏：整理了Spring5重要知识点与
    
                    
    • 
                    
  • Tauri+Dotnet+Vue3+Vite桌面应用程序创建
                        是楊不是杨
前后端vue.netcorerust前端框架
                        
    环境需求Node.js(已安装)Rust(安装Rust，必要).NETCoreSDK(用于后端)TauriCLI(通过Rust安装)1.创建Vue3+Vite前端项目初始化项目：bash复制代码npmcreatevite@latesttauri-vue3-dotnet--templatevuecdtauri-vue3-dotnet安装必要依赖：bash复制代码npminstall启动开发服务器，确
    
                    
    • 
                    
  • java.lang.NoSuchMethodError: org.springframework.data.redis.core.StringRedisTemplate.delete redis
                        羽 毛
javaredisspringspringboot分布式
                        
    java.lang.NoSuchMethodError:org.springframework.data.redis.core.StringRedisTemplate.delete(Ljava/lang/Object;)V在springboot2.0.0以上的版本中已经有独立的redis包了redis.clientsjedis</<
    
                    
    • 
                    
  • 通过Java代码实现ping功能测试ip地址与ip:port的连通性
                        Java大侠
业务代码java功能测试
                        
    通过Java代码实现测试ip地址与ip:port的连通性需求分析具体实现测试ip连通性测试ip:port连通性重试机制需求分析最近在业务中，需要添加一种掉线告警系统。大致思路为：通过定时任务扫描，每一个小时判断一次设备是否在线，如果在线继续判断端口是否能够通讯。如果不在线或者不能通讯，需要及时push消息给告警人员，及时处理。具体实现测试ip连通性主要通过InetAddress类来实现/***@p
    
                    
    • 
                    
  • Failed to instantiate [org.springframework.data.redis.connection.jedis.JedisConnectionFactory实例化配置失败
                        道阻且长-行则将至-行而不辍-未来可期
redis缓存springbootspring
                        
    前言：主要最近重构升级底层依赖版本，导致原先的一个系统以及完全起不来了。原来的SpringBoot版本是2.0.3.RELEASE我这边给升级到SpringBoot版本：[2.3.12.RELEASE],Spring版本：[5.2.15.RELEASE]原来的一些配置都会失效，导致错误不断，用了一个星期左右来进行解决这些问题，问题很多但是记录下来的就这些吧，以供后来者学习一下，避免跳进这些坑。目录
    
                    
    • 
                    
  • Servlet 点击计数器
                        lsx202406
开发语言
                        
    Servlet点击计数器引言随着互联网的快速发展，Web应用程序已成为人们日常生活中不可或缺的一部分。Servlet作为Java平台上用于开发Web应用程序的重要技术之一，已经广泛应用于各种Web项目中。本文将详细介绍Servlet点击计数器的实现方法，帮助读者更好地理解Servlet技术在实际开发中的应用。Servlet点击计数器概述Servlet点击计数器是一种用于记录Web页面点击次数的组件
    
                    
    • 
                    
  • 快速搭建学生信息查询 RESTFul API：Django-Rest-Framework 实现
                        富阔典

                        
    快速搭建学生信息查询RESTFulAPI：Django-Rest-Framework实现【下载地址】Django-Rest-Framework学生信息查询RESTFulAPI实现代码本仓库提供了一个基于Django-Rest-Framework的学生信息查询RESTFulAPI实现代码。通过该代码，您可以快速搭建一个用于查询学生信息的后端服务，并支持RESTFulAPI接口项目地址:https:/
    
                    
    • 
                                
  • Spring的注解积累
                                    yijiesuifeng
spring注解
                                    
    用注解来向Spring容器注册Bean。 
  
需要在applicationContext.xml中注册： 
<context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。 
如：在base-package指明一个包    
<context:component-sc
    
                                
    • 
                                
  • 传感器
                                    百合不是茶
android传感器
                                    
    android传感器的作用主要就是来获取数据,根据得到的数据来触发某种事件 
  
下面就以重力传感器为例; 
  
1,在onCreate中获得传感器服务 
  
private SensorManager sm;// 获得系统的服务
	private Sensor sensor;// 创建传感器实例

	@Override
	protected void 
    
                                
    • 
                                
  • [光磁与探测]金吕玉衣的意义
                                    comsci

                                    
          这是一个古代人的秘密:现在告诉大家 
 
      信不信由你们: 
 
      穿上金律玉衣的人,如果处于灵魂出窍的状态,可以飞到宇宙中去看星星 
 
      这就是为什么古代
    
                                
    • 
                                
  • 精简的反序打印某个数
                                    沐刃青蛟
打印
                                    
    以前看到一些让求反序打印某个数的程序。 
比如：输入123，输出321。 
  
记得以前是告诉你是几位数的，当时就抓耳挠腮，完全没有思路。 
  
似乎最后是用到%和/方法解决的。 
  
而今突然想到一个简短的方法，就可以实现任意位数的反序打印（但是如果是首位数或者尾位数为0时就没有打印出来了） 
  
代码如下： 
	long num, num1=0;
    
                                
    • 
                                
  • PHP：6种方法获取文件的扩展名
                                    IT独行者
PHP扩展名
                                    
      
PHP：6种方法获取文件的扩展名 
  
1、字符串查找和截取的方法 
       1      
$extension 
= 
substr 
( 
strrchr 
( 
$file 
,  
'.' 
), 1);       
2、字符串查找和截取的方法二 
       1      
$extension 
= 
substr 
    
                                
    • 
                                
  • 面试111
                                    文强chu
面试
                                    
     1事务隔离级别有那些 ，事务特性是什么（问到一次）
 2 spring aop 如何管理事务的，如何实现的。动态代理如何实现，jdk怎么实现动态代理的，ioc是怎么实现的，spring是单例还是多例，有那些初始化bean的方式，各有什么区别（经常问）
 3 struts默认提供了那些拦截器 （一次）
 4 过滤器和拦截器的区别 （频率也挺高）
 5 final，finally final
    
                                
    • 
                                
  • XML的四种解析方式
                                    小桔子
domjdomdom4jsax
                                    
    在平时工作中，难免会遇到把 XML 作为数据存储格式。面对目前种类繁多的解决方案，哪个最适合我们呢？在这篇文章中，我对这四种主流方案做一个不完全评测，仅仅针对遍历 XML 这块来测试，因为遍历 XML 是工作中使用最多的（至少我认为）。 　　预 备 　　测试环境： 　　AMD 毒龙1.4G OC 1.5G、256M DDR333、Windows2000 Server 
    
                                
    • 
                                
  • wordpress中常见的操作
                                    aichenglong
中文注册wordpress移除菜单
                                    
    1 wordpress中使用中文名注册解决办法 
  1)使用插件 
  2)修改wp源代码 
     进入到wp-include/formatting.php文件中找到 
      function sanitize_user( $username, $strict = false 
    
                                
    • 
                                
  • 小飞飞学管理-1
                                    alafqq
管理
                                    
    项目管理的下午题，其实就在提出问题（挑刺），分析问题，解决问题。 
今天我随意看下10年上半年的第一题。主要就是项目经理的提拨和培养。 
结合我自己经历写下心得 
 
对于公司选拔和培养项目经理的制度有什么毛病呢？ 
1，公司考察，选拔项目经理，只关注技术能力，而很少或没有关注管理方面的经验，能力。 
2，公司对项目经理缺乏必要的项目管理知识和技能方面的培训。 
3，公司对项目经理的工作缺乏进行指
    
                                
    • 
                                
  • IO输入输出部分探讨
                                    百合不是茶
IO
                                    
     
 //文件处理  在处理文件输入输出时要引入java.IO这个包； 
/* 
1，运用File类对文件目录和属性进行操作 
2，理解流，理解输入输出流的概念 
3，使用字节/符流对文件进行读/写操作 
4，了解标准的I/O 
5，了解对象序列化 
*/ 
  
//1，运用File类对文件目录和属性进行操作 
  
//在工程中线创建一个text.txt
    
                                
    • 
                                
  • getElementById的用法
                                    bijian1013
element
                                    
            getElementById是通过Id来设置/返回HTML标签的属性及调用其事件与方法。用这个方法基本上可以控制页面所有标签，条件很简单，就是给每个标签分配一个ID号。 
       返回具有指定ID属性值的第一个对象的一个引用。 
       语法： 
&n
    
                                
    • 
                                
  • 励志经典语录
                                    bijian1013
励志人生
                                    
    经典语录1:  
  哈佛有一个著名的理论：人的差别在于业余时间，而一个人的命运决定于晚上8点到10点之间。每晚抽出2个小时的时间用来阅读、进修、思考或参加有意的演讲、讨论，你会发现，你的人生正在发生改变，坚持数年之后，成功会向你招手。不要每天抱着QQ/MSN/游戏/电影/肥皂剧……奋斗到12点都舍不得休息，看就看一些励志的影视或者文章，不要当作消遣；学会思考人生，学会感悟人生
    
                                
    • 
                                
  • [MongoDB学习笔记三]MongoDB分片
                                    bit1129
mongodb
                                    
    MongoDB的副本集(Replica Set)一方面解决了数据的备份和数据的可靠性问题，另一方面也提升了数据的读写性能。MongoDB分片(Sharding)则解决了数据的扩容问题，MongoDB作为云计算时代的分布式数据库，大容量数据存储，高效并发的数据存取，自动容错等是MongoDB的关键指标。 
本篇介绍MongoDB的切片(Sharding) 
  1.何时需要分片 
&nbs
    
                                
    • 
                                
  • 【Spark八十三】BlockManager在Spark中的使用场景
                                    bit1129
manager
                                    
    1. Broadcast变量的存储，在HttpBroadcast类中可以知道 
2. RDD通过CacheManager存储RDD中的数据，CacheManager也是通过BlockManager进行存储的 
3. ShuffleMapTask得到的结果数据，是通过FileShuffleBlockManager进行管理的，而FileShuffleBlockManager最终也是使用BlockMan
    
                                
    • 
                                
  • yum方式部署zabbix
                                    ronin47
yum方式部署zabbix
                                    
    安装网络yum库#rpm -ivh http://repo.zabbix.com/zabbix/2.4/rhel/6/x86_64/zabbix-release-2.4-1.el6.noarch.rpm 通过yum装mysql和zabbix调用的插件还有agent代理#yum install zabbix-server-mysql zabbix-web-mysql mysql-
    
                                
    • 
                                
  • Hibernate4和MySQL5.5自动创建表失败问题解决方法
                                    byalias
J2EEHibernate4
                                    
    今天初学Hibernate4，了解了使用Hibernate的过程。大体分为4个步骤： 
①创建hibernate.cfg.xml文件 
②创建持久化对象 
③创建*.hbm.xml映射文件 
④编写hibernate相应代码 
在第四步中，进行了单元测试，测试预期结果是hibernate自动帮助在数据库中创建数据表，结果JUnit单元测试没有问题，在控制台打印了创建数据表的SQL语句，但在数据库中
    
                                
    • 
                                
  • Netty源码学习-FrameDecoder
                                    bylijinnan
javanetty
                                    
    Netty 3.x的user guide里FrameDecoder的例子，有几个疑问： 
 1.文档说：FrameDecoder calls decode method with an internally maintained cumulative buffer whenever new data is received. 
 为什么每次有新数据到达时，都会调用decode方法？ 
 2.Dec
    
                                
    • 
                                
  • SQL行列转换方法
                                    chicony
行列转换
                                    
      
  
create table tb(终端名称 varchar(10) , CEI分值 varchar(10) , 终端数量 int) 
insert into tb values('三星' , '0-5' , 74) 
insert into tb values('三星' , '10-15' , 83) 
insert into tb values('苹果' , '0-5' , 93) 

    
                                
    • 
                                
  • 中文编码测试
                                    ctrain
编码
                                    
    循环打印转换编码 
 

String[] codes = {
    "iso-8859-1",
    "utf-8",
    "gbk",
    "unicode"
};

for (int i = 0; i < codes.length; i++) {
    for (int j 
    
                                
    • 
                                
  • hive 客户端查询报堆内存溢出解决方法
                                    daizj
hive堆内存溢出
                                    
    hive> select * from t_test where ds=20150323 limit 2; 
OK 
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space 
  
问题原因： hive堆内存默认为256M 
  
这个问题的解决方法为： 
修改/us
    
                                
    • 
                                
  • 人有多大懒，才有多大闲 (评论『卓有成效的程序员』)
                                    dcj3sjt126com
程序员
                                    
      
卓有成效的程序员给我的震撼很大，程序员作为特殊的群体，有的人可以这么懒，  懒到事情都交给机器去做 ，而有的人又可以那么勤奋，每天都孜孜不倦得做着重复单调的工作。 
  
在看这本书之前，我属于勤奋的人，而看完这本书以后，我要努力变成懒惰的人。 
不要在去庞大的开始菜单里面一项一项搜索自己的应用程序，也不要在自己的桌面上放置眼花缭乱的快捷图标
    
                                
    • 
                                
  • Eclipse简单有用的配置
                                    dcj3sjt126com
eclipse
                                    
    1、显示行号  Window -- Prefences -- General -- Editors -- Text Editors -- show line numbers 
  
2、代码提示字符 Window ->Perferences，并依次展开 Java -> Editor -> Content Assist，最下面一栏 auto-Activation
    
                                
    • 
                                
  • 在tomcat上面安装solr4.8.0全过程
                                    eksliang
Solrsolr4.0后的版本安装solr4.8.0安装
                                    
    转载请出自出处：
http://eksliang.iteye.com/blog/2096478  
      首先solr是一个基于java的web的应用，所以安装solr之前必须先安装JDK和tomcat，我这里就先省略安装tomcat和jdk了 
        
第一步：当然是下载去官网上下载最新的solr版本，下载地址
    
                                
    • 
                                
  • Android APP通用型拒绝服务、漏洞分析报告
                                    gg163
漏洞androidAPP分析
                                    
    点评：记得曾经有段时间很多SRC平台被刷了大量APP本地拒绝服务漏洞，移动安全团队爱内测（ineice.com）发现了一个安卓客户端的通用型拒绝服务漏洞，来看看他们的详细分析吧。  
0xr0ot和Xbalien交流所有可能导致应用拒绝服务的异常类型时，发现了一处通用的本地拒绝服务漏洞。该通用型本地拒绝服务可以造成大面积的app拒绝服务。  
针对序列化对象而出现的拒绝服务主要
    
                                
    • 
                                
  • HoverTree项目已经实现分层
                                    hvt
编程.netWebC#ASP.ENT
                                    
    HoverTree项目已经初步实现分层，源代码已经上传到 http://hovertree.codeplex.com请到SOURCE CODE查看。在本地用SQL Server 2008 数据库测试成功。数据库和表请参考：http://keleyi.com/a/bjae/ue6stb42.htmHoverTree是一个ASP.NET 开源项目，希望对你学习ASP.NET或者C#语言有帮助，如果你对
    
                                
    • 
                                
  • Google Maps API v3: Remove Markers 移除标记
                                    天梯梦
google maps api
                                    
    Simply do the following: 
  
I. Declare a global variable: 
var markersArray = []; 
  
II. Define a function: 
function clearOverlays() {
  for (var i = 0; i < markersArray.length; i++ )
    
                                
    • 
                                
  • jQuery选择器总结
                                    lq38366
jquery选择器
                                    
           1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28   29   30   31   32   33   34   35   36   37   38   39   40
    
                                
    • 
                                
  • 基础数据结构和算法六：Quick sort
                                    sunwinner
AlgorithmQuicksort
                                    
    Quick sort is probably used more widely than any other. It is popular because it is not difficult to implement, works well for a variety of different kinds of input data, and is substantially faster t
    
                                
    • 
                                
  • 如何让Flash不遮挡HTML div元素的技巧_HTML/Xhtml_网页制作
                                    刘星宇
htmlWeb
                                    
    今天在写一个flash广告代码的时候，因为flash自带的链接，容易被当成弹出广告，所以做了一个div层放到flash上面，这样链接都是a触发的不会被拦截，但发现flash一直处于div层上面，原来flash需要加个参数才可以。 
 
让flash置于DIV层之下的方法，让flash不挡住飘浮层或下拉菜单，让Flash不档住浮动对象或层的关键参数：wmode=opaque。 
 
方法如下： 
 
    
                                
    • 
                                
  • Mybatis实用Mapper SQL汇总示例
                                    wdmcygah
sqlmysqlmybatis实用
                                    
    Mybatis作为一个非常好用的持久层框架，相关资料真的是少得可怜，所幸的是官方文档还算详细。本博文主要列举一些个人感觉比较常用的场景及相应的Mapper SQL写法，希望能够对大家有所帮助。 
不少持久层框架对动态SQL的支持不足，在SQL需要动态拼接时非常苦恼，而Mybatis很好地解决了这个问题，算是框架的一大亮点。对于常见的场景，例如：批量插入/更新/删除，模糊查询，多条件查询，联表查询，
    
                                
    •