💣 👨‍👩‍👧‍👧 🔚 Se débarrasser du code standard dans Protocol Buffers 2 🎑 👨‍👦‍👦 🏍️

Si vous développez des applications d'entreprise et pas seulement, vous êtes probablement déjà familiarisé avec le protocole de sérialisation Protocol Buffers de Google. Dans cet article, parlons de sa deuxième version. Et qu'il nous oblige à écrire beaucoup de code standard, avec lequel nous allons nous battre.

Protobuff est une bonne chose - vous décrivez la composition de votre API dans un fichier .proto, composé de primitives, et vous pouvez générer du code source pour différentes plates-formes - par exemple, un serveur en Java et un client en C #, ou vice versa. Comme il s'agit le plus souvent d'une API pour les systèmes externes, il est plus logique de la rendre immuable, et ce code lui-même génère un générateur standard pour Java.

Prenons un exemple:

syntax = "proto2";

option java_multiple_files = true;
package org.example.api;

message Person { //     
  required int32 id = 1; // ,  
  required string name = 2; // ,  
  optional int32 age = 3; // ,  
}

En conséquence, nous obtenons une classe avec l'interface suivante:

public interface PersonOrBuilder extends
    // @@protoc_insertion_point(interface_extends:org.example.api.Person)
    com.google.protobuf.MessageOrBuilder {


  boolean hasId();
  int getId();

  boolean hasName();
  java.lang.String getName();
  com.google.protobuf.ByteString getNameBytes();

  boolean hasAge();
  int getAge();
}

Notez que les primitives sont utilisées partout (ce qui est efficace pour la sérialisation et les performances). Mais le champ age est facultatif, mais la primitive a toujours une valeur par défaut. C'est ce qui étonne un tas de code standard avec lequel nous allons nous battre.

Integer johnAge = john.hasAge() ? john.getAge() : null;

Mais j'ai vraiment envie d'écrire:

Integer johnAge = john.age().orElse(null); //  age() -  Optional<Integer>

Protocol Buffers a un mécanisme d'extensibilité de plugin et peut être écrit en Java, ce que nous allons faire.

Qu'est-ce qu'un plugin protobuf?

Il s'agit d'un fichier exécutable qui lit un objet PluginProtos.CodeGeneratorRequest à partir du flux d'entrée standard, génère un PluginProtos.CodeGeneratorResponse à partir du flux d'entrée standard et l'écrit dans le flux de sortie standard.

public static void main(String[] args) throws IOException {
        PluginProtos.CodeGeneratorRequest codeRequest = PluginProtos.CodeGeneratorRequest.parseFrom(System.in);
        PluginProtos.CodeGeneratorResponse codeResponse;
        try {
            codeResponse = generate(codeRequest);
        } catch (Exception e) {
            codeResponse = PluginProtos.CodeGeneratorResponse.newBuilder()
                    .setError(e.getMessage())
                    .build();
        }
        codeResponse.writeTo(System.out);
    }

Regardons de plus près ce que nous pouvons générer?

PluginProtos.CodeGeneratorResponse contient la collection PluginProtos.CodeGeneratorResponse.File.

Chaque "fichier" est une nouvelle classe que nous générons nous-mêmes. Cela consiste en:

String name; //  ,          package
String content; //    
String insertionPoint; //

La chose la plus importante pour écrire des plugins - nous n'avons pas à régénérer toutes les classes - nous pouvons compléter les classes existantes en utilisant insertionPoint . Si nous revenons à l'interface générée ci-dessus, nous verrons là:

 // @@protoc_insertion_point(interface_extends:org.example.api.Person)

c'est dans ces endroits que nous pouvons ajouter notre code. Ainsi, nous ne pourrons pas ajouter à une section arbitraire de la classe. Nous allons bâtir sur cela. Comment pouvons-nous résoudre ce problème? Nous pouvons créer notre nouvelle interface avec une méthode par défaut -

public interface PersonOptional extends PersonOrBuilder {
  default Optional<Integer> age() {
    return hasAge() ? Optional.of(getAge()) : Optional.empty();
  }
}

et pour la classe Person, ajoutez l'implémentation non seulement de PersonOrBuilder, mais également de PersonOptional

Code pour générer l'interface dont nous avons besoin

@Builder
public class InterfaceWriter {

