仅需四步，写一个springboot starter

最新推荐文章于 2024-07-11 18:41:25 发布
最新推荐文章于 2024-07-11 18:41:25 发布
阅读量473 收藏
点赞数
分类专栏： Spring 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/floor2011/article/details/107569972
版权

这个系列分为5篇

1. @Component，@Service等注解是如何被解析的

2. @Enable驱动原理

3. @EnableAutoConfiguration处理逻辑

4. spring，springBoot事件

5.仅需四步，写一个springboot starter

引言

只要你用Springboot，一定会用到各种spring-boot-starter。其实写一个spring-boot-starter

，仅需4步。下面我们就写一个starter，它将实现，在日志中打印方法执行时间。

 

第一步 创建maven项目

在使用spring-boot-starter，会发现，有的项目名称是 XX-spring-boot-starter，有的是

spring-boot-starter-XX，这个项目的名称有什么讲究呢？

从springboot官方文档摘录如下：

Do not start your module names with spring-boot, even if you use a different Maven groupId. We may offer official support for the thing you auto-configure in the future.

As a rule of thumb, you should name a combined module after the starter.

从这段话可以看出spring-boot-starter命名的潜规则。

命名潜规则

spring-boot-starter-XX是springboot官方的starter

XX-spring-boot-starter是第三方扩展的starter

打印方法执行时间的功能，需要用到aop，咱们的项目就叫做

aspectlog-spring-boot-starter吧。

项目的pom文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>aspectlog-spring-boot-starter</artifactId>
    <version>1.0.2</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.15.RELEASE</version>
    </parent>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

</project>

关于spring-boot-configuration-processor的说明，引自springBoot官方文档：

 

Spring Boot uses an annotation processor to collect the conditions on auto-configurations in a metadata file ( META-INF/spring-autoconfigure-metadata.properties ). If that file is present, it is used to eagerly filter auto-configurations that do not match, which will improve startup time. It is recommended to add the following dependency in a module that contains auto-configurations:

<dependency>

<groupId> org.springframework.boot </groupId>

<artifactId> spring-boot-autoconfigure-processor </artifactId>

<optional> true </optional>

</dependency>

 

简单说就是 写starter时，在pom中配置 spring-boot-autoconfigure-processor，

在编译时会自动收集配置类的条件，写到一个 META-INF/spring-autoconfigure-metadata.properties中。

 

第二步写自动配置逻辑

各种condition

 

类型注解说明

Class Conditions

类条件注解

@ConditionalOnClass

当前classpath下

有指定类才加载

@ConditionalOnMissingClass

当前classpath下

无指定类才加载

Bean Conditions

Bean条件注解

@ConditionalOnBean

当期容器内有

指定bean才加载

@ConditionalOnMissingBean

当期容器内无

指定bean才加载

Property Conditions

环境变量条件

注解（含配置文件）

@ConditionalOnProperty

prefix  前缀

name 名称

havingValue

 用于匹配配置项值

matchIfMissing  

没找指定配置项时

的默认值

Resource

Conditions

 资源条件注解

@ConditionalOnResource有指定资源才加载

Web Application Conditions

web条件注解

@ConditionalOnWebApplication是web才加载
@ConditionalOnNotWebApplication不是web才加载
SpEL Expression Conditions@ConditionalOnExpression符合SpEL 表达式才加载

本次我们就选用@ConditionalOnProperty。即配置文件中有aspectLog.enable=true，才加载我们的配置类。

下面开始写自动配置类

 

2.1.定义AspectLog注解，该注解用于标注需要打印执行时间的方法。

package com.shanyuan.autoconfiguration.aspectlog;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * class_name: ScheduleManage
 * describe:   用于控制定时任务的开启与关闭
 * 对应切面
 * creat_user: wenl
 * creat_time:  2018/11/10 18:45
 **/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface   AspectLog {
}

2.2定义配置文件对应类

package com.shanyuan.autoconfiguration.aspectlog;
import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties("aspectLog")
public class AspectLogProperties {
    private boolean enable;
    public boolean isEnable() {
        return enable;
    }
    public void setEnable(boolean enable) {
        this.enable = enable;
    }
}

2.3定义自动配置类

 

package com.shanyuan.autoconfiguration.aspectlog;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.condition.*;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.core.PriorityOrdered;

@Aspect
@EnableAspectJAutoProxy(exposeProxy = true, proxyTargetClass = true)
@Configuration
@ConditionalOnProperty(prefix = "aspectLog", name = "enable",
                     havingValue = "true", matchIfMissing = true)
public class AspectLogAutoConfiguration implements PriorityOrdered {

