Canigó. Com utilitzar Google Error-Prone

Introducció

L’objectiu d’aquest article és mostrar l’ús d’un complement al compilador Java (javac) anomenat Google Error-Prone que permet l’avaluació estàtica de codi en temps de compilació per tal de detectar errors i evitar que aquests es traslladin a un entorn productiu. Aquest complement té el seu repositori de codi font.

Justificació

Error Prone permet que el compilador de Java sigui més poderós en analitzar el codi font durant la compilació. Alguns avantatges que aporta són els següents:

• Mostra els errors que es detecten al principi del cicle de vida del desenvolupament de software (Shift left testing). En lloc de detectar-se durant la revisió del codi o en producció, ara es detectaran en el moment de la compilació.
• Google Error Prone és un processador d’anotacions Java que està connectat al compilador, per la qual cosa es pot utilitzar per a diferents sistemes de construcció: Bazel, Maven, Ant i Gradle.
• La solució del problema generalment se suggereix en el moment d’identificar l’error.

Configuració

Per a poder utilitzar el complement a Canigó, serà necessari modificar el fitxer pom.xml que conté la configuració maven del projecte. Es recomana utilitzar Google Error Prone amb JDK 8 o superior, encara que també és possible configurar-ho per a JDK 6 o 7.

Configuració del _plugin

Dins del plugin maven-compiler-plugin, que ja es troba configurat en els projectes generats amb Canigó plugin, s’han d’agregar les etiquetes <compilerArgs> i <annotationProcessorPaths> indicant que es vol utilitzar el complement.

Exemple:

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-compiler-plugin</artifactId>
  <configuration>
    <source>${maven.compiler.plugin.source}</source>
    <target>${maven.compiler.plugin.target}</target>
    <compilerArgs>
      <arg>-XDcompilePolicy=simple</arg>
      <arg>-Xplugin:ErrorProne</arg>
    </compilerArgs>
    <annotationProcessorPaths>
      <path>
        <groupId>com.google.errorprone</groupId>
        <artifactId>error_prone_core</artifactId>
        <version>2.4.0</version>
      </path>>
    </annotationProcessorPaths>
  </configuration>
</plugin>

Canviar el compilador de Java per un d’Error Prone

Si s’utilitza JDK 8, també serà necessari canviar el compilador de Java per a utilitzar una versió específica del compilador d’Error Prone javac. Per a fer-ho, serà necessari agregar la versió del compilador a la secció de propietats:

<properties>
  <javac.version>9+181-r4173-1</javac.version>
</properties>

A més, serà necessari canviar el compilador modificant el maven-compiler-plugin. Per a fer-ho, utilitzarem un perfil per a poder diferenciar el compilador de desenvolupament del compilador d’entorns productius:

  <profiles>
    <profile>
      <id>jdk8</id>
      <activation>
        <jdk>1.8</jdk>
      </activation>
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
              <fork>true</fork>
              <compilerArgs combine.children="append">
                <arg>-J-Xbootclasspath/p:${settings.localRepository}/com/google/errorprone/javac/${javac.version}/javac-${javac.version}.jar</arg>
              </compilerArgs>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>

Ús del complement

En compilar amb maven (mvn compile), sigui a través de CLI o d’un entorn de desenvolupament integrat com Eclipse o IntelliJ IDEA, el complement error-prone farà un anàlisi estàtic del projecte com a part del procés de compilació de forma que:

• En cas de detectar bugs classificats com Error per Defecte, s’aturarà la compilació.
• En cas de detectar bugs classificats com Warning per defecte, no s’aturarà la compilació.
• En qualsevol cas, es mostrarà el detall de l’error i alguns suggeriments de solució.

El detall dels patrons d’errors que es validaran en la compilació es troben descrits a: https://errorprone.info/bugpatterns.

Exemple amb CLI

Per exemple, si tinguéssim el següent bug al projecte:

System.out.println(String.class.getClass().toString())

En executar la compilació:

mvn clean compile

Obtindríem un resultat similar al que es mostra a continuació:

Exemple amb Eclipse

Per utilitzar-ho a l’Eclipse, serà necessari instal·lar el següent plugin:

Exemple amb IntelliJ IDEA

Per a utilitzar-ho a l’IntelliJ IDEA, serà necessari donar d’alta la nova configuració Run/Debug:

Exclusió de patrons d’error

És possible excloure algunes de les advertències dels patrons d’error per a evitar que es pari la compilació. Per exemple, per a excloure l’error GetClassOnClass de la validació hauríem de configurar al fitxer pom.xml el següent:

  <arg>-Xplugin:ErrorProne -Xep:GetClassOnClass:OFF</arg>

Conclusió

L’ús d’aquest complement permet millorar la qualitat del software permetent trobar errors com més aviat millor dins el cicle de vida del desenvolupament d’aplicacions.