Spring Starter 实现方案

作为Java架构师，手动实现一个Spring Starter是一个很好的实践。下面我将提供一个详细的方案，包括设计、实现和验证步骤。

1. 设计方案

1.1 Starter 功能定位

首先明确starter的功能，假设我们要实现一个"请求日志记录starter"，它能自动记录所有进入Controller的请求信息。

1.2 模块划分

建议采用两模块结构：

1. my-spring-boot-autoconfigure - 包含自动配置核心逻辑
2. my-spring-boot-starter - 空模块，只包含对autoconfigure的依赖

1.3 技术组件

• Spring Boot AutoConfiguration
• Spring Boot Conditional注解
• Spring AOP (用于拦截请求)
• 自定义属性配置(通过@ConfigurationProperties)

2. 实现步骤

2.1 创建项目结构

my-request-logging-starter/
├── my-spring-boot-autoconfigure
│   ├── src/main/java
│   │   └── com/example/autoconfigure
│   ├── src/main/resources
│   │   └── META-INF
│   └── pom.xml
└── my-spring-boot-starter
    └── pom.xml

2.2 实现自动配置模块

2.2.1 添加依赖(pom.xml)

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-autoconfigure</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
    </dependency>
</dependencies>

2.2.2 创建配置属性类

@ConfigurationProperties(prefix = "request.logging")
public class RequestLoggingProperties {
    private boolean enabled = true;
    private Level level = Level.INFO;
    private boolean includeHeaders = false;
    
    // 枚举和getter/setter省略
}

2.2.3 实现请求日志切面

@Aspect
public class RequestLoggingAspect {
    private static final Logger logger = LoggerFactory.getLogger(RequestLoggingAspect.class);
    
    private final RequestLoggingProperties properties;
    
    public RequestLoggingAspect(RequestLoggingProperties properties) {
        this.properties = properties;
    }
    
    @Around("@within(org.springframework.web.bind.annotation.RestController) || " +
            "@within(org.springframework.stereotype.Controller)")
    public Object logRequest(ProceedingJoinPoint joinPoint) throws Throwable {
        if (!properties.isEnabled()) {
            return joinPoint.proceed();
        }
        
        HttpServletRequest request = 
            ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest();
        
        // 记录请求信息
        logRequestDetails(request);
        
        try {
            Object result = joinPoint.proceed();
            logResponseDetails(request, result);
            return result;
        } catch (Exception e) {
            logErrorDetails(request, e);
            throw e;
        }
    }
    
    private void logRequestDetails(HttpServletRequest request) {
        // 实现请求日志记录逻辑
    }
}

2.2.4 创建自动配置类

@Configuration
@ConditionalOnWebApplication
@EnableConfigurationProperties(RequestLoggingProperties.class)
@ConditionalOnClass({DispatcherServlet.class, Aspect.class})
public class RequestLoggingAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnProperty(prefix = "request.logging", name = "enabled", havingValue = "true", matchIfMissing = true)
    public RequestLoggingAspect requestLoggingAspect(RequestLoggingProperties properties) {
        return new RequestLoggingAspect(properties);
    }
}

2.2.5 创建spring.factories

在src/main/resources/META-INF/下创建spring.factories文件：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.autoconfigure.RequestLoggingAutoConfiguration

2.3 实现Starter模块

2.3.1 添加依赖(pom.xml)

<dependencies>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>my-spring-boot-autoconfigure</artifactId>
        <version>${project.version}</version>
    </dependency>
</dependencies>

3. 使用示例

3.1 在应用中添加依赖

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

3.2 配置属性(application.yml)

request:
  logging:
    enabled: true
    level: DEBUG
    include-headers: true

4. 验证方案

4.1 单元测试

为自动配置模块编写单元测试：

@SpringBootTest
public class RequestLoggingAutoConfigurationTest {
    
    @Autowired(required = false)
    private RequestLoggingAspect aspect;
    
    @Test
    public void testAutoConfigurationEnabled() {
        assertNotNull(aspect);
    }
    
    @Test
    @DirtiesContext
    @EnableAutoConfiguration(exclude = RequestLoggingAutoConfiguration.class)
    public void testAutoConfigurationDisabled() {
        assertNull(aspect);
    }
}

4.2 集成测试

创建一个测试Spring Boot应用：

1. 添加starter依赖
2. 创建几个Controller
3. 发送请求并验证日志输出

4.3 条件验证

• 验证当request.logging.enabled=false时切面不生效
• 验证不同日志级别的输出
• 验证包含header和不包含header的情况

4.4 性能测试

使用JMeter或类似工具测试starter引入的性能影响

5. 高级考虑

5.1 自定义注解

可以添加自定义注解来更精细地控制哪些请求需要记录：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LogRequest {
    Level value() default Level.INFO;
    boolean includeHeaders() default false;
}

5.2 指标收集

集成Micrometer来提供请求指标：

@Bean
public MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
    return registry -> registry.config().commonTags("application", "request-logging-starter");
}

5.3 自定义日志输出

允许用户自定义日志格式：

public interface RequestLogFormatter {
    String formatRequest(HttpServletRequest request);
    String formatResponse(HttpServletRequest request, Object response);
}

6. 发布准备

1. 完善README.md，说明功能、配置项和使用示例
2. 添加LICENSE文件
3. 配置CI/CD流程
4. 发布到Maven仓库

通过以上步骤，你可以实现一个功能完善、可配置、易于集成的Spring Boot Starter。这个starter可以自动记录请求信息，并且提供了丰富的配置选项，用户只需添加依赖即可获得功能，无需编写额外代码。