Java और Bazel

किसी समस्या की शिकायत करें सोर्स देखें Nightly · 8.3 · 8.2 · 8.1 · 8.0 · 7.6

इस पेज पर ऐसे संसाधन मौजूद हैं जिनकी मदद से, Java प्रोजेक्ट के साथ Bazel का इस्तेमाल किया जा सकता है. इसमें Bazel की मदद से Java प्रोजेक्ट बनाने से जुड़े ट्यूटोरियल, नियम, और अन्य जानकारी का लिंक होता है.

Bazel का इस्तेमाल करना

Java प्रोजेक्ट पर Bazel का इस्तेमाल करने के लिए, इन संसाधनों की मदद लें:

Bazel पर माइग्रेट करना

अगर फ़िलहाल Maven की मदद से Java प्रोजेक्ट बनाए जा रहे हैं, तो Bazel की मदद से Maven प्रोजेक्ट बनाने के लिए, माइग्रेशन गाइड में दिया गया तरीका अपनाएं:

Java के वर्शन

Java के दो काम के वर्शन हैं, जिन्हें कॉन्फ़िगरेशन फ़्लैग के साथ सेट किया जाता है:

  • डेटा स्टोर करने की जगह में मौजूद सोर्स फ़ाइलों का वर्शन
  • Java रनटाइम का वह वर्शन जिसका इस्तेमाल कोड को चलाने और उसकी जांच करने के लिए किया जाता है

अपनी रिपॉज़िटरी में सोर्स कोड का वर्शन कॉन्फ़िगर करना

अतिरिक्त कॉन्फ़िगरेशन के बिना, Bazel यह मान लेता है कि रिपॉज़िटरी में मौजूद सभी Java सोर्स फ़ाइलें, Java के एक ही वर्शन में लिखी गई हैं. रिपॉज़िटरी में मौजूद सोर्स का वर्शन तय करने के लिए, .bazelrc फ़ाइल में build --java_language_version={ver} जोड़ें. यहां {ver}, उदाहरण के लिए 11 है. Bazel रिपॉज़िटरी के मालिकों को यह फ़्लैग सेट करना चाहिए, ताकि Bazel और उसके उपयोगकर्ता सोर्स कोड के Java वर्शन नंबर का रेफ़रंस दे सकें. ज़्यादा जानकारी के लिए, Java language version flag देखें.

कोड को एक्ज़ीक्यूट और टेस्ट करने के लिए इस्तेमाल किए जाने वाले JVM को कॉन्फ़िगर करना

Bazel, कंपाइलेशन के लिए एक JDK और कोड को चलाने और उसकी जांच करने के लिए दूसरे JVM का इस्तेमाल करता है.

Bazel डिफ़ॉल्ट रूप से, डाउनलोड किए गए JDK का इस्तेमाल करके कोड को कंपाइल करता है. साथ ही, यह लोकल मशीन पर इंस्टॉल किए गए JVM की मदद से कोड को एक्ज़ीक्यूट और टेस्ट करता है. Bazel, JAVA_HOME या पाथ का इस्तेमाल करके JVM खोजता है.

इससे मिलने वाली बाइनरी, सिस्टम लाइब्रेरी में स्थानीय तौर पर इंस्टॉल किए गए JVM के साथ काम करती हैं. इसका मतलब है कि इससे मिलने वाली बाइनरी, मशीन पर इंस्टॉल किए गए JVM पर निर्भर करती हैं.

एक्ज़ीक्यूशन और टेस्टिंग के लिए इस्तेमाल किए गए JVM को कॉन्फ़िगर करने के लिए, --java_runtime_version फ़्लैग का इस्तेमाल करें. डिफ़ॉल्ट वैल्यू local_jdk है.

हर्मेटिक टेस्टिंग और कंपाइल करना

हर्मेटिक कंपाइल बनाने के लिए, कमांड लाइन फ़्लैग --java_runtime_version=remotejdk_11 का इस्तेमाल किया जा सकता है. कोड को रिमोट रिपॉज़िटरी से डाउनलोड किए गए जेवीएम पर कंपाइल, एक्ज़ीक्यूट, और टेस्ट किया जाता है. ज़्यादा जानकारी के लिए, Java रनटाइम वर्शन फ़्लैग देखें.

Java में बिल्ड टूल के कंपाइलेशन और एक्ज़ीक्यूशन को कॉन्फ़िगर करना

