Java और Bazel

समस्या की शिकायत करें सोर्स देखें

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

बेज़ल के साथ काम करना

नीचे दिए गए संसाधन, आपको Java प्रोजेक्ट पर Bagel के साथ काम करने में मदद करेंगे:

• ट्यूटोरियल: Java प्रोजेक्ट बनाना
• Java के नियम

बेज़ल पर माइग्रेट किया जा रहा है

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

• Maven से बेज़ल पर माइग्रेट करना

Java वर्शन

कॉन्फ़िगरेशन फ़्लैग के साथ सेट किए गए Java के दो सही वर्शन हैं:

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

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

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

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

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

डिफ़ॉल्ट रूप से Basel, डाउनलोड किए जाने वाले JDK का इस्तेमाल करके, कोड को कंपाइल करता है. साथ ही, लोकल मशीन पर इंस्टॉल किए गए JVM के साथ कोड को एक्ज़ीक्यूट करता है और उसकी जांच करता है. Baज़ल, JAVA_HOME या पाथ का इस्तेमाल करके 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 का इस्तेमाल करके कंपाइल किया जा रहा है

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

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

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

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

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

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

Maven का स्टैंडर्ड डायरेक्ट्री लेआउट (src/main/java में दिए गए सोर्स, src/test/java में टेस्ट) को प्राथमिकता दें.

फ़ाइलें बनाएं

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

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

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

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

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

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

• टेस्ट, src/test से मेल खाने वाली डायरेक्ट्री में होने चाहिए और इस लाइब्रेरी पर निर्भर होने चाहिए.

बेहतर Java बिल्ड के लिए नए नियम बनाना

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

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

• मुख्य Java की सेवा देने वाली कंपनी: java_common
• मुख्य Java मॉड्यूल: JavaInfo
• कॉन्फ़िगरेशन का हिस्सा: java

• अन्य मॉड्यूल:

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

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

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

अतिरिक्त निष्पादन टूलचेन कॉन्फ़िगर करना

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

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

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

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
)

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

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 = ...
)

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

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

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

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

VenillaJavaBuilder, Javaबिल्डर को लागू करने की दूसरी प्रोसेस है. यह JDK के इंटरनल कंपाइलर में कोई बदलाव नहीं करता और न ही इसमें कोई अन्य अतिरिक्त सुविधा होती है. VenillaJavaBuilder में पहले से मौजूद किसी भी टूलचेन का इस्तेमाल नहीं किया जाता.

JavaBuilder के अलावा, Basel, कंपाइलेशन के दौरान कई अन्य टूल का इस्तेमाल करता है.

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

singlejar टूल की मदद से, कई jar फ़ाइलों को एक ही फ़ोल्डर में पैक किया जा सकता है.

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

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

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

कंपाइलेशन को फिर से कॉन्फ़िगर किया जा सकता है. इसके लिए, आपको BUILD फ़ाइल में default_java_toolchain मैक्रो जोड़ना होगा. इसके बाद, WORKSPACE फ़ाइल में register_toolchains नियम जोड़कर या --extra_toolchains फ़्लैग का इस्तेमाल करके, उसे रजिस्टर करना होगा.

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

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

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",
)

इसका इस्तेमाल, --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 कंपाइलर फ़्लैग कॉन्फ़िगर करना

JVM और javac फ़्लैग को फ़्लैग या default_java_toolchain एट्रिब्यूट के साथ कॉन्फ़िगर किया जा सकता है.

सही फ़्लैग --jvmopt, --host_jvmopt, --javacopt, और --host_javacopt हैं.

काम के default_java_toolchain एट्रिब्यूट ये हैं: javacopts, jvm_opts, javabuilder_jvm_opts, और turbine_jvm_opts.

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

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

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
    ],
)

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

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

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

अलग-अलग फ़्लैग के इस्तेमाल को आसान बनाने के लिए, किसी खास वर्शन के लिए फ़्लैग के सेट को .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

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