在Java中使用注解来制定策略

我在工作中遇到了一个非常有趣的情况，想在这里分享解决方案。

想象一下您需要处理一组数据。为了处理这组数据，您有几种不同的策略。例如，我需要创建如何从 s3 获取数据集合、本地存储库中的示例或作为输入传递的策略。

决定这一策略的人就是提出请求的人：

我想获取s3中的数据。取 x 天 h1 和 h2 之间生成的数据，该数据来自 abóbora 客户端。获取最近3000条符合此条件的数据。

或者：

拿你那里的示例数据，复制10000次来进行压力测试。

立即学习“Java免费学习笔记（深入）”；

或者甚至：

我有这个目录，你也可以访问它。获取该目录中的所有内容并递归到子目录中。

最后：

获取输入中的这个数据单元并使用它。

如何实施？

我的第一个想法是：“如何在 java 中定义输入的形状？”

我得出了第一个结论，对于该项目非常重要：“你知道吗？我不会定义形状。添加一个可以处理它的 map。”

最重要的是，由于我没有在 dto 中放置任何形状，因此我可以完全自由地尝试输入。

因此，在建立概念验证后，我们遇到了这样的情况：我们需要摆脱 poc 压力，转向接近实际使用的东西。

我所做的服务是验证规则。基本上，当更改规则时，我需要采用该规则并将其与生产应用程序中发生的事件进行匹配。或者，如果应用程序发生更改并且没有错误，则期望对相同数据的相同规则的决策将保持相同；现在，如果使用相同数据集的相同规则的决策发生变化……那么，这就是潜在的麻烦。

所以，我需要这个应用程序来运行规则的回测。我需要点击真实的应用程序发送数据以进行评估和相关规则。它的用途相当多样：

• 验证更新应用程序时的潜在偏差
• 验证更改后的规则是否保持相同的行为
  • 例如，优化规则执行时间
• 检查规则的变化是否产生了预期的决策变化
• 验证应用程序中的更改确实提高了效率
  • 例如，使用新版本的 graalvm 并启用 jvmci 是否会增加我可以发出的请求数量？

因此，为此，我需要一些关于事件起源的策略：

• 从s3获取真实数据
• 获取存储库中的数据作为样本并复制多次
• 从本地计算机上的特定位置获取数据

而且我还需要与我的规则不同的策略：

Shell脚本编写基础 中文WORD版

Shell本身是一个用C语言编写的程序，它是用户使用Linux的桥梁。Shell既是一种命令语言，又是一种程序设计语言。作为命令语言，它交互式地解释和执行用户输入的命令；作为程序设计语言，它定义了各种变量和参数，并提供了许多在高级语言中才具有的控制结构，包括循环和分支。它虽然不是Linux系统核心的一部分，但它调用了系统核心的大部分功能来执行程序、建立文件并以并行的方式协调各个程序的运行。因此，对于用户来说，shell是最重要的实用程序，深入了解和熟练掌握shell的特性极其使用方法，是用好Linux系统

下载

• 通过输入传递
• 使用快速运行的存根
• 使用基于生产规则的样本
• 在我的机器上使用此路径

如何处理这个问题？好吧，让用户提供数据吧！

策略 api

你知道关于 json-schema 总是引起我注意的一些事情吗？这里：

{
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "$id": "https://json-schema.org/draft/2020-12/schema",
    "$vocabulary": {
        //...
    }
}

这些字段以 $ 开头。在我看来，它们是用来表示元数据的。那么为什么不在数据输入中使用它来指示正在使用哪种策略的元数据呢？

{
    "dados": {
        "$strategy": "sample",
        "copias": 15000
    },
    //...
}

例如，我可以订购 15000 份我拥有的数据作为样本。或者从 s3 请求一些东西，在 athena 中进行查询：

{
    "dados": {
        "$strategy": "athena-query",
        "limit": 15000,
        "inicio": "2024-11-25",
        "fim": "2024-11-26",
        "cliente": "abóbora"
    },
    //...
}

或者在本地路径中？

{
    "dados": {
        "$strategy": "localpath",
        "cwd": "/home/jeffque/random-project-file",
        "dir": "../payloads/esses-daqui/top10-hard/"
    },
    //...
}

这样我就可以委托选择未来的策略。

代码审查和外观

我处理策略的第一个方法是：

public dataloader getdataloader(map inputdados) {
    final var strategy = (string) inputdados.get("$strategy");
    return switch (strategy) {
        case "localpath" -> new localpathdataloader();
        case "sample" -> new sampledataloader(resourcepatternresolver_spring);
        case "athena-query" -> new athenaquerydataloader(athenaclient, s3client);
        default -> new athenaquerydataloader(athenaclient, s3client);
    }
}

所以我的架构师在代码审查期间问了两个问题：

• “为什么你实例化所有东西而不让 spring 为你工作？”
• 他在代码中创建了一个dataloaderfacade并放弃了它半成品

从中我明白了什么？使用外观将处理委托给正确的角落并......放弃手动控制是一个好主意？

嗯，很多魔法都是因为春天而发生的。既然我们在一个拥有 java 专业知识的 java 之家，为什么不使用惯用的 java/spring，对吧？仅仅因为我作为一个个体觉得有些事情难以理解并不一定意味着它们很复杂。那么，让我们拥抱 java 依赖注入魔法的世界。

创建 façade 对象

曾经是：

final var dataloader = getdataloader(inputdados)
dataloader.loaddata(inputdados, workingpath);

变成：

dataloaderfacade.loaddata(inputdados, workingpath);

所以我的控制器层不需要管理这个。把它留给门面。

那么，我们要如何做立面呢？好吧，首先，我需要将所有对象注入其中：

@service // para o spring gerenciar esse componente como um serviço
public class dataloaderfacade implements dataloader {

    public dataloaderfacade(dataloader primarydataloader,
                            list dataloaderwithstrategies) {
        // armazena de algum modo
    }

    @override
    public completablefuture loaddata(map input, path workingpath) {
        return getdataloader(input).loaddata(input, workingpath);
    }

    private dataloader getdataloader(map input) {
        final var strategy = input.get("$strategy");
        // magia...
    }
}

好的，对于主 dataloader，除了 @service 之外，我还将其写为 @primary。剩下的我就用@service写下来。

在这里测试一下，设置 getdataloader 返回 null 只是为了尝试 spring 如何调用构造函数......它起作用了。现在我需要用元数据注释每个服务他们使用什么策略...

注释！我可以创建一个 runtime 注释，其中包含该组件使用的策略！

@service
@primary
@estrategia("athena-query")
public class athenaquerydataloader implements dataloader {
    // ...
}

@service
@estrategia({"local", "path", "localpath"})
public class localpathdataloader implements dataloader {
    // ...
}

@retention(retentionpolicy.runtime) // posso usar isso em runtime, não só em análise de bytecode
@target(elementtype.type)           // é intenção que eu só possa anotar tipos com essa anotação
public @interface estrategia {
    string[] value();
}

@service
@estrategiafeia(estrategia = {"local", "path", "localpath"})
public class localpathdataloader implements dataloader {
    // ...
}

从传递的对象中提取类注释
创建字符串映射
• css">→右箭头→ 数据加载器（或字符串 →右箭头→ t）

o.getclass();

o.getclass().getdeclaredannotation(estrategia.class)

string[] estrategias = o.getclass().getdeclaredannotation(estrategia.class).values();

record dataloadercomestrategia(dataloader dataloader, string estrategia) {}

list dataloaders = ...;

dataloaders.stream()
    .flatmap(o ->
        stream.of(o.getclass().getdeclaredannotation(estrategia.class).values())
            .map(s -> new dataloadercomestrategia(o, s)
        )
    )  //...

record dataloadercomestrategia(dataloader dataloader, string estrategia) {}

list dataloaders = ...;

dataloaders.stream()
    .filter(o -> o.getclass().getdeclaredannotation(estrategia.class) != null)
    .flatmap(o ->
        stream.of(o.getclass().getdeclaredannotation(estrategia.class).values())
            .map(s -> new dataloadercomestrategia(o, s)
        )
    )  //...

record dataloadercomestrategia(dataloader dataloader, string estrategia) {}

list dataloaders = ...;

dataloaders.stream()
    .filter(o -> o.getclass().getdeclaredannotation(estrategia.class) != null)
    .flatmap(o ->
        stream.of(o.getclass().getdeclaredannotation(estrategia.class).values())
            .map(s -> new dataloadercomestrategia(o, s)
        )
    ).collect(collectors.tomap(dataloadercomestrategia::estratgia, dataloadercomestrategia::dataloader));

record dataloadercomestrategia(dataloader dataloader, string estrategia) {}

list dataloaders = ...;

dataloaders.stream()
    .filter(o -> o.getclass().getdeclaredannotation(estrategia.class) != null)
    .>mapmulti((o, c) -> {
        for (final var estrategia: o.getclass().getdeclaredannotation(strategized.class).value()) {
            c.accept(new dataloadercomestrategia<>(o, estrategia));
        }
    })
    .collect(collectors.tomap(dataloadercomestrategia::estratgia, dataloadercomestrategia::dataloader));

record objetocomestrategia(t objeto, string estrategia) {}

list objetos = ...;

objetos.stream()
    .filter(o -> o.getclass().getdeclaredannotation(estrategia.class) != null)
    .>mapmulti((o, c) -> {
        for (final var estrategia: o.getclass().getdeclaredannotation(strategized.class).value()) {
            c.accept(new objetocomestrategia<>(o, estrategia));
        }
    })
    .collect(collectors.tomap(objetocomestrategia::estratgia, objetocomestrategia::objeto));

@retention(retentionpolicy.runtime) // posso usar isso em runtime, não só em análise de bytecode
@target(elementtype.type)           // é intenção que eu só possa anotar tipos com essa anotação
public @interface estrategia {
    string[] value();

    public static class util {

        // nenhum motivo especial o record estar aqui, apenas para facilidade de uso
        private record objetocomestrategia(t objeto, string estrategia) {}

        public static  map mapaestrategia(list objetoscomestrategia) {
            return objetoscomestrategia.stream()
                    .filter(o -> o.getclass().getdeclaredannotation(estrategia.class) != null)
                    .>mapmulti((o, c) -> {
                        for (final var estrategia: o.getclass().getdeclaredannotation(strategized.class).value()) {
                            c.accept(new objetocomestrategia<>(o, estrategia));
                        }
                    })
                    .collect(collectors.tomap(objetocomestrategia::estratgia, objetocomestrategia::objeto));
        }
    }
}

class fachadaselector {
    final t primario;
    final map estrategia;

    fachadaselector(t primario, list outros) {
        this.primario = primario;
        this.estrategia = estrategia.util.mapaestrategia(outros);
    }

    t objetousado(map input) {
        if (input == null) return primario;
        final var estrategiainput = input.get("$strategy"); // aqui o tipo vai ser object
        if (estrategiainput == null) return primario;

        // mas tudo bem ser object porque a chave do mapa é object e ele casa no final com .equals
        return estrategia.getordefault(estrategiainput, primario);
    }
}

@Service // para o Spring gerenciar esse componente como um serviço
public class DataLoaderFacade implements DataLoader {

    private final FachadaSelector selector;

    public DataLoaderFacade(DataLoader primaryDataLoader,
                            List dataLoaderWithStrategies) {
        this.selector = new FachadaSelector<>(primaryDataLoader, dataLoaderWithStrategies);
    }

    @Override
    public CompletableFuture loadData(Map input, Path workingPath) {
        return getDataLoader(input).loadData(input, workingPath);
    }

    private DataLoader getDataLoader(Map input) {
        return selector.objetoUsado(input);
    }
}