Utiliser des annotations en Java pour élaborer une stratégie

J'ai vécu une situation très intéressante au travail et je voulais partager la solution ici.

Imaginez que vous ayez besoin de traiter un ensemble de données. Et pour gérer cet ensemble de données, vous disposez de plusieurs stratégies différentes. Par exemple, j'avais besoin de créer des stratégies pour récupérer une collection de données à partir de S3, ou des exemples dans le référentiel local, ou transmis en entrée.

Et celui qui dictera cette stratégie est celui qui en fera la demande :

Je souhaite récupérer les données dans S3. Prenez les données générées le jour X entre les heures H1 et H2, qui proviennent du client Abóbora. Obtenez les 3000 dernières données qui répondent à cela.

Ou bien :

Prenez l'exemple de données que vous avez là, copiez-le 10000 fois pour faire le test de résistance.

Ou encore :

J'ai ce répertoire, vous y avez également accès. Récupérez tout dans ce répertoire et récursivement dans les sous-répertoires.

Et aussi enfin :

Prenez cette unité de données qui se trouve dans l'entrée et utilisez-la.

Comment mettre en œuvre ?

Ma première pensée a été : "comment puis-je définir la forme de ma saisie en Java ?"

Et je suis arrivé à la première conclusion, super importante pour le projet : "vous savez quoi ? Je ne vais pas définir la forme. Ajoutez une Map qui peut la gérer."

En plus de cela, comme je n'ai mis aucune forme dans le DTO, j'avais toute liberté pour expérimenter la saisie.

Donc après avoir établi une preuve de concept, on arrive à la situation : il faut sortir du stress du POC et passer à quelque chose de proche de l'usage réel.

Le service que je faisais était de valider les règles. Fondamentalement, lorsque je modifiais une règle, je devais prendre cette règle et la comparer aux événements survenus dans l'application de production. Ou bien, si l’application a été modifiée et qu’il n’y a pas eu de bugs, on s’attend à ce que la décision pour la même règle reste la même pour les mêmes données ; Maintenant, si la décision pour la même règle utilisant le même ensemble de données est modifiée... eh bien, c'est un problème potentiel.

J'avais donc besoin de cette application pour exécuter le backtesting des règles. Je dois accéder à la véritable application qui envoie les données pour évaluation et la règle en question. L'utilisation de celui-ci est assez diversifiée :

• valider les écarts potentiels lors de la mise à jour de l'application
• valider si les règles modifiées conservent le même comportement
  • par exemple, optimiser le temps d'exécution des règles
• vérifier si le changement de règles a généré le changement attendu dans les décisions
• valider que le changement dans l'application l'a réellement rendue plus efficace
  • par exemple, utiliser la nouvelle version de GraalVM avec JVMCI activé augmente le nombre de requêtes que je peux faire ?

Donc, pour cela, j'ai besoin de quelques stratégies sur l'origine des événements :

• obtenir les données réelles de S3
• prenez les données qui servent d'échantillon dans le référentiel et copiez-les plusieurs fois
• obtenir les données d'un emplacement spécifique sur ma machine locale

Et j'ai aussi besoin de stratégies différentes de mes règles :

• passé via l'entrée
• utilise le stub à exécution rapide
• utilise un échantillon basé sur la règle de production
• utiliser ce chemin ici sur ma machine

Comment gérer cela ? Eh bien, laissez l'utilisateur fournir les données !

L'API pour la stratégie

Savez-vous quelque chose qui a toujours attiré mon attention à propos de json-schema ? Ceci ici :

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

Ces champs commencent par $. À mon avis, ils sont utilisés pour indiquer des métadonnées. Alors pourquoi ne pas l'utiliser dans la saisie des données pour indiquer les métadonnées de la stratégie utilisée ?

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

Par exemple, je peux commander 15 000 copies des données dont je dispose comme échantillon. Ou demandez certaines choses à S3, en faisant une requête dans Athena :

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

Ou dans le chemin local ?

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

Et ainsi je peux déléguer le choix de la stratégie à venir.

Révision du code et façade

Ma première approche pour gérer les stratégies était la suivante :

public DataLoader getDataLoader(Map<string object> 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);
    }
}
</string>

Mon architecte a donc posé deux questions lors de la révision du code :

• "Pourquoi instanciez-vous tout et ne laissez-vous pas Spring travailler pour vous ?"
• il a créé un DataLoaderFacade dans le code et l'a abandonné à moitié cuit

Qu’est-ce que j’ai compris de cela ? Qu'utiliser la façade serait une bonne idée pour déléguer le traitement au bon coin et... renoncer au contrôle manuel ?

Eh bien, beaucoup de magie se produit à cause du printemps. Puisque nous sommes dans une maison Java avec une expertise Java, pourquoi ne pas utiliser Java/Spring idiomatique, n'est-ce pas ? Ce n’est pas parce que je en tant qu’individu trouve certaines choses difficiles à comprendre qu’elles sont compliquées. Alors, embrassons le monde de la magie de l'injection de dépendances Java.

Création de l'objet façade

Ce qui était :

final var dataLoader = getDataLoader(inputDados)
dataLoader.loadData(inputDados, workingPath);

Devenu :

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

Donc ma couche contrôleur n'a pas besoin de gérer ça. Laissez-le à la façade.

Alors, comment va-t-on faire la façade ? Bon, pour commencer, je dois y injecter tous les objets :

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

Ok, pour le DataLoader principal, je l'écris comme @Primary en plus de @Service. Le reste, je l'écris simplement avec @Service.

Testez ceci ici, en définissant getDataLoader pour qu'il renvoie null juste pour essayer comment Spring appelle le constructeur et... cela a fonctionné. Maintenant, je dois noter avec les métadonnées chaque service quelle stratégie il utilise...

Comment faire ça...

Eh bien, regarde ! En Java nous avons des annotations ! Je peux créer une annotation runtime qui contient les stratégies utilisées par ce composant !

Je peux donc avoir quelque chose comme ça dans AthenaQueryDataLoader :

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

Et je peux aussi avoir des pseudonymes, pourquoi pas ?

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

Et montrez !

Mais comment créer cette annotation ? Eh bien, j'en ai besoin pour avoir un attribut qui soit un vecteur de chaînes (le compilateur Java s'occupe déjà de fournir une chaîne solitaire et de la transformer en un vecteur avec 1 position). La valeur par défaut est valeur. Cela ressemble à ceci :

public DataLoader getDataLoader(Map<string object> 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);
    }
}
</string>

Si le champ d'annotation n'avait pas de valeur, je devrais le rendre explicite, et cela aurait l'air moche, comme dans l'annotation EstrategiaFeia :

final var dataLoader = getDataLoader(inputDados)
dataLoader.loadData(inputDados, workingPath);

Cela ne semble pas si naturel à mon avis.

D'accord, étant donné cela, nous avons encore besoin de :

• extraire l'annotation de classe des objets passés
• créer une carte de chaînes $\to$→ chargeur de données (ou chaîne $\to$→ T)

Extraire l'annotation et assembler la carte

Pour extraire l'annotation, je dois avoir accès à la classe d'objet :

dataLoaderFacade.loadData(inputDados, workingPath);

En plus de cela, puis-je demander si cette classe a été annotée avec une annotation comme Strategy :

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

    public DataLoaderFacade(DataLoader primaryDataLoader,
                            List<dataloader> dataLoaderWithStrategies) {
        // armazena de algum modo
    }

    @Override
    public CompletableFuture<void> loadData(Map<string object> input, Path workingPath) {
        return getDataLoader(input).loadData(input, workingPath);
    }

    private DataLoader getDataLoader(Map<string object> input) {
        final var strategy = input.get("$strategy");
        // magia...
    }
}
</string></string></void></dataloader>

Vous souvenez-vous qu'il a le champ valeurs ? Eh bien, ce champ renvoie un vecteur de chaînes :

@Service
@Primary
@Estrategia("athena-query")
public class AthenaQueryDataLoader implements DataLoader {
    // ...
}

Spectacle ! Mais j'ai un défi, car avant j'avais un objet de type T et maintenant je veux mapper ce même objet dans, eh bien, (T, String)[]. Dans les flux, l'opération classique qui permet cela est flatMap. Et Java ne me permet pas non plus de renvoyer un tuple comme celui-là de nulle part, mais je peux créer un enregistrement avec.

Cela ressemblerait à ceci :

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

Et s'il y a un objet qui n'a pas été annoté avec une stratégie ? Est-ce que ça donnera du NPE ? Mieux vaut ne pas le filtrer avant le NPE :

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

Compte tenu de cela, je dois encore dresser une carte. Et bien, regardez : Java fournit déjà un collecteur pour cela ! Collector.toMap(keyMapper, valueMapper)

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

Jusqu'à présent, ok. Mais flatMap m'a particulièrement dérangé. Il existe une nouvelle API Java appelée mapMulti, qui a ce potentiel de multiplication :

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

La beauté. Je l'ai eu pour DataLoader, mais je dois aussi faire la même chose pour RuleLoader. Ou peut-être pas ? Si vous le remarquez, il n'y a rien dans ce code qui soit spécifique à DataLoader. Nous pouvons résumer ce code !!

public DataLoader getDataLoader(Map<string object> 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);
    }
}
</string>

Sous la façade

Pour des raisons purement utilitaires, j'ai placé cet algorithme au sein de l'annotation :

final var dataLoader = getDataLoader(inputDados)
dataLoader.loadData(inputDados, workingPath);

Et pour la façade ? Eh bien, le travail est bien de dire la même chose. J'ai décidé de résumer ceci :

dataLoaderFacade.loadData(inputDados, workingPath);

Et la façade ressemble à ça :

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

    public DataLoaderFacade(DataLoader primaryDataLoader,
                            List<dataloader> dataLoaderWithStrategies) {
        // armazena de algum modo
    }

    @Override
    public CompletableFuture<void> loadData(Map<string object> input, Path workingPath) {
        return getDataLoader(input).loadData(input, workingPath);
    }

    private DataLoader getDataLoader(Map<string object> input) {
        final var strategy = input.get("$strategy");
        // magia...
    }
}
</string></string></void></dataloader>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!