手撸一个Spring Boot Starter并上传到Maven中央仓库

手撸一个Spring Boot Starter并上传到Maven中央仓库，可以大致分成以下步骤：

一、准备工作

1. 创建一个Maven项目

在本地创建一个Maven项目，包含一个POM文件和一个src目录。可以使用Eclipse、IntelliJ IDEA等开发工具，也可以手工创建。

2. 引入相关依赖

在POM文件中引入Spring Boot和相关依赖，并指定版本号，例如：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.4</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>

3. 定义Starter核心类

定义一个类作为Starter的核心类，该类通常实现了Spring Boot中AutoConfiguration接口，例如：

@Configuration
@EnableConfigurationProperties(MyProperties.class)
@ConditionalOnClass(MyService.class)
@EnableConfigurationProperties(MyProperties.class)
public class MyAutoConfiguration {

    @Autowired
    private MyProperties myProperties;

    @Bean
    @ConditionalOnMissingBean
    public MyService myService() {
        return new MyService(myProperties.getName());
    }

}

二、创建Starter所需的资源

1.创建application.properties

在资源目录src/main/resources下创建application.properties文件，该文件用于定义Starter所需的配置信息，例如：

my.name=default_value

2.创建README.md

在项目根目录下创建README.md文件，用于说明该Starter的使用方式、功能等信息。

三、测试Starter

1. 创建测试项目

在本地创建一个测试项目，引入刚才创建的Starter，并写一个简单的测试类，例如：

@SpringBootTest
class MyApplicationTests {

    @Autowired
    private MyService myService;

    @Test
    void contextLoads() {
        assertNotNull(myService);
    }

}

2. 执行测试

运行测试类，查看是否能够正常加载配置文件，并注入MyService。

四、打包并上传到Maven中央仓库

1. 打包

执行mvn clean install命令，将Starter打包成jar包。

2. 上传至Maven中央仓库

注册Maven Central账号；
登录Maven Central Repository的Web UI；
新建Maven Repository Hosting的仓库，即Staging-Profile，并填写相关信息；
用Maven插件sonatype-nexus-staging-maven-plugin将Starter发布到刚才创建的这个Staging-Profile中：

$ mvn deploy -Prelease -DskipTests

执行Staging-Repo的Close按钮，等待审核通过之后点击Release按钮。

至此，手撸的Spring Boot Starter已经成功上传至Maven中央仓库，并可以作为依赖被其他项目引用使用。

示例一：MyTranslatorStarter

以一个简单的示例—翻译器为例，手撸一个Spring Boot Starter，并上传到Maven中央仓库。

创建Maven项目

$ mvn archetype:generate -DgroupId=com.example -DartifactId=my-translator-starter -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.4</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>

创建核心类

@Configuration
@EnableConfigurationProperties(MyTranslatorProperties.class)
@EnableAutoConfiguration
public class MyTranslatorAutoConfiguration {

    @Autowired
    private MyTranslatorProperties myTranslatorProperties;

    @Bean
    @ConditionalOnMissingBean
    public Translator translator() {
        return new Translator(myTranslatorProperties.getFrom(), myTranslatorProperties.getTo());
    }
}

创建配置文件

在resources目录下创建application.properties文件

my.translator.from=en
my.translator.to=zh

创建测试类

@SpringBootTest
class MyTranslatorStarterApplicationTests {

    @Autowired
    private Translator translator;

    @Test
    void contextLoads() {
        assertNotNull(translator);
        assertEquals("你好，世界！", translator.translate("Hello, World!"));
    }

}

打包并上传至Maven中央仓库
在项目中引入该Starter，并使用

在pom.xml中引入该Starter

<dependency>
    <groupId>com.example</groupId>
    <artifactId>my-translator-starter</artifactId>
    <version>1.0.0</version>
</dependency>

在main方法中使用

@SpringBootApplication
public class DemoApplication {

    @Autowired
    private Translator translator;

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @GetMapping("/hello")
    public String hello(@RequestParam("word") String word) {
        return translator.translate(word);
    }
}

现在运行该程序，并打开浏览器访问
http://localhost:8080/hello?word=Hello,%20World!

你将会看到：“你好，世界！”几个汉字。

示例二：MyDockerStarter

以Docker的Java API-kit为例实现一个Starter，支持Java应用创建、打架docker镜像、上传至容器仓库等操作。

创建Maven项目

$ mvn archetype:generate -DgroupId=com.example -DartifactId=my-docker-starter -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

引入依赖

<dependency>
    <groupId>com.github.docker-java</groupId>
    <artifactId>docker-java-core</artifactId>
    <version>3.2.5</version>
</dependency>
<dependency>
    <groupId>com.github.docker-java</groupId>
    <artifactId>docker-java</artifactId>
    <version>3.2.5</version>
</dependency>

创建核心类

@Configuration
public class DockerAutoConfiguration {

    @Value("${docker.registry.url}")
    private String registryUrl;

    @Value("${docker.registry.username}")
    private String registryUsername;

    @Value("${docker.registry.password}")
    private String registryPassword;

    @Autowired
    private DockerClient dockerClient;

    @Bean
    public DockerUtil dockerUtil() {
        return new DockerUtil(dockerClient, registryUrl, registryUsername, registryPassword);
    }

    @Bean
    @ConditionalOnMissingBean
    public DockerClient dockerClient() {
        DefaultDockerClientConfig config = DefaultDockerClientConfig.createDefaultConfigBuilder().build();
        return DockerClientBuilder.getInstance(config).build();
    }

}

创建配置文件

在resources目录下创建application.properties文件，并填写配置信息

docker.registry.url=https://hub.docker.com/v2
docker.registry.username=MyUserName
docker.registry.password=MyPassword

创建测试类

详见：https://github.com/malathion/my-docker-starter/blob/main/src/test/java/com/example/DockerStarterApplicationTests.java

打包并上传至Maven中央仓库
在项目中引入该Starter，并使用