• 定制你的【Spring Boot Starter】，加速开发效率

    摘要： 本文将介绍如何创建一个自定义的 Spring Boot Starter，让您可以封装常用功能和配置，并在多个 Spring Boot 项目中共享和重用。

    1. 简介

    Spring Boot Starter 是 Spring Boot 框架中的一种特殊的依赖项，它用于快速启动和配置特定功能的应用程序。Starter 实际上是一个 Maven 或 Gradle 项目，它包含了一组预配置的依赖项、默认的配置信息和自动配置类，以帮助开发者快速集成和使用某项功能。

    Spring Boot Starter 通常命名为 spring-boot-starter-*，例如 spring-boot-starter-web 用于启动基本的Web应用程序，spring-boot-starter-data-jpa 用于启动使用JPA的数据访问应用程序。

    2.背景

    在企业微服务开发中，每个微服务模块可能会有不同的异常处理和错误信息输出方式，这样会导致系统的一致性和可维护性下降。为了解决这个问题，您希望创建一个自定义的 Spring Boot Starter，用于统一处理异常和错误信息，并提供一致的错误响应格式。

    3.需求

    1. 统一的异常处理：对于常见的异常类型（如 404、500），提供统一的异常处理方式，并返回一致的错误响应。

    2. 统一的错误响应格式：定义一致的错误响应格式，包括错误代码、错误消息、错误详情等信息。

    3. 可定制化：允许开发人员根据实际情况定制异常处理和错误响应的方式，以满足不同的业务需求。

    4.实现

    4.1.创建SpringBoot项目

    创建完成后项目结构

    4.2.添加相关依赖

    这里需要注意的是，在build.gradle文件中，我们在这里引入了  id 'java-library'

    1. plugins {
    2.     id 'java'
    3.     // 添加 maven-publish 插件 主要是为了发布项目到 Maven 仓库
    4.     id 'maven-publish'
    5.     // 应用 Java Library 插件，提供 Java 项目的基本构建功能
    6.     id 'java-library'
    7.  
    8. }
    9.  
    10. group = 'org.sys_my_start'
    11. version = '1.0-SNAPSHOT'
    12. ext {
    13.     springfoxVersion = '3.2.2'
    14. }
    15.  
    16. // 配置发布任务
    17. publishing {
    18.     // 定义发布内容
    19.     publications {
    20.         // 定义一个 MavenPublication 类型的发布
    21.         mavenJava(MavenPublication) {
    22.             // 发布内容来源于 Java 组件
    23.             from components.java
    24.             // 定义 Maven 坐标信息
    25.             groupId 'org.sys_my_start' // Maven 项目的组织或公司标识
    26.             artifactId 'com_sys_my_start' // 项目在 Maven 仓库中的唯一标识
    27.             version '1.0-SNAPSHOT' // 项目的版本号，表示开发中的版本
    28.         }
    29.     }
    30. }
    31.  
    32. repositories {
    33.     mavenCentral()
    34. }
    35.  
    36. /*  api: 这个依赖声明范围表示该依赖项不仅仅对当前项目的编译和运行时可见，而且对于其他依赖于当前项目的项目也是可见的。
    37.     换句话说，当一个项目依赖于当前项目时，它也将自动获得该依赖项。（也就是最外层的可以访问最内层所引入的依赖）
    38.     上面引入这个 也是为了使用api 因为 gradle 7.0 以后默认不支持 compile语法了废弃了，所以我们这里需要使用api
    39.     id 'java-library'
    40. */
    41. dependencies {
    42.     api "org.springframework.boot:spring-boot-starter-web:$springfoxVersion"
    43. }
    44.  
    45. test {
    46.     useJUnitPlatform()
    47. }
    48.

    4.3.编写Starter 主要逻辑

    4.3.1.编写异常处理类

    1. package com.sys.my.start.exception;
    2.  
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.http.HttpStatus;
    5. import org.springframework.http.ResponseEntity;
    6. import org.springframework.web.bind.annotation.ControllerAdvice;
    7. import org.springframework.web.bind.annotation.ExceptionHandler;
    8. import org.springframework.web.context.request.WebRequest;
    9.  
    10. @ControllerAdvice
    11. public class GlobalExceptionHandler {
    12.  
    13.     private final ExceptionHandlerProperties properties;
    14.  
    15.     @Autowired
    16.     public GlobalExceptionHandler(ExceptionHandlerProperties properties) {
    17.         this.properties = properties;
    18.     }
    19.  
    20.     /**
    21.      * 处理自定义异常
    22.      * @param ex 自定义异常
    23.      * @param request 请求
    24.      * @return ResponseEntity 返回异常信息
    25.      */
    26.     @ExceptionHandler(Exception.class)
    27.     public ResponseEntity handleAnyException(Exception ex, WebRequest request) {
    28.         if (properties.isEnabled()) {
    29.             // 处理自定义异常, 返回异常信息
    30.             ErrorResponse errorResponse = new ErrorResponse("500", ex.getMessage(), request.getDescription(false));
    31.             return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    32.         } else {
    33.             // 未启用全局异常处理 返回500
    34.             return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
    35.         }
    36.     }
    37. }

    4.3.2.编写错误响应类

    1. package com.sys.my.start.exception;
    2.  
    3. /**
    4.  * 定义统一错误相应格式
    5.  */
    6. public class ErrorResponse {
    7.     /**
    8.      * 错误码
    9.      */
    10.     private String errorCode;
    11.  
    12.     /**
    13.      * 错误信息
    14.      */
    15.     private String errorMessage;
    16.  
    17.     /**
    18.      * 错误详情
    19.      */
    20.     private String errorDetails;
    21.  
    22.     public ErrorResponse(String number, String message, String description) {
    23.         this.errorCode = number;
    24.         this.errorMessage = message;
    25.         this.errorDetails = description;
    26.     }
    27.  
    28.     public String getErrorCode() {
    29.         return errorCode;
    30.     }
    31.  
    32.     public String getErrorMessage() {
    33.         return errorMessage;
    34.     }
    35.  
    36.     public String getErrorDetails() {
    37.         return errorDetails;
    38.     }
    39.  
    40.     public void setErrorCode(String errorCode) {
    41.         this.errorCode = errorCode;
    42.     }
    43.  
    44.     public void setErrorMessage(String errorMessage) {
    45.         this.errorMessage = errorMessage;
    46.     }
    47.  
    48.     public void setErrorDetails(String errorDetails) {
    49.         this.errorDetails = errorDetails;
    50.     }
    51. }

    4.3.3.编写扫描配置文件类

    1. package com.sys.my.start.exception;
    2.  
    3. import org.springframework.boot.context.properties.ConfigurationProperties;
    4. import org.springframework.stereotype.Component;
    5.  
    6. /**
    7.  * 扫描 exception-handler:
    8.  *      enabled: true
    9.  * 为true时，启用全局异常处理
    10.  */
    11. @Component
    12. @ConfigurationProperties(prefix = "exception-handler")
    13. public class ExceptionHandlerProperties {
    14.     private boolean enabled;
    15.  
    16.     public boolean isEnabled() {
    17.         return enabled;
    18.     }
    19.  
    20.     public void setEnabled(boolean enabled) {
    21.         this.enabled = enabled;
    22.     }
    23. }

    4.3.4.编写自动配置类

    1. package com.sys.my.start.exception;
    2.  
    3. import org.slf4j.Logger;
    4. import org.slf4j.LoggerFactory;
    5. import org.springframework.context.annotation.Configuration;
    6. import org.springframework.context.annotation.EnableAspectJAutoProxy;
    7. import org.springframework.context.annotation.Import;
    8.  
    9. import java.lang.invoke.MethodHandles;
    10.  
    11. /**
    12.  * 自动配置类
    13.  * 通过@Import导入相关文件
    14.  * EnableAspectJAutoProxy开启AOP代理自动配置
    15.  * @author 13723
    16.  * @version 1.0
    17.  * 2024/2/16 19:16
    18.  */
    19. @Configuration
    20. @EnableAspectJAutoProxy(
    21. 		exposeProxy = true
    22. )
    23. @Import({ExceptionHandlerProperties.class})
    24. public class ErrorHandlerAutoProxy {
    25. 	private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
    26. }

    4.3.5.编写spring.factories

    1. # 通过SpringBoot的自动注入功能，扫描spring.factories，实现自动注入。
    2. org.springframework.boot.autoconfigure.EnableAutoConfiguration= com.sys.my.start.exception.ErrorHandlerAutoProxy

    4.3.6.发布到本地gradle

    5.测试

    5.1.测试模块引入starter

    注意 这里为了保证测试的service模块能够使用到 starter引入springboot依赖，也需要使用api进行调用

    1. // sys_my_service 子项目中的 build.gradle
    2. plugins {
    3.     id 'java-library'
    4. }
    5. dependencies {
    6.     // https://mvnrepository.com/artifact/com.alibaba.fastjson2/fastjson2
    7.     /* json转换 */
    8.     implementation 'com.alibaba.fastjson2:fastjson2:2.0.46'
    9.     /* lombok */
    10.     compileOnly 'org.projectlombok:lombok'
    11.     annotationProcessor 'org.projectlombok:lombok'
    12.     /* 日志类 */
    13.     api 'ch.qos.logback:logback-classic:1.4.14'
    14.     /* 引入自定义jar包 */
    15.     api  group: 'org.sys_my_start', name: 'com_sys_my_start', version: '1.0-SNAPSHOT'
    16. }
    17. sourceSets.main.resources {
    18.     srcDirs = ['src/main/java']
    19.     include '**/*.xml'
    20. }

    5.2.编写测试代码

    1. /**
    2.  * @author 13723
    3.  * @version 1.0
    4.  * 2024/2/16 13:32
    5.  */
    6. @RestController
    7. @RequestMapping("/test")
    8. public class TestController {
    9. 	private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
    10.  
    11. 	@Resource
    12. 	private TestService testService;
    13. 	@RequestMapping("/hello")
    14. 	public String hello(){
    15. 		return testService.hello();
    16. 	}
    17. }
    1. /**
    2.  * @author 13723
    3.  * @version 1.0
    4.  * 2024/2/16 13:33
    5.  */
    6.  
    7. @Service
    8. public class TestService {
    9. 	private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
    10.  
    11. 	public String hello(){
    12. 		throw new RuntimeException("测试统一返回异常！");
    13. 	}
    14. }

    5.3.测试结果

    6.总结

    6.1.好处

    自定义 Starter 是在 Spring Boot 中实现代码模块化和功能封装的强大工具。它的优势和用途包括：

    • 模块化开发： 自定义 Starter 允许将应用程序的不同功能模块化，使得代码结构更清晰，易于维护和管理。
    • 功能封装： Starter 可以封装特定功能的代码和配置，使得其他开发人员可以轻松地集成和使用这些功能。
    • 提高开发效率： 使用自定义 Starter 可以加速新项目的开发过程，避免重复编写相似的代码，提高开发效率。
    • 标准化配置： Starter 可以定义标准化的配置方式，使得不同项目之间的配置更一致，降低了配置错误的可能性。

    通过自定义 Starter，开发团队可以实现代码的复用和标准化，从而提高了代码的复用性和可维护性，降低了开发和维护成本。

    6.2.结语

    本文介绍了如何创建自定义的 Spring Boot Starter，并详细解释了其优势、用途以及如何提高代码复用性和可维护性。通过自定义 Starter，开发人员可以更轻松地构建模块化的应用程序，并在团队内部实现功能的共享和复用。

    鼓励读者在实际项目中尝试创建自己的自定义 Starter，将通用的功能模块化，并通过开源社区与他人分享，促进技术的共享和交流。这将有助于提高团队的开发效率，加速项目的上线和迭代过程，推动软件开发行业的发展。

  • 相关阅读:
    强化学习笔记
    【SVA】SystemVerilog Assertion语法速查
    第二证券|12月A股投资方向来了！这些板块已先涨为敬
    枚举
    车载软件架构——基础软件供应商&开发工具链（二）
    【从0开始编写webserver·基础篇#02】服务器的核心---I/O处理单元和任务类
    在 MacOS 上通过 Lima 使用 Docker
    MySQL索引优化
    华为、思科选哪个更有前途？
    2022-08-01
  • 原文地址：https://blog.csdn.net/q1372302825/article/details/136131281