टूल बनाने और उन्हें चलाने के लिए, JDK और JVM के दूसरे पेयर का इस्तेमाल किया जाता है. इनका इस्तेमाल बिल्ड प्रोसेस में किया जाता है, लेकिन ये बिल्ड के नतीजों में शामिल नहीं होते. JDK और JVM को --tool_java_language_version और --tool_java_runtime_version का इस्तेमाल करके कंट्रोल किया जाता है. इनकी डिफ़ॉल्ट वैल्यू, 11 और remotejdk_11 होती हैं.

डिवाइस पर इंस्टॉल किए गए JDK का इस्तेमाल करके कंपाइल करना

Bazel, डिफ़ॉल्ट रूप से रिमोट JDK का इस्तेमाल करके कंपाइल करता है. ऐसा इसलिए, क्योंकि यह JDK के इंटरनल को बदल रहा है. लोकल तौर पर इंस्टॉल किए गए JDK का इस्तेमाल करने वाली कंपाइलेशन टूलचेन कॉन्फ़िगर की गई हैं. हालांकि, इनका इस्तेमाल नहीं किया जाता.

स्थानीय तौर पर इंस्टॉल किए गए JDK का इस्तेमाल करके कंपाइल करने के लिए, यानी स्थानीय JDK के लिए कंपाइलेशन टूलचेन का इस्तेमाल करने के लिए, --extra_toolchains=@local_jdk//:all फ़्लैग का इस्तेमाल करें. हालांकि, ध्यान रखें कि यह किसी भी वेंडर के JDK पर काम नहीं कर सकता.

ज़्यादा जानकारी के लिए, Java टूलचेन कॉन्फ़िगर करना लेख पढ़ें.

सबसे सही तरीके

Bazel के सबसे सही सामान्य तरीकों के अलावा, यहां Java प्रोजेक्ट के लिए सबसे सही तरीके दिए गए हैं.

डायरेक्ट्री स्ट्रक्चर

Maven के स्टैंडर्ड डायरेक्ट्री लेआउट (सोर्स src/main/java में और टेस्ट src/test/java में) का इस्तेमाल करें.

BUILD फ़ाइलें

BUILD फ़ाइलें बनाते समय, इन दिशा-निर्देशों का पालन करें:

  • Java सोर्स वाली हर डायरेक्ट्री के लिए, एक BUILD फ़ाइल का इस्तेमाल करें. इससे बिल्ड परफ़ॉर्मेंस बेहतर होती है.

  • हर BUILD फ़ाइल में एक java_library नियम होना चाहिए, जो इस तरह दिखता है:

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

  • लाइब्रेरी का नाम, उस डायरेक्ट्री का नाम होना चाहिए जिसमें BUILD फ़ाइल मौजूद है. इससे लाइब्रेरी का लेबल छोटा हो जाता है. इसका मतलब है कि "//package:package" के बजाय "//package" का इस्तेमाल करें.

  • सोर्स, डायरेक्ट्री में मौजूद सभी Java फ़ाइलों का नॉन-रिकर्सिव glob होना चाहिए.

  • टेस्ट, src/test में मौजूद मैचिंग डायरेक्ट्री में होने चाहिए और इस लाइब्रेरी पर निर्भर होने चाहिए.

एडवांस जावा बिल्ड के लिए नए नियम बनाए जा रहे हैं

ध्यान दें: नए नियम बनाने की सुविधा, ऐडवांस बिल्ड और टेस्ट के लिए उपलब्ध है. Bazel का इस्तेमाल शुरू करने के लिए, इसकी ज़रूरत नहीं होती.

Java प्रोजेक्ट बनाते समय, Bazel की क्षमताओं को बढ़ाने में ये मॉड्यूल, कॉन्फ़िगरेशन फ़्रैगमेंट, और प्रोवाइडर आपकी मदद करेंगे:

Java टूलचेन कॉन्फ़िगर करना

Bazel, दो तरह की Java टूलचेन का इस्तेमाल करता है: - एक्ज़ीक्यूशन, इसका इस्तेमाल Java बाइनरी को एक्ज़ीक्यूट और टेस्ट करने के लिए किया जाता है. इसे --java_runtime_version फ़्लैग से कंट्रोल किया जाता है - कंपाइलेशन, इसका इस्तेमाल Java सोर्स को कंपाइल करने के लिए किया जाता है. इसे --java_language_version फ़्लैग से कंट्रोल किया जाता है

अन्य एक्ज़ीक्यूशन टूलचेन कॉन्फ़िगर करना

एक्ज़ीक्यूशन टूलचेन, JVM होता है. यह लोकल या किसी रिपॉज़िटरी से होता है. इसमें इसके वर्शन, ऑपरेटिंग सिस्टम, और सीपीयू आर्किटेक्चर के बारे में कुछ अतिरिक्त जानकारी होती है.