    protected Logger logger = LoggerFactory.getLogger(getClass());

@Around("@annotation(com.shanyuan.autoconfiguration.aspectlog.AspectLog) ")
    public Object isOpen(ProceedingJoinPoint thisJoinPoint) 
                                        throws Throwable {
        //执行方法名称 
        String taskName = thisJoinPoint.getSignature()
            .toString().substring(
                thisJoinPoint.getSignature()
                    .toString().indexOf(" "), 
                    thisJoinPoint.getSignature().toString().indexOf("("));
        taskName = taskName.trim();
        long time = System.currentTimeMillis();
        Object result = thisJoinPoint.proceed();
        logger.info("method:{} run :{} ms", taskName, 
                            (System.currentTimeMillis() - time));
        return result;
    }
    @Override
    public int getOrder() {
        //保证事务等切面先执行
        return Integer.MAX_VALUE;
    }
}

配置类简要说明：

@ConditionalOnProperty(prefix = "aspectLog", name = "enable",havingValue = "true", matchIfMissing = true)

当配置文件有aspectLog.enable=true时开启，如果配置文件没有设置aspectLog.enable也开启。

 

第三步META-INF/spring.factories

META-INF/spring.factories是spring的工厂机制，在这个文件中定义的类，都会被自动加载。多个配置使用逗号分割，换行用\

如果有兴趣可以查看这2篇blog：

2.@Enable驱动原理(设置连接)

3.@EnableAutoConfiguration处理逻辑(设置连接)

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.shanyuan.autoconfiguration.aspectlog.AspectLogAutoConfiguration
wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

第四步打包测试

这是我们最终的目录结构

在IDEA中，进行mvn intall

 

打包完成后，在其他项目中的pom中引入进行测试

 

参考资料

https://docs.spring.io/spring-boot/docs/2.1.15.RELEASE/reference/html/boot-features-developing-auto-configuration.html#boot-features-custom-starter

 

 

