Java y Bazel

Informar un problemaopen_in_new Ver fuenteopen_in_new . Por la noche · 7.3 · 7.2 · 7.1 · 7.0 · 6.5

Esta página contiene recursos que te ayudarán a usar Bazel con proyectos de Java. Integra vínculos a un instructivo, reglas de compilación y otra información específica de la compilación Proyectos de Java con Bazel.

Cómo trabajar con Bazel

Los siguientes recursos te ayudarán a trabajar con Bazel en proyectos de Java:

• Instructivo: Cómo compilar un proyecto de Java
• Reglas de Java

Migra a Bazel

Si actualmente compilas tus proyectos de Java con Maven, sigue los pasos que se indican en el guía de migración para comenzar a compilar tus proyectos de Maven con Bazel:

• Migra de Maven a Bazel

Versiones de Java

Hay dos versiones relevantes de Java que se establecen con marcas de configuración:

• la versión de los archivos fuente en el repositorio
• la versión del entorno de ejecución de Java que se usa para ejecutar el código y probar it

Configura la versión del código fuente en tu repositorio

Sin una configuración adicional, Bazel supone todos los archivos fuente de Java en la se escriben en una versión única de Java. Para especificar la versión del Las fuentes en el repositorio agregan build --java_language_version={ver} al .bazelrc, en el que {ver} es, por ejemplo, 11. Propietarios del repositorio de Bazel debes configurar esta marca para que Bazel y sus usuarios puedan hacer referencia a los recursos Número de versión de Java. Para obtener más detalles, consulta Marca de versión de lenguaje Java.

Cómo configurar la JVM que se usa para ejecutar y probar el código

Bazel usa un JDK para la compilación y otra JVM para ejecutar y probar el código.

De forma predeterminada, Bazel compila el código mediante un JDK que descarga y ejecuta. prueba el código con la JVM instalada en la máquina local. Bazel busca la JVM con JAVA_HOME o una ruta de acceso.

Los objetos binarios resultantes son compatibles con la JVM instalada de forma local en el sistema. bibliotecas, lo que significa que los objetos binarios resultantes dependen de lo que se instale en el máquina.

Para configurar la JVM que se usa para la ejecución y las pruebas, usa --java_runtime_version. marca. El valor predeterminado es local_jdk.

Pruebas herméticas y compilación

Para crear una compilación hermética, puedes usar la función experimental de línea de comandos --java_runtime_version=remotejdk_11 El código se compila, ejecuta y y se probó en la JVM descargada de un repositorio remoto. Para obtener más detalles, consulta Marca de versión del entorno de ejecución de Java.

Cómo configurar la compilación y ejecución de herramientas de compilación en Java

Existe un segundo par de JDK y JVM para compilar y ejecutar herramientas, que son que se usan en el proceso de compilación, pero no en los resultados de la compilación. Ese JDK y JVM se controlan con --tool_java_language_version y --tool_java_runtime_version Los valores predeterminados son 11 y remotejdk_11, respectivamente.

Cómo compilar con el JDK instalado de forma local

De forma predeterminada, Bazel compila con el JDK remoto porque anula el de JDK. internas. Las cadenas de herramientas de compilación que usan JDK instalado localmente están configurados. pero no se utiliza.

Para compilar usando el JDK instalado localmente, usa las cadenas de herramientas de compilación. Para el JDK local, usa la marca adicional --extra_toolchains=@local_jdk//:all. Sin embargo, ten en cuenta que es posible que esto no funcione en el JDK de proveedores arbitrarios.

Para obtener más detalles, consulta cómo configurar cadenas de herramientas de Java.

Prácticas recomendadas

Además de las prácticas recomendadas generales sobre Bazel, a continuación se incluyen las siguientes: prácticas recomendadas específicas de los proyectos de Java.

Estructura del directorio

Se prefiere el diseño de directorio estándar de Maven (fuentes en src/main/java, pruebas). en src/test/java).

Archivos de BUILD

Sigue estos lineamientos cuando crees tus archivos BUILD:

• Usa un archivo BUILD por directorio que contenga fuentes Java, ya que mejora el rendimiento de compilación.

• Cada archivo BUILD debe contener una regla java_library similar a esto:

  java_library(
      name = "directory-name",
      srcs = glob(["*.java"]),
      deps = [...],
  )
  

• El nombre de la biblioteca debe ser el nombre del directorio que contiene los BUILD. Esto hace que la etiqueta de la biblioteca sea más corta, lo que se usa "//package" en lugar de "//package:package".

• Las fuentes deben ser una glob no recursiva de todos los archivos Java del directorio.

• Las pruebas deben estar en un directorio coincidente en src/test y dependen de esto. biblioteca.

Crea reglas nuevas para compilaciones avanzadas de Java

Nota: La creación de reglas nuevas es para situaciones avanzadas de compilación y prueba. Tú lo haces no la necesitarás cuando comiences a usar Bazel.

Los siguientes módulos, fragmentos de configuración y proveedores te ayudarán extender las capacidades de Bazel cuando compilas tu Java proyectos:

• Proveedor principal de Java: java_common
• Módulo principal de Java: JavaInfo
• Fragmento de configuración: java

• Otros módulos:

  • java_annotation_processing
  • java_compilation_info
  • java_output
  • java_output_jars
  • JavaRuntimeInfo
  • JavaToolchainInfo

Cómo configurar las cadenas de herramientas de Java

Bazel usa dos tipos de cadenas de herramientas de Java: - ejecución, que se usa para ejecutar y probar binarios de Java, controlados con marca --java_runtime_version - compilación, utilizada para compilar fuentes de Java, controlada con Marca de --java_language_version

Cómo configurar cadenas de herramientas de ejecución adicionales

La cadena de herramientas de ejecución es la JVM, ya sea local o de un repositorio, con algunas información adicional sobre su versión, sistema operativo y CPU arquitectura.

Las cadenas de herramientas de ejecución de Java pueden agregarse usando local_java_repository o Reglas remote_java_repository en el archivo WORKSPACE. Agregar la regla hace que la JVM disponible con una marca. Cuando hay varias definiciones para la misma operación del sistema y la CPU, se usa la primera.

Ejemplo de configuración de una JVM local:

load("@bazel_tools//tools/jdk:local_java_repository.bzl", "local_java_repository")

local_java_repository(
  name = "additionaljdk",          # Can be used with --java_runtime_version=additionaljdk, --java_runtime_version=11 or --java_runtime_version=additionaljdk_11
  version = 11,                    # Optional, if not set it is autodetected
  java_home = "/usr/lib/jdk-15/",  # Path to directory containing bin/java
)

Ejemplo de configuración de una JVM remota:

load("@bazel_tools//tools/jdk:remote_java_repository.bzl", "remote_java_repository")

remote_java_repository(
  name = "openjdk_canary_linux_arm",
  prefix = "openjdk_canary", # Can be used with --java_runtime_version=openjdk_canary_11
  version = "11",            # or --java_runtime_version=11
  target_compatible_with = [   # Specifies constraints this JVM is compatible with "@platforms//cpu:arm",
    "@platforms//os:linux",
  ],
  urls = ...,               # Other parameters are from http_repository rule.
  sha256 = ...,
  strip_prefix = ...
)

Cómo configurar cadenas de herramientas de compilación adicionales

La cadena de herramientas de compilación consta de JDK y las múltiples herramientas que usa Bazel. durante la compilación y que proporciona funciones adicionales, como Error Dependencias de Java estrictas y propensas, compilación de encabezados, expansión de sintaxis de Android, instrumentación de cobertura y manejo de clases generativas para IDE.

JavaBuilder es una herramienta integrada por Bazel que ejecuta la compilación y proporciona la las funciones antes mencionadas. La compilación real se ejecuta con la compilación interna por el JDK. El JDK que se usa para la compilación se especifica mediante java_runtime. de la cadena de herramientas.

Bazel anula algunos componentes internos de JDK. En el caso de la versión de JDK > 9, Los módulos java.compiler y jdk.compiler reciben parches con la marca de JDK. --patch_module En el caso de la versión 8 de JDK, el compilador de Java recibe un parche con -Xbootclasspath.

VanillaJavaBuilder es una segunda implementación de JavaBuilder, que no modifica el compilador interno de JDK y no tiene ninguno de los funciones adicionales. VanillaJavaBuilder no se usa en ninguno de los cadenas de herramientas.

Además de JavaBuilder, Bazel usa varias otras herramientas durante la compilación.

La herramienta ijar procesa archivos jar para quitar todo, excepto la llamada las firmas. Los archivos jar resultantes se denominan jar de encabezado. Se usan para mejorar el la incrementalidad de compilación solo volviendo a compilar dependientes downstream cuando el cuerpo de una función cambia.

La herramienta singlejar agrupa varios archivos jar en uno solo.

La herramienta genclass procesa de manera posterior el resultado de una compilación de Java y produce un objeto jar que contiene solo los archivos de clase para las fuentes generadas por ni procesadores de anotaciones.