    private static final Map<DescriptorProtos.FieldDescriptorProto.Type, Class<?>> typeToClassMap = ImmutableMap.<DescriptorProtos.FieldDescriptorProto.Type, Class<?>>builder()
            .put(TYPE_DOUBLE, Double.class)
            .put(TYPE_FLOAT, Float.class)
            .put(TYPE_INT64, Long.class)
            .put(TYPE_UINT64, Long.class)
            .put(TYPE_INT32, Integer.class)
            .put(TYPE_FIXED64, Long.class)
            .put(TYPE_FIXED32, Integer.class)
            .put(TYPE_BOOL, Boolean.class)
            .put(TYPE_STRING, String.class)
            .put(TYPE_UINT32, Integer.class)
            .put(TYPE_SFIXED32, Integer.class)
            .put(TYPE_SINT32, Integer.class)
            .put(TYPE_SFIXED64, Long.class)
            .put(TYPE_SINT64, Long.class)
            .build();

    private final String packageName;
    private final String className;
    private final List<DescriptorProtos.FieldDescriptorProto> fields;

    public String getCode() {
        List<MethodSpec> methods = fields.stream().map(field -> {
            ClassName fieldClass;
            if (typeToClassMap.containsKey(field.getType())) {
                fieldClass = ClassName.get(typeToClassMap.get(field.getType()));
            } else {
                int lastIndexOf = StringUtils.lastIndexOf(field.getTypeName(), '.');
                fieldClass = ClassName.get(field.getTypeName().substring(1, lastIndexOf), field.getTypeName().substring(lastIndexOf + 1));
            }

            return MethodSpec.methodBuilder(field.getName())
                    .addModifiers(Modifier.DEFAULT, Modifier.PUBLIC)
                    .returns(ParameterizedTypeName.get(ClassName.get(Optional.class), fieldClass))
                    .addStatement("return has$N() ? $T.of(get$N()) : $T.empty()", capitalize(field.getName()), Optional.class, capitalize(field.getName()), Optional.class)
                    .build();
        }).collect(Collectors.toList());

        TypeSpec generatedInterface = TypeSpec.interfaceBuilder(className + "Optional")
                .addSuperinterface(ClassName.get(packageName, className + "OrBuilder"))
                .addModifiers(Modifier.PUBLIC)
                .addMethods(methods)
                .build();

        return JavaFile.builder(packageName, generatedInterface).build().toString();
    }
}

Revenons maintenant du plugin le code qui doit être généré

 PluginProtos.CodeGeneratorResponse.File.newBuilder() //     InsertionPoint,       
                    .setName(String.format("%s/%sOptional.java", clazzPackage.replaceAll("\\.", "/"), clazzName))
.setContent(InterfaceWriter.builder().packageName(clazzPackage).className(clazzName).fields(optionalFields).build().getCode())
                    .build();

PluginProtos.CodeGeneratorResponse.File.newBuilder()
                            .setName(String.format("%s/%s.java", clazzPackage.replaceAll("\\.", "/"), clazzName))
                            .setInsertionPoint(String.format("message_implements:%s.%s", clazzPackage, clazzName)) //     -  message -     
                            .setContent(String.format(" %s.%sOptional, ", clazzPackage, clazzName))
                            .build(),

Comment allons-nous utiliser notre nouveau plugin? - via maven, ajoutez et configurez notre plugin:

<plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>0.6.1</version>
                <extensions>true</extensions>
                <configuration>
                    <pluginId>java8</pluginId>
                    <protoSourceRoot>${basedir}/src/main/proto</protoSourceRoot>
                    <protocPlugins>
                        <protocPlugin>
                            <id>java8</id>
                            <groupId>org.example.protobuf</groupId>
                            <artifactId>optional-plugin</artifactId>
                            <version>1.0-SNAPSHOT</version>
                            <mainClass>org.example.proto2plugin.OptionalPlugin</mainClass>
                        </protocPlugin>
                    </protocPlugins>
                </configuration>
            </plugin>

Mais vous pouvez également l'exécuter à partir de la console - il y a une fonctionnalité pour exécuter non seulement notre plugin, mais avant cela, vous devez appeler le compilateur java standard (mais vous devez créer un fichier exécutable - protoc-gen-java8 (dans mon cas, juste un script bash).

protoc -I=./src/main/resources/ --java_out=./src/main/java/  --java8_out=./src/main/java/ ./src/main/resources/example.proto

Le code source peut être consulté ici .

Se débarrasser du code standard dans Protocol Buffers 2

More articles: