当前位置: 首页 > 知识库问答 >
问题:

Spring数据Rest:更改OpenAPI规范中的操作ID

欧阳晗日
2023-03-14

我正在尝试生成一个openapi。yaml是我的Spring数据Rest服务的一部分,因此我们可以使用typescript angular generator轻松生成客户机代码。不幸的是,生成的服务和方法的名称是。。。不太理想。我们为实体获得不同的控制器,用于“搜索”,另一个用于关系。此外,生成的服务中的函数名非常长,没有添加太多信息/好处。下面是一个例子:

paths:
  /pricingPlans:
    get:
      tags:
      - pricing-plan-entity-controller
      description: get-pricingplan
      operationId: getCollectionResource-pricingplan-get_1

有了这个openapi.yaml,我们得到了一个PricingPlanEntityControlllerService,其中有一个函数getCollection Resource-pricingplan-get_1,这太荒谬了。我们希望将其更改为PricingPlanServicegetAll

@Tag(name = "pricing-plan")
@CrossOrigin
public interface PricingPlanRepo extends CrudRepository<PricingPlan, UUID> {

    @Override
    Iterable<PricingPlan> findAll();

通过在类级别添加@Tag(name=“pricing plan”),我们可以将生成的服务的名称更改为PricingPlanService,但无论我们尝试了什么,操作ID始终保持不变。

我希望@Operation(operationId=“getAll”)做我们想做的事情,但正如我所说的:忽略了。使用SpringDataREST应用所有这些注释的正确方法是什么?

共有2个答案

汪胡非
2023-03-14

@mimi78告诉我如何自定义生成的OpenAPI规范。谢谢你这么说!我担心的是简单地添加操作ID的1:1翻译的方法,因为内部/原始名称可能会随着endpoint的添加或删除而改变。我想出了一个解决方案,它可以从路径模式(例如/产品/{id}/供应商)和HTTP方法中生成操作ID。我认为这应该提供稳定的命名,它是人类可读的,更适合基于操作ID的客户机生成器。

我想分享这个解决方案,以防有一天其他人需要它:

@Configuration
public class OperationIdCustomizer {

    @Bean
    public OpenApiCustomiser operationIdCustomiser() {
        // @formatter:off
        return openApi -> openApi.getPaths().entrySet().stream()
            .forEach(entry -> {
                String path = entry.getKey();
                PathItem pathItem = entry.getValue();
                if (pathItem.getGet() != null)
                    pathItem.getGet().setOperationId(OperationIdGenerator.convert("get", path));
                if (pathItem.getPost() != null)
                    pathItem.getPost().setOperationId(OperationIdGenerator.convert("post", path));
                if (pathItem.getPut() != null)
                    pathItem.getPut().setOperationId(OperationIdGenerator.convert("put", path));
                if (pathItem.getPatch() != null)
                    pathItem.getPatch().setOperationId(OperationIdGenerator.convert("patch", path));
                if (pathItem.getDelete() != null)
                    pathItem.getDelete().setOperationId(OperationIdGenerator.convert("delete", path));
            });
        // @formatter:on
    }

}
public class OperationIdGenerator {

    private static String pattern1 = "^/([a-zA-Z]+)$"; // /products
    private static String pattern2 = "^/([a-zA-Z]+)/(\\{[a-zA-Z]+\\})$"; // /products/{id}
    private static String pattern3 = "^/([a-zA-Z]+)/(\\{[a-zA-Z]+\\})/([a-zA-Z]+)$"; // /products/{id}/vendor
    private static String pattern4 = "^/([a-zA-Z]+)/(\\{[a-zA-Z]+\\})/([a-zA-Z]+)/(\\{[a-zA-Z]+\\})$"; // /products/{id}/vendor/{propertyId}
    private static String pattern5 = "^/([a-zA-Z]+)/search/([a-zA-Z]+)$"; // /products/search/findByVendor

    // @formatter:off
    private static Map<String, String> httpMethodVerb = Map.of(
        "get",      "get",
        "post",     "create",
        "put",      "replace",
        "patch",    "update",
        "delete",   "delete");
    // @formatter:on

    private static String handlePattern1(String op, String path) {
        Pattern r = Pattern.compile(pattern1);
        Matcher m = r.matcher(path);
        boolean found = m.find();
        if (!found)
            return null;
        String noun = toCamelCase(m.group(1));
        String verb = getVerb(op);
        if (verb.equals("create"))
            noun = singularize(noun);
        return verb + noun;
    }

    private static String handlePattern2(String op, String path) {
        Pattern r = Pattern.compile(pattern2);
        Matcher m = r.matcher(path);
        boolean found = m.find();
        if (!found)
            return null;
        String noun = toCamelCase(singularize(m.group(1)));
        return getVerb(op) + noun;
    }

    private static String handlePattern3(String op, String path) {
        Pattern r = Pattern.compile(pattern3);
        Matcher m = r.matcher(path);
        boolean found = m.find();
        if (!found)
            return null;
        String noun = toCamelCase(singularize(m.group(1)));
        String relation = toCamelCase(m.group(3));
        return op + noun + relation;
    }

    private static String handlePattern4(String op, String path) {
        Pattern r = Pattern.compile(pattern4);
        Matcher m = r.matcher(path);
        boolean found = m.find();
        if (!found)
            return null;
        
        String entity = toCamelCase(singularize(m.group(1)));
        String relation = m.group(3);

        return getVerb(op) + entity + toCamelCase(singularize(relation)) + "ById";
    }

    private static String handlePattern5(String op, String path) {
        Pattern r = Pattern.compile(pattern5);
        Matcher m = r.matcher(path);
        boolean found = m.find();
        if (!found)
            return null;
        String entity = toCamelCase(m.group(1));
        String searchMethod = m.group(2);
        r = Pattern.compile("findBy([a-zA-Z0-9]+)");
        m = r.matcher(searchMethod);
        if (m.find())
            return "search" + entity + "By" + toCamelCase(m.group(1));
        return "search" + entity + "By" + toCamelCase(searchMethod);
    }

    public static String singularize(String word) {
        Inflector i = new Inflector();
        return i.singularize(word);
    }

    public static boolean isSingular(String word) {
        Inflector i = new Inflector();
        return i.singularize(word).equals(word);
    }

    public static String getVerb(String op) {
        return httpMethodVerb.get(op);
    }

    public static String convert(String op, String path) {
        String result = handlePattern1(op, path);
        if (result == null) {
            result = handlePattern2(op, path);
            if (result == null) {
                result = handlePattern3(op, path);
                if (result == null) {
                    result = handlePattern4(op, path);
                    if (result == null) {
                        result = handlePattern5(op, path);
                    }
                }
            }
        }
        return result;
    }

    private static String toCamelCase(String phrase) {
        List<String> words = new ArrayList<>();
        for (String word : phrase.split("_"))
            words.add(word);
        for (int i = 0; i < words.size(); i++) {
            String word = words.get(i);
            String firstLetter = word.substring(0, 1).toUpperCase();
            word = firstLetter + word.substring(1);
            words.set(i, word);
        }
        return String.join("", words.toArray(new String[words.size()]));
    }

}
督飞羽
2023-03-14

请注意,您使用@操作注释来自定义操作id的方法不适用于大多数sping-data-rest存储库:原因是操作是由框架在内部生成的,您没有任何方法添加注释。

在所有情况下都有效的简单方法是使用OpenApiCustomiser,按照文档中的描述更改生成的OpenAPI规范的任何部分的值。

    @Bean
    OpenApiCustomiser operationIdCustomiser() {
        return openApi -> openApi.getPaths().values().stream().flatMap(pathItem -> pathItem.readOperations().stream())
                .forEach(operation -> {
                    if ("id-to-change".equals(operation.getOperationId()))
                        operation.setOperationId("any id you want ...");
                });
    }
 类似资料:
  • 我试图按照官方指南,使用RESTEasy和JSON-B来启动和运行一个反应性的REST服务。我还添加了对OpenAPI的支持,以测试遵循本指南的服务。 这两个部分都独立工作,服务正确地返回硬编码的演示数据。Swagger UI显示了可用的路由,并允许调用它们。 然而,它并不像我喜欢的那样顺利... 从简单的、无反应的路由中,模式被正确地提取出来: 理想情况下,我不想单独注释每个反应方法。 是否有一

  • 我按照本教程获得了Spring Data JPA规范:https://dzone.com/articles/using-spring-data-jpa-specification 它为我实现了这一点,但我不能调用规范方法来搜索它们。我想把它们放在我的SearchController中: 现在我想在我的SearchController(比如Controller)中调用这个方法,但我不知道如何调用。目

  • 对于来说,肯定有某种方法可以产生这个输出,不是吗?我发现有一些将映射到,所以似乎有一种方法可以让它产生类型,但我没有找到

  • 我正在尝试开发一个具有规范和RSQL的搜索API。遵循本教程-https://www.baeldung.com/rest-api-search-language-rsql-fiql

  • 表规范 命名统一小写下划线 非CMF核心应用,统一带应用表前缀,如portal_ 插件表,统一带插件表前缀,如:demo_ 表默认编码utf8mb4,默认排序规则utf8mb4_general_ci 引擎统一innodb 写表注释 字段规范 命名统一小写下划线 非自增主键一定要写字段注释 数据类型尽量用数字类型,数字类型的比字符类型的要快很多。 数据类型尽量小,这里的尽量小是指在满足可以预见的未来

  • 表规范 命名统一小写下划线 非CMF核心应用,统一带应用表前缀,如portal_ 插件表,统一带插件表前缀,如:plugindemo 表默认编码utf8mb4,默认排序规则utf8mb4_general_ci 引擎统一innodb 写表注释 字段规范 命名统一小写下划线 非自增主键一定要写字段注释 数据类型尽量用数字类型,数字类型的比字符类型的要快很多。 数据类型尽量小,这里的尽量小是指在满足可以