温安适
关注
专栏目录
手把手带你编写属于自己的 Starter
band_mmbx的博客
08-11 815
再编写 starter 之前我们先了解一下什么是 starter，一个 starter 其实就是对一个功能的集成封装，然后对外提供一个依赖，让业务去使用，像我们熟悉的 Redis，mongo，mybatis 等。另外由于任何人都可以编写自己的 starter，那么为了区分官方的 starter 和个人的 starter，通常在命名上面会有一个规范。...
教你如何开发一个 SpringBoot starter
ywl470812087的博客
12-25 1300
starter 是 SpringBoot 的一个重要的组成部分，它相当于一个集成的模块，比如你想用 Mybatis 和 lombok，但是在 pom 文件中需要写两个依赖，如果你将他们集成为一个 starter（或者将更多你需要的依赖集成进去），那么你只需要在 pom 文件中写一个 starter 依赖就可以了，这对于一个可复用模块的开发和维护都极为有利。当然我当时确实水平不足，连 Java 的 SPI 都忘了是啥，后来又捡了起来，原来我在大学的时候就用过 Java 的 SPI，悔之晚矣！
写一个的spring-boot-starter
qq_39052947的博客
12-13 1100
自定义一个spring-boot-starter及源码简析
【SpringBoot】手写一个简单的SpringBoot-starter
花&败
02-24 447
starter会把所有用到的依赖都给包含进来，避免了开发者自己去引入依赖所带来的麻烦。 虽然不同的starter实现起来各有差异，但是他们基本上都会使用到两个相同的内容：ConfigurationProperties和AutoConfiguration。 Starters are a set of convenient dependency descriptors that you can include in your application. Starters 是一组可以让你很方便在应用.
如何使用SpringBoot写一个属于自己的Starter
Java鱼仔的博客
03-09 5089
写一个starter原来并不难
SpringBoot自己开发一个starter
最新发布
weixin_60523038的博客
07-11 1346
SpringBoot自己写一个Starter，SpringBoot
springboot手写一个自己的starter
08-25
SpringBoot 手写一个自己的 Starter SpringBoot 的强大之处就在于其自动配置机制，而这个机制的实现正是依赖于那些starter。starter 是 SpringBoot 的核心组件之一，它提供了一种非常便捷的方式来配置和实现自动...
从零开始写一个SpringBoot Starter
01-20
Starter是Spring Boot 中的一个非常重要的概念，Starter相当于模块，它能将模块所需的依赖整合起来并对模块内的Bean根据环境进行自动装配。使用者只需要依赖响应功能的Starter，无需做过多的配置和依赖，SpringBoot...
SpringBoot Starter模板
11-26
SpringBoot Starter模板是Spring Boot框架中的一个重要组成部分，它旨在简化应用程序的初始搭建和配置过程。Spring Boot通过Starters提供了一种“开箱即用”的体验，使得开发者可以快速地构建基于Spring的应用。在这...
手把手教你手写一个最简单的 Spring Boot Starter
2401_84048832的博客
04-07 656
引领完成Docker的安装、部署、管理和扩展，让其经历从测试到生产的整个开发生命周期，深入了解Docker适用于什么场景。并且这本Docker的学习权威指南介绍了其组件的基础知识，然后用Docker构建容器和服务来完成各种任务：利用Docker为新项目建立测试环境，演示如何使用持续集成的工作流集成Docker，如何构建应用程序服务和平台，如何使用Docker的API，如何扩展Docker。
如何自己实现一个Spring Boot Starter
如无必要勿增实体
01-21 1717
使用AOP实现拦截方法执行和打印日志的功能import org} }} }} }} }如果我们需要从 application.yaml 或 application.properties 中拿到一些使用者配置的数据，那么我们就需要定义一个properties类。
如何写一个简单的spring boot starter~
HeiheiChihiro的博客
10-14 253
在开始手写starter前，先去看懂springboot自动加载的原理~ 写一个普通类，里面要写上各种属性，以便我们自动配置。 @Data public class ShareDemo { private String name; private Integer age; private Boolean real; private String desc; } 创建一个autoconfigure包，在里面写该类的自动配置类，和属性类(属性类也可以放在另外一.
手写一个简单的SpringBoot Starter
weixin_46034642的博客
06-04 207
SpringBoot的自定义starter
写了一个自己的spring-boot-start，亲测可用
方圆 Blog
08-09 496
目录1. 先给你看看整体布局1.1 pom文件1.2 HelloService1.3 HelloServiceProperties1.4 HelloServiceConfiguration1.5 spring.factories2. 测试 1. 先给你看看整体布局 1.1 pom文件 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-in.
看，教你手写一个最简单的SpringBoot Starter
m0_63437643的博客
01-09 197
所以我们将这些可独立于业务代码之外的功能配置模块封装成一个 Starter，在需要用到此功能模块的项目中，只需要在其 pom.xml 文件中引用依赖即可，SpringBoot 帮我们完成自动装配，而且我们还可以在配置文件中调整 Starter 中默认的配置信息。通过 Starter，能够简化以前繁杂的配置，无需过多的配置和依赖，它会帮你合并依赖，并且将其统一集成到一个 Starter 中，我们只需在 Maven 或 Gradle 中引入 Starter 依赖即可。你可以理解为一个可拔插式的插件（组件）。
如何写一个springboot的starter
weixin_43929900的博客
08-10 872
首先第一步，创建一个maven项目 Spring 官方建议自定义的 starter 使用 xxx-spring-boot-starter 命名规则 第二步在pom.xml中加入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId>
如何写一个springboot-starter
cxclll的博客
07-11 547
一般来说，starter里面会定义各种bean，当主项目引用starter的时候，需要知道程序启动的时候需要加载哪些bean，怎么做呢在这个配置文件上面标注好，需要加载哪些bean然后添加spring.factories 文件，这个文件是干嘛用的就不用多说了吧，相信大家背八股文时里面有一个问springboot-starter的工作原理的问题，都应该见过吧指向我们的配置类即可。到此，一个简单的springboot-starter就开发完成了。
手写一个springboot-starter
09-05
当然可以！以下是一个简单的示例，展示了如何手写一个Spring Boot Starter： 首先，创建一个 Maven 项目，并添加以下依赖项： ```xml <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> <version>2.5.4</version> </dependency> </dependencies> ``` 接下来，创建一个自定义的自动配置类，用于配置你的 Starter： ```java @Configuration @EnableConfigurationProperties(MyStarterProperties.class) public class MyStarterAutoConfiguration { private final MyStarterProperties properties; public MyStarterAutoConfiguration(MyStarterProperties properties) { this.properties = properties; } // 在此处定义你的自动配置逻辑 @Bean public MyStarterService myStarterService() { return new MyStarterService(properties); } } ``` 然后，创建一个属性类，用于将外部配置绑定到属性上： ```java @ConfigurationProperties("my.starter") public class MyStarterProperties { private String message; // 提供 getter 和 setter } ``` 最后，创建一个自定义的服务类，该服务类将在你的 Starter 中使用： ```java public class MyStarterService { private final MyStarterProperties properties; public MyStarterService(MyStarterProperties properties) { this.properties = properties; } public void showMessage() { System.out.println(properties.getMessage()); } } ``` 现在，你的 Spring Boot Starter 已经准备就绪了！你可以将其打包并使用在其他 Spring Boot 项目中。在其他项目的 `pom.xml` 文件中，添加你的 Starter 依赖： ```xml <dependencies> <dependency> <groupId>com.example</groupId> <artifactId>my-starter</artifactId> <version>1.0.0</version> </dependency> </dependencies> ``` 然后，在你的应用程序中使用 `MyStarterService`： ```java @SpringBootApplication public class MyApplication implements CommandLineRunner { private final MyStarterService myStarterService; public MyApplication(MyStarterService myStarterService) { this.myStarterService = myStarterService; } public static void main(String[] args) { SpringApplication.run(MyApplication.class, args); } @Override public void run(String... args) throws Exception { myStarterService.showMessage(); } } ``` 这样，你就成功地创建了一个简单的 Spring Boot Starter！当其他项目引入你的 Starter 并运行时，将会输出预定义的消息。 当然，这只是一个简单的示例，真实的 Starter 可能包含更多的配置和功能。你可以根据自己的需求进行扩展和定制。希望对你有所帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值