La herramienta JacocoRunner ejecuta Jacoco en archivos instrumentados y genera resultados en LCOV.

La herramienta TestRunner ejecuta las pruebas JUnit 4 en un entorno controlado.

Para volver a configurar la compilación, agrega la macro default_java_toolchain al un archivo BUILD y registrarlo agregando la regla register_toolchains a el archivo WORKSPACE o mediante --extra_toolchains.

La cadena de herramientas solo se usa cuando el atributo source_version coincide con valor especificado por la marca --java_language_version.

Ejemplo de configuración de la cadena de herramientas:

load(
  "@bazel_tools//tools/jdk:default_java_toolchain.bzl",
  "default_java_toolchain", "DEFAULT_TOOLCHAIN_CONFIGURATION", "BASE_JDK9_JVM_OPTS", "DEFAULT_JAVACOPTS"
)

default_java_toolchain(
  name = "repository_default_toolchain",
  configuration = DEFAULT_TOOLCHAIN_CONFIGURATION,        # One of predefined configurations
                                                          # Other parameters are from java_toolchain rule:
  java_runtime = "@bazel_tools//tools/jdk:remote_jdk11", # JDK to use for compilation and toolchain's tools execution
  jvm_opts = BASE_JDK9_JVM_OPTS + ["--enable_preview"],   # Additional JDK options
  javacopts = DEFAULT_JAVACOPTS + ["--enable_preview"],   # Additional javac options
  source_version = "9",
)

que se puede usar con --extra_toolchains=//:repository_default_toolchain_definition o agregando register_toolchains("//:repository_default_toolchain_definition") al espacio de trabajo.

Parámetros de configuración predefinidos:

• DEFAULT_TOOLCHAIN_CONFIGURATION: Todas las funciones, admite versiones de JDK >= 9.
• VANILLA_TOOLCHAIN_CONFIGURATION: sin funciones adicionales, admite JDK de proveedores arbitrarios.
• PREBUILT_TOOLCHAIN_CONFIGURATION: Es igual que la configuración predeterminada, pero solo usa una compilación previa. herramientas (ijar, singlejar)
• NONPREBUILT_TOOLCHAIN_CONFIGURATION: Es la misma que la predeterminada, pero todas las herramientas son compilada a partir de fuentes (esto puede ser útil en sistemas operativos con diferentes libc)

Configura marcas de JVM y del compilador de Java

Puedes configurar marcas de JVM y javac con marcas o con default_java_toolchain.

Las marcas relevantes son --jvmopt, --host_jvmopt, --javacopt y --host_javacopt

Los atributos default_java_toolchain relevantes son javacopts, jvm_opts, javabuilder_jvm_opts y turbine_jvm_opts.

Configuración de marcas específicas del compilador de Java del paquete

Puedes configurar diferentes indicadores del compilador de Java para fuentes específicas. usando el atributo package_configuration de default_java_toolchain. Consulta el siguiente ejemplo.

load("@bazel_tools//tools/jdk:default_java_toolchain.bzl", "default_java_toolchain")

# This is a convenience macro that inherits values from Bazel's default java_toolchain
default_java_toolchain(
    name = "toolchain",
    package_configuration = [
        ":error_prone",
    ],
    visibility = ["//visibility:public"],
)

# This associates a set of javac flags with a set of packages
java_package_configuration(
    name = "error_prone",
    javacopts = [
        "-Xep:MissingOverride:ERROR",
    ],
    packages = ["error_prone_packages"],
)

# This is a regular package_group, which is used to specify a set of packages to apply flags to
package_group(
    name = "error_prone_packages",
    packages = [
        "//foo/...",
        "-//foo/bar/...", # this is an exclusion
    ],
)

Versiones múltiples del código fuente de Java en un solo repositorio

Bazel solo admite la compilación de una única versión de fuentes de Java en una compilación. compilar. Esto significa que, cuando compilas una prueba de Java o una aplicación, las dependencias se compilan con la misma versión de Java.

Sin embargo, se pueden ejecutar compilaciones independientes con marcas diferentes.

Para facilitar la tarea de usar diferentes marcas, conjuntos de marcas para un la versión se puede agrupar con parámetros de configuración .bazelrc”:

build:java8 --java_language_version=8
build:java8 --java_runtime_version=localjdk_8
build:java11 --java_language_version=11
build:java11 --java_runtime_version=remotejdk_11

Estos parámetros de configuración se pueden usar con la marca --config, por ejemplo bazel test --config=java11 //:java11_test