第一步：starter 模块（依赖管理功能）#

aliyun-oss-spring-boot-starter/pom.xml——注意它只有依赖，没有代码：

1
<parent>
2
    <groupId>org.springframework.boot</groupId>
3
    <artifactId>spring-boot-starter-parent</artifactId>
4
    <version>3.2.10</version>
5
    <relativePath/> <!-- lookup parent from repository -->
6
</parent>
7
<groupId>com.aliyun.oss</groupId>
8
<artifactId>aliyun-oss-spring-boot-starter</artifactId>
9
<version>0.0.1-SNAPSHOT</version>
10
...
11
<dependencies>
12
    <dependency>
13
        <groupId>org.springframework.boot</groupId>
14
        <artifactId>spring-boot-starter</artifactId>
15
    </dependency>
16

17
    <dependency>
18
        <groupId>com.aliyun.oss</groupId>
19
        <artifactId>aliyun-oss-spring-boot-autoconfigure</artifactId>
20
        <version>0.0.1-SNAPSHOT</version>
21
    </dependency>
22
</dependencies>

关键就是最后那个依赖——starter 引入 autoconfigure，于是使用方引 starter 时，靠 Maven 的依赖传递（89 篇起步依赖那一节）把 autoconfigure 模块一路带过去，连带 autoconfigure 自己依赖的阿里云 SDK 也一起到位。

第二步：autoconfigure 模块（自动配置功能）#

aliyun-oss-spring-boot-autoconfigure/pom.xml 里装着组件真正需要的东西：

1
<groupId>com.aliyun.oss</groupId>
2
<artifactId>aliyun-oss-spring-boot-autoconfigure</artifactId>
3
<version>0.0.1-SNAPSHOT</version>
4
...
5
<dependencies>
6
    <dependency>
7
        <groupId>org.springframework.boot</groupId>
8
        <artifactId>spring-boot-starter</artifactId>
9
    </dependency>
10

11
    <!--阿里云OSS依赖-->
12
    <dependency>
13
        <groupId>com.aliyun.oss</groupId>
14
        <artifactId>aliyun-sdk-oss</artifactId>
15
        <version>3.17.4</version>
16
    </dependency>
17
    <dependency>
18
        <groupId>javax.xml.bind</groupId>
19
        <artifactId>jaxb-api</artifactId>
20
        <version>2.3.1</version>
21
    </dependency>
22
    <dependency>
23
        <groupId>javax.activation</groupId>
24
        <artifactId>activation</artifactId>
25
        <version>1.1.1</version>
26
    </dependency>
27
    <!-- no more than 2.3.3-->
28
    <dependency>
29
        <groupId>org.glassfish.jaxb</groupId>
30
        <artifactId>jaxb-runtime</artifactId>
31
        <version>2.3.3</version>
32
    </dependency>
33
</dependencies>

这正是”依赖管理功能”的实质：那”三个 jaxb 兄弟”是 73 篇里必须自己补上的坐标——现在它们被封在 starter 里，使用方再也不用记这一串。

第三步：写作三个类 + 一个名字很长的文件#

autoconfigure 模块里一共三个 Java 文件：

① 工具类 AliyunOSSOperator——从工程里搬过来，但去掉 @Component，改成构造方法接收参数对象：

1
package com.aliyun.oss;
2

3
public class AliyunOSSOperator {
4

5
    private AliyunOSSProperties aliyunOSSProperties;
6

7
    public AliyunOSSOperator(AliyunOSSProperties aliyunOSSProperties) {
8
        this.aliyunOSSProperties = aliyunOSSProperties;
9
    }
10

11
    public String upload(byte[] content, String originalFilename) throws Exception {
12
        String endpoint = aliyunOSSProperties.getEndpoint();
13
        String bucketName = aliyunOSSProperties.getBucketName();
14
        String region = aliyunOSSProperties.getRegion();
15
        // ... 后面就是原来那套 OSS 上传逻辑（创建 OSSClient、putObject、返回访问地址）
16
    }
17
}

② 参数类 AliyunOSSProperties——同样去掉 @Component，只保留绑定前缀的注解（它怎么变成 bean，交给下面的自动配置类负责）：

1
package com.aliyun.oss;
2

3
import org.springframework.boot.context.properties.ConfigurationProperties;
4

5
@ConfigurationProperties(prefix = "aliyun.oss")
6
public class AliyunOSSProperties {
7
    private String endpoint;
8
    private String bucketName;
9
    private String region;
10
    // ... getter / setter（课程代码里是手写的，也可以用 Lombok 的 @Data）
11
}

③ 自动配置类 AliyunOSSAutoConfiguration——这是全篇的核心，只有短短几行：

1
package com.aliyun.oss;
2

3
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
4
import org.springframework.boot.context.properties.EnableConfigurationProperties;
5
import org.springframework.context.annotation.Bean;
6
import org.springframework.context.annotation.Configuration;
7

8
/**
9
 * AliyunOSS的自动配置类
10
 */
11
@EnableConfigurationProperties(AliyunOSSProperties.class)
12
@Configuration
13
public class AliyunOSSAutoConfiguration {
14

15
    @Bean
16
    @ConditionalOnMissingBean
17
    public AliyunOSSOperator aliyunOSSOperator(AliyunOSSProperties aliyunOSSProperties){
18
        return new AliyunOSSOperator(aliyunOSSProperties);
19
    }
20

21
}

三行注解各司其职，正好把 88 篇与 89 篇的知识点用齐了：

④ 那个名字很长的文件——自动配置类写好了还不够，SpringBoot 不认识它。按 89 篇源码跟踪的结论，自动配置类必须登记在约定文件里：

1
src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

文件内容只有一行（全类名）：

1
com.aliyun.oss.AliyunOSSAutoConfiguration

一、知识回顾（读完直接做下面的实践题）#

1. 场景、做法与本篇目标：开发中经常要定义公共组件提供给各个团队使用，SpringBoot 项目里一般把公共组件封装成 starter——它同时包含起步依赖（依赖管理功能）和自动配置（自动配置功能）两块能力，SpringBoot 官方与其它技术提供的 starter 都是这个结构；本篇的需求就是自定义 aliyun-oss-spring-boot-starter 完成 AliyunOSSOperator 的自动配置，目标是引入起步依赖之后，注入 AliyunOSSOperator 直接使用即可
2. 两个能力分别落在哪：依赖管理功能在 starter 模块自己的 pom.xml 里（引入 autoconfigure 模块，靠依赖传递把 SDK 等一起带过去）；自动配置功能在 autoconfigure 模块里（自动配置类 + .imports 名单文件）
3. 三个步骤：① 创建 aliyun-oss-spring-boot-starter 模块；② 创建 aliyun-oss-spring-boot-autoconfigure 模块，并在 starter 中引入该模块；③ 在 autoconfigure 模块中定义自动配置功能，并定义自动配置文件 META-INF/spring/xxxx.imports（完整文件名是 org.springframework.boot.autoconfigure.AutoConfiguration.imports）
4. 两个模块里各装什么：starter 模块通常只有 pom.xml（可以一个类都没有）——依赖 spring-boot-starter 与 aliyun-oss-spring-boot-autoconfigure；autoconfigure 模块里装着工具类 AliyunOSSOperator、参数类 AliyunOSSProperties、自动配置类 AliyunOSSAutoConfiguration 和 resources/META-INF/spring/ 下那个 .imports 文件，pom 里放组件真正需要的依赖（aliyun-sdk-oss、jaxb 三兄弟等）
5. 工具类与参数类的改造：都去掉 @Component（第三方组件不能依赖使用方的组件扫描）；工具类改成构造方法接收 AliyunOSSProperties；参数类保留 @ConfigurationProperties(prefix = "aliyun.oss")，由自动配置类上的注解启用
6. 自动配置类的写法：类上 @EnableConfigurationProperties(AliyunOSSProperties.class) + @Configuration；方法上 @Bean + @ConditionalOnMissingBean（使用方自己定义了同类型 bean 时自动配置让位）；方法形参写参数类型，容器按类型自动装配
7. .imports 文件：路径 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports，一行一个自动配置类全类名（com.aliyun.oss.AliyunOSSAutoConfiguration）；SpringBoot 启动时由 AutoConfigurationImportSelector 读它
8. 使用方要做的三件事：① pom 里加一行 starter 依赖；② application.yml 里配前缀对应的参数（aliyun.oss.endpoint / bucketName / region）；③ 直接 @Autowired 注入工具类——不写任何 @Component / @Configuration / @Import
9. 本机实测：两个模块先 mvn clean install 装进本地仓库（本机仓库在 A:\develop\maven\apache-maven-3.9.14\mvn_repo\，所以打了 -s settings.xml）；测试工程只加一行依赖 + 三项配置后访问 /check，返回 AliyunOSSOperator 已自动装配: true , 实例: com.aliyun.oss.AliyunOSSOperator@38ec98ee——两个能力（依赖管理 + 自动配置）同时被验证
10. 版本差异：2.7.0 之前自动配置类登记在 META-INF/spring.factories（按 org.springframework.boot.autoconfigure.EnableAutoConfiguration= 的键写），是历史写法；本机 Spring Boot 3.2.x 走的是 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports（一行一个全类名）

二、裸写题#

• 2-1 把公共组件拆成两个模块，并说清各自装什么 需求：你的团队要发布一个公共组件给其它项目用，约定叫 aliyun-oss-spring-boot-starter。 要求： ① 画出两个模块的名字与依赖方向，说明哪个模块管”带哪些依赖进来”、哪个模块管”使用方不写配置就能注入”； ② 写出 starter 模块的 pom 依赖部分（要有哪两个依赖、其中哪个是本组件自己的模块）； ③ 说出组件真正需要的第三方坐标（阿里云 SDK 与”三个 jaxb 兄弟”）应该写在哪个模块的 pom 里，为什么； ④ 回答：为什么 starter 模块里通常一个 Java 类都没有？ （写作区见练习文件 test_90_自定义starter.txt 的题目2-1。）

  提示（先自己想，实在想不出再点开）

  一级 · 思路：一个模块专门”带货”（依赖），一个模块专门”干活”（自动配置）；使用方只引”带货”的那个，另一个靠依赖传递跟进来 二级 · 方法：两个模块名 aliyun-oss-spring-boot-starter 与 aliyun-oss-spring-boot-autoconfigure（同 groupId、同版本）；starter 的依赖是 spring-boot-starter + aliyun-oss-spring-boot-autoconfigure；组件用到的第三方坐标（com.aliyun.oss:aliyun-sdk-oss、javax.xml.bind:jaxb-api、javax.activation:activation、org.glassfish.jaxb:jaxb-runtime）写在使用到它们的模块里 三级 · 骨架：

  1
  <dependency>
  2
      <groupId>org.springframework.boot</groupId>
  3
      <artifactId>spring-boot-starter</artifactId>
  4
  </dependency>
  5
  <dependency>
  6
      <groupId>com.aliyun.oss</groupId>
  7
      <artifactId>____</artifactId>
  8
      <version>0.0.1-SNAPSHOT</version>
  9
  </dependency>

  参考答案（做完再点开）

  ① 模块结构与依赖方向：

  1
  aliyun-oss-spring-boot-starter         ← 依赖管理功能（管"带哪些依赖进来"）
  2
          │ 依赖
  3
          ▼
  4
  aliyun-oss-spring-boot-autoconfigure   ← 自动配置功能（管"不写配置就能注入"）

  ② starter 模块的依赖部分：

  1
  <dependencies>
  2
      <dependency>
  3
          <groupId>org.springframework.boot</groupId>
  4
          <artifactId>spring-boot-starter</artifactId>
  5
      </dependency>
  6
  
  7
      <dependency>
  8
          <groupId>com.aliyun.oss</groupId>
  9
          <artifactId>aliyun-oss-spring-boot-autoconfigure</artifactId>
  10
          <version>0.0.1-SNAPSHOT</version>
  11
      </dependency>
  12
  </dependencies>

  ③ 写在 autoconfigure 模块的 pom 里——因为工具类 AliyunOSSOperator 就在这个模块里编译，它用到的 aliyun-sdk-oss、jaxb 三兄弟必须在这个模块声明；使用方引 starter 时，这些坐标靠依赖传递自动到位（这也正是”依赖管理功能”的实现方式）。 ④ 因为它的职责只有”声明依赖”：starter 自己不写代码，引什么由 pom 说、干活的代码在 autoconfigure 模块里。这样分工的好处是职责清晰，将来要调整”带哪些依赖”不用碰自动配置代码。 自查：把使用方工程里除 starter 之外的所有相关依赖删掉再编译——能编译过、能启动，就说明依赖被 starter 带进来了。

• 2-2 写这个公共组件的自动配置功能（三个类 + 一个文件） 需求：组件的工具类 AliyunOSSOperator（构造方法需要一个参数对象 AliyunOSSProperties，参数对象要能读到配置文件里 aliyun.oss 前缀下的 endpoint / bucketName / region）已经搬进 autoconfigure 模块了。要求写出自动配置功能： ① 工具类与参数类分别要怎么改（原来它们靠”交给容器管理”的注解生效，现在这条路不能走了）； ② 自动配置类（类上、方法上各写什么，方法里干什么，形参谁来传）； ③ 自动配置类的登记文件：完整路径与文件内容； ④ 回答：如果使用方自己在工程里定义了一个同类型的工具类 bean，你的 starter 会怎么表现？靠哪个注解保证的？ （写作区见练习文件 test_90_自定义starter.txt 的题目2-2。）

  提示（先自己想，实在想不出再点开）

  一级 · 思路：第三方组件不能指望”被使用方扫描到”，所以两个类都别再标”交给容器管理”的注解——工具类改成构造接收参数对象，参数类只留”绑定前缀”，由自动配置类统一把它们造出来；最后别忘了登记文件，否则 SpringBoot 根本不知道有这个自动配置类 二级 · 方法：类上 @EnableConfigurationProperties(AliyunOSSProperties.class) + @Configuration（顺序无所谓）；方法上 @Bean + @ConditionalOnMissingBean，返回 new AliyunOSSOperator(aliyunOSSProperties)；登记文件 src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports，内容一行全类名；“让位”靠 @ConditionalOnMissingBean 三级 · 骨架：

  1
  public class AliyunOSSOperator {
  2
      private AliyunOSSProperties aliyunOSSProperties;
  3
      public AliyunOSSOperator(____ aliyunOSSProperties) { this.aliyunOSSProperties = aliyunOSSProperties; }
  4
  }
  5
  
  6
  @____(prefix = "aliyun.oss")
  7
  public class AliyunOSSProperties { private String endpoint; /* ... */ }
  8
  
  9
  @____(AliyunOSSProperties.class)
  10
  @____
  11
  public class AliyunOSSAutoConfiguration {
  12
      @____
  13
      @____
  14
      public AliyunOSSOperator aliyunOSSOperator(____ props) { return new AliyunOSSOperator(props); }
  15
  }

  显示更多显示更少

  ③ 路径 src/main/resources/____/____/org.springframework.boot.autoconfigure.____.imports

  参考答案（做完再点开）

  ① 两个类的改造：都去掉 @Component——工具类改成构造方法接收参数对象；参数类只留 @ConfigurationProperties(prefix = "aliyun.oss")（以及 getter/setter），它由自动配置类上的 @EnableConfigurationProperties 启用：

  1
  public class AliyunOSSOperator {
  2
      private AliyunOSSProperties aliyunOSSProperties;
  3
      public AliyunOSSOperator(AliyunOSSProperties aliyunOSSProperties) {
  4
          this.aliyunOSSProperties = aliyunOSSProperties;
  5
      }
  6
      public String upload(byte[] content, String originalFilename) throws Exception { /* OSS 上传逻辑 */ }
  7
  }

  1
  @ConfigurationProperties(prefix = "aliyun.oss")
  2
  public class AliyunOSSProperties {
  3
      private String endpoint;
  4
      private String bucketName;
  5
      private String region;
  6
      // getter / setter
  7
  }

  ② 自动配置类：

  1
  package com.aliyun.oss;
  2
  
  3
  import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
  4
  import org.springframework.boot.context.properties.EnableConfigurationProperties;
  5
  import org.springframework.context.annotation.Bean;
  6
  import org.springframework.context.annotation.Configuration;
  7
  
  8
  @EnableConfigurationProperties(AliyunOSSProperties.class)   // 让参数类成为 bean 并绑定 aliyun.oss 前缀
  9
  @Configuration
  10
  public class AliyunOSSAutoConfiguration {
  11
  
  12
      @Bean
  13
      @ConditionalOnMissingBean                                // 使用方自己定义了就让位
  14
      public AliyunOSSOperator aliyunOSSOperator(AliyunOSSProperties aliyunOSSProperties){
  15
          return new AliyunOSSOperator(aliyunOSSProperties);   // 形参由容器按类型自动装配
  16
      }
  17
  }

  显示更多显示更少

  ③ 登记文件：

  1
  src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

  内容一行：

  1
  com.aliyun.oss.AliyunOSSAutoConfiguration

  （2.7.0 之前写在 META-INF/spring.factories 里，是历史写法；本机 Spring Boot 3.2.x 读的是 .imports。） ④ 使用方自己定义过同类型 bean 时，自动配置类里那个 @Bean 方法不会执行——容器里用使用方定义的那个，应用照常启动、注入也不会报”同类型 bean 有两个”。保证这件事的注解是 @ConditionalOnMissingBean：判断环境中没有对应的 bean（按类型或名称）时才注册。本机实测过：加上自定义 bean 后，控制台打印了 [实验] 自定义的 AliyunOSSOperator bean 被创建，应用正常启动，/check 依然能注入。 自查：把自动配置类的登记文件删掉（或改个名字）再启动使用方工程——注入会失败（找不到 bean），这就是”登记文件是必需品”的证明。

• 2-3 把”我的组件怎么才能被别的工程用上”讲清楚 需求：同事问你三个问题，请写清楚： ① 为什么不能把工具类的源码直接拷给别的团队用（至少两条理由）； ② 打包好的两个模块要怎么”交付”给别的工程，包管理器层面做了什么动作、跟只打 package 有什么区别； ③ 使用方接入你的组件要做哪几件事，其中哪几件是”必须的”。 （写作区见练习文件 test_90_自定义starter.txt 的题目2-3。）

  提示（先自己想，实在想不出再点开）

  一级 · 思路：① 从”重复维护”和”依赖与配置都得自己补”两个角度说；② 关键词是”装进本地仓库”与”打进 target”的区别；③ 数一数使用方写的东西：依赖、配置、注入 二级 · 方法：mvn clean install（install 会把 jar 装进本地仓库，package 只到 target/）；使用方 pom 一行依赖 + yml 参数（前缀与参数类 prefix 一致）+ @Autowired 注入；install 安装顺序：先 autoconfigure 再 starter（被依赖的先装） 三级 · 骨架：① 拷贝源码 → 每个团队各维护一份，改一次要改 N 处；而且 OSS 的 SDK 与 jaxb 三兄弟还得各自补；② 在组件模块里执行 mvn ____ → 装进本地仓库；③ 使用方：____ 一行依赖、____ 参数、____ 注入

  参考答案（做完再点开）

  ① 不拷源码的理由：重复维护——每个团队各存一份，组件一改就要挨个通知、挨个改；依赖与配置也得自己补——OSS 的 SDK 与那三个 jaxb 坐标要各自加一遍，工具类的 bean 也要各自声明（73 篇就是这么干的，麻烦之处都见过）；此外还有版本失控的问题（各团队引的版本可能不一致）。做成 starter 后，这些都被封进依赖里。 ② 交付方式：在两个模块的目录下分别执行 mvn clean install——install 会把打好的 jar 装进本地仓库（本机是 A:\develop\maven\apache-maven-3.9.14\mvn_repo\com\aliyun\oss\...）；package 只把 jar 打进工程的 target/ 目录，本地仓库里没有，别的工程就引不到。顺序上先 install autoconfigure、再 install starter（被依赖的模块要先在仓库里）。 ③ 使用方要做三件事：pom 里加一行 starter 依赖（必须）、application.yml 里写参数（aliyun.oss 三项，按需必须——组件要和 OSS 通信就得配）、@Autowired 注入工具类（用的时候写）。不必须的是任何配置类、任何 @Component、任何 @Import——这三样一件都不用写，正是”自动配置功能”省下来的。 自查：本机实测的结果是 /check 返回 AliyunOSSOperator 已自动装配: true , 实例: com.aliyun.oss.AliyunOSSOperator@38ec98ee——使用方工程里确实没有任何配置代码。

三、综合题#

• 3-1 照课程案例做一个自己的 starter，并让另一个工程用起来 这一题把 PPT 第 36 页的三步完整走一遍，每一步都要能说出”为什么这么做”。

  1. 建 aliyun-oss-spring-boot-autoconfigure 模块：把工具类与参数类搬进来（去掉 @Component，工具类改成构造方法接收参数对象），pom 里补上组件需要的依赖（阿里云 SDK + 三个 jaxb 坐标）；
  2. 在 autoconfigure 模块里写自动配置类：类上 @EnableConfigurationProperties(...) + @Configuration，方法上 @Bean + @ConditionalOnMissingBean；
  3. 新建登记文件（注意目录与文件名的每一个字），写入自动配置类的全类名；
  4. 建 aliyun-oss-spring-boot-starter 模块：pom 里依赖 spring-boot-starter 与你的 autoconfigure 模块（starter 里不写代码）；
  5. 依次 install 两个模块进本地仓库（先 autoconfigure、再 starter），记下控制台里 Installing ... to ... 那两行；
  6. 另建（或用课程给的）测试工程：只做三件事——加一行 starter 依赖、在 yml 里写 aliyun.oss 三项参数、在 Controller 里 @Autowired 注入工具类并提供 /check 接口；
  7. 启动测试工程，把 /check 的返回原文抄下来，确认”自动装配 = true”；
  8. 做”让位”对照实验：在测试工程里自己用 @Bean 定义一个同类型的工具类 bean（打印一句话），重启后看控制台有没有出现你那句话、有没有报”同类型 bean 有两个”的错；
  9. 收尾回答：① 两个能力分别由哪部分提供？② 使用方为什么不用写任何配置类？③ 本机读的是 .imports 还是 spring.factories？

  （练习文件 test_90_自定义starter.txt 的”综合题”一段里按这 9 步给了写作区。）

  涉及知识点

  知识点	在这里的应用
  场景与两个能力（PPT 35）	第 1、4 步——依赖管理放 starter、自动配置放 autoconfigure
  三个步骤（PPT 36）	第 1～4 步——建两个模块、引入、写自动配置 + imports
  第三方 Bean 与 @Bean（88 篇）	第 2 步——@Configuration + @Bean + 形参自动装配
  @ConditionalOnMissingBean（89 篇）	第 2、8 步——使用方定义了就让位
  .imports 名单文件（89 篇源码跟踪）	第 3 步——路径与文件名的每一个字都不能改
  install 与本地仓库（26 篇）	第 5 步——装进本地仓库别的工程才能引用
  本机实测（第 14 章 ）	第 5～8 步的对照答案——/check 返回”已自动装配: true”
  版本差异	第 9 步——本机 3.2.x 走 .imports，spring.factories 是历史写法

  提示（先自己想，实在想不出再点开）

  一级 · 思路：按”依赖 → 自动配置 → 登记 → 使用”的顺序做，每完成一步都先想”使用方少写了什么”；第 8 步的对照实验是把 89 篇那个实测再做一次，只是这次组件是你自己写的 二级 · 方法：类上 @EnableConfigurationProperties + @Configuration；方法上 @Bean + @ConditionalOnMissingBean；登记文件 src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports；mvn clean install（本机本地仓库换过位置，打包时用 -s settings.xml）；使用方 yml 的前缀与参数类 prefix 一致（aliyun.oss）；“同类型 bean 有两个”的报错关键词是 NoUniqueBeanDefinitionException 三级 · 骨架：① @____(AliyunOSSProperties.class) + @____；@____ + @____；③ 文件路径 META-INF/spring/org.springframework.boot.autoconfigure.____.imports；⑤ mvn clean ____；⑥ 使用方 pom 一整块依赖 + yml 的 aliyun: → oss: 三项 + Controller 里 @____ private AliyunOSSOperator ____;；⑧ @____ public class MyConfig { @____ public AliyunOSSOperator ____() { ... } }

  参考答案（做完再点开）

  1~4. 模块、pom、三个类与登记文件见 2-1、2-2 的答案（自动配置类是 @EnableConfigurationProperties(AliyunOSSProperties.class) + @Configuration，方法上 @Bean + @ConditionalOnMissingBean；登记文件里一行全类名 com.aliyun.oss.AliyunOSSAutoConfiguration）。 5. 本机实测：两条 mvn -s settings.xml clean install 的控制台里分别出现

  1
  Installing ... to A:\develop\maven\apache-maven-3.9.14\mvn_repo\com\aliyun\oss\aliyun-oss-spring-boot-autoconfigure\0.0.1-SNAPSHOT\...
  2
  Installing ... to A:\develop\maven\apache-maven-3.9.14\mvn_repo\com\aliyun\oss\aliyun-oss-spring-boot-starter\0.0.1-SNAPSHOT\...

  6. 测试工程那三件事：pom 一行 com.aliyun.oss:aliyun-oss-spring-boot-starter:0.0.1-SNAPSHOT；yml 里 aliyun.oss 的 endpoint / bucketName / region；Controller 里 @Autowired private AliyunOSSOperator aliyunOSSOperator;（这个类型来自 starter 的包，工程里没有它的源码）。
  7. 本机实测：/check 返回原文——

     1
     AliyunOSSOperator 已自动装配: true , 实例: com.aliyun.oss.AliyunOSSOperator@38ec98ee

  8. 本机实测：加上自定义的 @Bean 后控制台出现 [实验] 自定义的 AliyunOSSOperator bean 被创建，应用正常启动（Started SpringbootAutoconfigurationTestApplication in 2.084 seconds），/check 依然能注入，没有 NoUniqueBeanDefinitionException——说明自动配置类里那个带 @ConditionalOnMissingBean 的方法让位了。
  9. 三个回答： ① 依赖管理功能由 starter 模块的 pom 提供（引入 autoconfigure，连带阿里云 SDK 与 jaxb 三兄弟一起进来）；自动配置功能由 autoconfigure 模块提供（自动配置类 + .imports 登记文件）。 ② 因为自动配置类已经把”造哪些 bean”写好了，而 .imports 文件让 SpringBoot 在启动时自动读到它（AutoConfigurationImportSelector 读名单 → @Conditional 条件满足 → 注册 bean）——使用方不需要再写 @Component / @Configuration / @Import 中的任何一个。 ③ 本机是 Spring Boot 3.2.x，读的是 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports；spring.factories 是 2.7.0 之前的历史写法。