मॉड्यूल एक्सटेंशन में, local_java_repository या remote_java_repository repo नियमों का इस्तेमाल करके, Java एक्ज़ीक्यूशन टूलचेन जोड़ी जा सकती हैं. नियम जोड़ने से, फ़्लैग का इस्तेमाल करके JVM उपलब्ध हो जाता है. अगर एक ही ऑपरेटिंग सिस्टम और सीपीयू आर्किटेक्चर के लिए कई परिभाषाएं दी गई हैं, तो पहली परिभाषा का इस्तेमाल किया जाता है.

MODULE.bazel फ़ाइल में लोकल JVM के कॉन्फ़िगरेशन का उदाहरण:

custom_jdk = use_extension("@rules_java//java:extensions.bzl", "java_repository")

custom_jdk.local(
  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
)
use_repo(custom_jdk, "additionaljdk", "additionaljdk_toolchain_config_repo")
register_toolchains("@additionaljdk_toolchain_config_repo//:all")

रिमोट JVM के कॉन्फ़िगरेशन का उदाहरण:

custom_jdk = use_extension("@rules_java//java:extensions.bzl", "java_repository")

custom_jdk.remote(
  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 = ...
)
use_repo(custom_jdk, "openjdk_canary_linux_arm", "openjdk_canary_linux_arm_toolchain_config_repo")

register_toolchains("@openjdk_canary_linux_arm_toolchain_config_repo//:all")

अन्य कंपाइलेशन टूलचेन कॉन्फ़िगर करना

कंपाइलेशन टूलचेन में JDK और कई टूल शामिल होते हैं. Bazel इनका इस्तेमाल कंपाइलेशन के दौरान करता है. साथ ही, ये टूल कई अन्य सुविधाएं भी देते हैं. जैसे: गड़बड़ी की आशंका, Java की सख्त डिपेंडेंसी, हेडर कंपाइलेशन, Android desugaring, कवरेज इंस्ट्रुमेंटेशन, और IDE के लिए genclass हैंडलिंग.

JavaBuilder, Bazel के साथ बंडल किया गया एक टूल है. यह कंपाइलेशन को लागू करता है और ऊपर बताई गई सुविधाएं उपलब्ध कराता है. असल कंपाइलेशन, JDK के इंटरनल कंपाइलर का इस्तेमाल करके किया जाता है. कंपाइलेशन के लिए इस्तेमाल किए गए JDK को टूलचेन के java_runtime एट्रिब्यूट से तय किया जाता है.

Bazel, JDK के कुछ इंटरनल को बदल देता है. JDK के वर्शन > 9 के मामले में, java.compiler और jdk.compiler मॉड्यूल को JDK के फ़्लैग --patch_module का इस्तेमाल करके पैच किया जाता है. JDK वर्शन 8 के मामले में, Java कंपाइलर को -Xbootclasspath फ़्लैग का इस्तेमाल करके पैच किया जाता है.

VanillaJavaBuilder, JavaBuilder का दूसरा वर्शन है. यह JDK के इंटरनल कंपाइलर में बदलाव नहीं करता है. साथ ही, इसमें कोई अतिरिक्त सुविधा नहीं होती है. VanillaJavaBuilder का इस्तेमाल किसी भी इन-बिल्ट टूलचेन में नहीं किया जाता.

Bazel, कंपाइल करने के दौरान JavaBuilder के साथ-साथ कई अन्य टूल का भी इस्तेमाल करता है.

ijar टूल, jar फ़ाइलों को प्रोसेस करता है, ताकि कॉल सिग्नेचर के अलावा बाकी सभी चीज़ें हटाई जा सकें. नतीजे में मिलने वाले जार को हेडर जार कहा जाता है. इनका इस्तेमाल, कंपाइलेशन इंक्रीमेंटैलिटी को बेहतर बनाने के लिए किया जाता है. ऐसा तब होता है, जब किसी फ़ंक्शन के मुख्य हिस्से में बदलाव होने पर, सिर्फ़ डाउनस्ट्रीम डिपेंडेंट को फिर से कंपाइल किया जाता है.

singlejar टूल, कई jar फ़ाइलों को एक ही फ़ाइल में पैक करता है.

genclass टूल, Java कंपाइलेशन के आउटपुट को प्रोसेस करता है और एक jar बनाता है. इसमें सिर्फ़ उन सोर्स के लिए क्लास फ़ाइलें होती हैं जिन्हें एनोटेशन प्रोसेसर ने जनरेट किया था.

JacocoRunner टूल, इंस्ट्रुमेंट की गई फ़ाइलों पर Jacoco को चलाता है और LCOV फ़ॉर्मैट में नतीजे दिखाता है.

TestRunner टूल, कंट्रोल किए गए एनवायरमेंट में JUnit 4 टेस्ट को एक्ज़ीक्यूट करता है.

BUILD फ़ाइल में default_java_toolchain मैक्रो जोड़कर, कंपाइलेशन को फिर से कॉन्फ़िगर किया जा सकता है. साथ ही, इसे रजिस्टर किया जा सकता है. इसके लिए, MODULE.bazel फ़ाइल में register_toolchains नियम जोड़ें या --extra_toolchains फ़्लैग का इस्तेमाल करें.

टूलचेन का इस्तेमाल सिर्फ़ तब किया जाता है, जब source_version एट्रिब्यूट की वैल्यू, --java_language_version फ़्लैग के ज़रिए दी गई वैल्यू से मेल खाती हो.

टूलचेन के कॉन्फ़िगरेशन का उदाहरण:

load(
  "@rules_java//toolchains: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 = "@rules_java//toolchains: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",
)

इसका इस्तेमाल --extra_toolchains=//:repository_default_toolchain_definition का इस्तेमाल करके या वर्कस्पेस में register_toolchains("//:repository_default_toolchain_definition") जोड़कर किया जा सकता है.

पहले से तय किए गए कॉन्फ़िगरेशन:

  • DEFAULT_TOOLCHAIN_CONFIGURATION: सभी सुविधाएं, JDK के वर्शन >= 9 के साथ काम करता है
  • VANILLA_TOOLCHAIN_CONFIGURATION: इसमें कोई अतिरिक्त सुविधा नहीं है. यह किसी भी वेंडर के JDK के साथ काम करता है.
  • PREBUILT_TOOLCHAIN_CONFIGURATION: डिफ़ॉल्ट सेटिंग की तरह ही, लेकिन सिर्फ़ पहले से बने टूल (ijar, singlejar) का इस्तेमाल करें
  • NONPREBUILT_TOOLCHAIN_CONFIGURATION: डिफ़ॉल्ट के जैसा ही है, लेकिन सभी टूल सोर्स से बनाए गए हैं. यह अलग-अलग libc वाले ऑपरेटिंग सिस्टम पर काम आ सकता है

JVM और Java कंपाइलर फ़्लैग कॉन्फ़िगर करना

आपके पास फ़्लैग या default_java_toolchain एट्रिब्यूट का इस्तेमाल करके, JVM और javac फ़्लैग को कॉन्फ़िगर करने का विकल्प होता है.

इससे जुड़े फ़्लैग ये हैं: --jvmopt, --host_jvmopt, --javacopt, और --host_javacopt.

default_java_toolchain एट्रिब्यूट के लिए, javacopts, jvm_opts, javabuilder_jvm_opts, और turbine_jvm_opts एट्रिब्यूट का इस्तेमाल किया जा सकता है.

पैकेज के हिसाब से Java कंपाइलर फ़्लैग कॉन्फ़िगरेशन

package_configuration एट्रिब्यूट का इस्तेमाल करके, कुछ सोर्स फ़ाइलों के लिए अलग-अलग Java कंपाइलर फ़्लैग कॉन्फ़िगर किए जा सकते हैं.default_java_toolchain कृपया यहां दिया गया उदाहरण देखें.

load("@rules_java//toolchains: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
    ],
)

एक ही रिपॉज़िटरी में Java सोर्स कोड के कई वर्शन

Bazel, एक बिल्ड में Java सोर्स के सिर्फ़ एक वर्शन को कंपाइल कर सकता है. build. इसका मतलब है कि Java टेस्ट या ऐप्लिकेशन बनाते समय, सभी डिपेंडेंसी एक ही Java वर्शन के हिसाब से बनाई जाती हैं.

हालांकि, अलग-अलग फ़्लैग का इस्तेमाल करके अलग-अलग बिल्ड लागू किए जा सकते हैं.

अलग-अलग फ़्लैग का इस्तेमाल करना आसान बनाने के लिए, किसी खास वर्शन के फ़्लैग के सेट को .bazelrc कॉन्फ़िगरेशन" के साथ ग्रुप किया जा सकता है:

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

इन कॉन्फ़िगरेशन का इस्तेमाल --config फ़्लैग के साथ किया जा सकता है. उदाहरण के लिए, bazel test --config=java11 //:java11_test.