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

इस पेज पर, Maven से Bazel पर माइग्रेट करने का तरीका बताया गया है. इसमें ज़रूरी शर्तें और इंस्टॉलेशन के चरण भी शामिल हैं. इसमें Maven और Bazel के बीच के अंतर के बारे में बताया गया है. साथ ही, Guava प्रोजेक्ट का इस्तेमाल करके माइग्रेट करने का उदाहरण दिया गया है.

किसी भी बिल्ड टूल से Bazel पर माइग्रेट करते समय, यह सबसे अच्छा होता है कि दोनों बिल्ड टूल एक साथ काम करते रहें. ऐसा तब तक करें, जब तक आपकी डेवलपमेंट टीम, सीआई सिस्टम, और अन्य ज़रूरी सिस्टम पूरी तरह से माइग्रेट न हो जाएं. Maven और Bazel को एक ही रिपॉज़िटरी में चलाया जा सकता है.

शुरू करने से पहले

  • अगर आपने अब तक Bazel इंस्टॉल नहीं किया है, तो Bazel इंस्टॉल करें.
  • अगर आपने पहले कभी Bazel का इस्तेमाल नहीं किया है, तो माइग्रेट करने से पहले, Bazel का परिचय: Java बनाएं ट्यूटोरियल देखें. इस ट्यूटोरियल में, Bazel के कॉन्सेप्ट, स्ट्रक्चर, और लेबल सिंटैक्स के बारे में बताया गया है.

Maven और Bazel के बीच अंतर

  • Maven, टॉप-लेवल की pom.xml फ़ाइल(लों) का इस्तेमाल करता है. Bazel, एक से ज़्यादा बिल्ड फ़ाइलों और हर BUILD फ़ाइल के लिए एक से ज़्यादा टारगेट का इस्तेमाल करता है. इससे, Maven की तुलना में ज़्यादा इंक्रीमेंटल बिल्ड बनाए जा सकते हैं.
  • Maven, डिप्लॉयमेंट की प्रोसेस के चरणों को मैनेज करता है. Bazel, डिप्लॉयमेंट की प्रोसेस को अपने-आप पूरा नहीं करता.
  • Bazel की मदद से, भाषाओं के बीच डिपेंडेंसी तय की जा सकती हैं.
  • प्रोजेक्ट में नए सेक्शन जोड़ने पर, आपको Bazel के साथ नई BUILD फ़ाइलें जोड़ने की ज़रूरत पड़ सकती है. सबसे सही तरीका यह है कि हर नए Java पैकेज में BUILD फ़ाइल जोड़ी जाए.

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

अपने प्रोजेक्ट को Bazel पर माइग्रेट करने का तरीका यहां बताया गया है:

  1. WORKSPACE फ़ाइल बनाना
  2. एक BUILD फ़ाइल बनाना
  3. ज़्यादा BUILD फ़ाइलें बनाना
  4. Bazel का इस्तेमाल करके बनाना

यहां दिए गए उदाहरण, Maven से Bazel में Guava प्रोजेक्ट के माइग्रेशन से लिए गए हैं. Guava प्रोजेक्ट का इस्तेमाल किया गया है, जो v31.1 वर्शन है. Guava का इस्तेमाल करने वाले उदाहरणों में, माइग्रेशन के हर चरण के बारे में नहीं बताया गया है. हालांकि, इनमें वे फ़ाइलें और कॉन्टेंट दिखाए गए हैं जिन्हें माइग्रेशन के लिए जनरेट किया गया है या मैन्युअल तरीके से जोड़ा गया है.

$ git clone https://github.com/google/guava.git && cd guava
$ git checkout v31.1

1. WORKSPACE फ़ाइल बनाना

अपने प्रोजेक्ट के रूट में WORKSPACE नाम की फ़ाइल बनाएं. अगर आपके प्रोजेक्ट में कोई बाहरी डिपेंडेंसी नहीं है, तो वर्कस्पेस फ़ाइल खाली हो सकती है.

अगर आपका प्रोजेक्ट ऐसी फ़ाइलों या पैकेज पर निर्भर करता है जो प्रोजेक्ट की किसी डायरेक्ट्री में नहीं हैं, तो वर्कस्पेस फ़ाइल में इन बाहरी डिपेंडेंसी के बारे में बताएं. वर्कस्पेस फ़ाइल के लिए बाहरी डिपेंडेंसी की सूची को ऑटोमेट करने के लिए, rules_jvm_external का इस्तेमाल करें. इस नियम के सेट को इस्तेमाल करने के बारे में निर्देश पाने के लिए, README फ़ाइल देखें.

Guava प्रोजेक्ट का उदाहरण: बाहरी डिपेंडेंसी

rules_jvm_external ruleset की मदद से, Guava प्रोजेक्ट की बाहरी डिपेंडेंसी की सूची बनाई जा सकती है.

WORKSPACE फ़ाइल में यह स्निपेट जोड़ें:

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

RULES_JVM_EXTERNAL_TAG = "4.3"
RULES_JVM_EXTERNAL_SHA = "6274687f6fc5783b589f56a2f1ed60de3ce1f99bc4e8f9edef3de43bdf7c6e74"

http_archive(
    name = "rules_jvm_external",
    sha256 = RULES_JVM_EXTERNAL_SHA,
    strip_prefix = "rules_jvm_external-%s" % RULES_JVM_EXTERNAL_TAG,
    url = "https://github.com/bazelbuild/rules_jvm_external/archive/%s.zip" % RULES_JVM_EXTERNAL_TAG,
)

load("@rules_jvm_external//:defs.bzl", "maven_install")

maven_install(
    artifacts = [
        "com.google.code.findbugs:jsr305:3.0.2",
        "com.google.errorprone:error_prone_annotations:2.11.0",
        "com.google.j2objc:j2objc-annotations:1.3",
        "org.codehaus.mojo:animal-sniffer-annotations:1.20",
        "org.checkerframework:checker-qual:3.12.0",
    ],
    repositories = [
        "https://repo1.maven.org/maven2",
    ],
)

2. एक BUILD फ़ाइल बनाएं

अब आपने अपने वर्कस्पेस को तय कर लिया है और बाहरी डिपेंडेंसी (अगर लागू हो) की सूची बना ली है. अब आपको BUILD फ़ाइलें बनानी होंगी, ताकि यह बताया जा सके कि आपके प्रोजेक्ट को कैसे बनाया जाना चाहिए. Maven में सिर्फ़ एक pom.xml फ़ाइल होती है. हालांकि, Bazel में किसी प्रोजेक्ट को बनाने के लिए कई BUILD फ़ाइलों का इस्तेमाल किया जा सकता है. इन फ़ाइलों में कई बिल्ड टारगेट तय किए जाते हैं. इससे Bazel को इंक्रीमेंटल बिल्ड बनाने में मदद मिलती है.

BUILD फ़ाइलों को चरणों में जोड़ें. अपने प्रोजेक्ट के रूट में एक BUILD फ़ाइल जोड़ें. इसके बाद, Bazel का इस्तेमाल करके शुरुआती बिल्ड बनाएं. इसके बाद, ज़्यादा टारगेट के साथ ज़्यादा BUILD फ़ाइलें जोड़कर, अपनी बिल्ड को बेहतर बनाया जाता है.

  1. अपनी WORKSPACE फ़ाइल वाली डायरेक्ट्री में, एक टेक्स्ट फ़ाइल बनाएं और उसका नाम BUILD रखें.

  2. इस BUILD फ़ाइल में, अपने प्रोजेक्ट को बनाने के लिए एक टारगेट बनाने के लिए सही नियम का इस्तेमाल करें. इसके लिए, यहां कुछ सुझाव दिए गए हैं:

    • सही नियम का इस्तेमाल करें:

      • किसी एक Maven मॉड्यूल की मदद से प्रोजेक्ट बनाने के लिए, java_library नियम का इस्तेमाल इस तरह करें:

        java_library(
    name = "everything",
    srcs = glob(["src/main/java/**/*.java"]),
    resources = glob(["src/main/resources/**"]),
    deps = ["//:all-external-targets"],
)

      • एक से ज़्यादा Maven मॉड्यूल वाले प्रोजेक्ट बनाने के लिए, java_library नियम का इस्तेमाल इस तरह करें:

        java_library(
    name = "everything",
    srcs = glob([
        "Module1/src/main/java/**/*.java",
        "Module2/src/main/java/**/*.java",
        ...
    ]),
    resources = glob([
        "Module1/src/main/resources/**",
        "Module2/src/main/resources/**",
        ...
    ]),
    deps = ["//:all-external-targets"],
)

      • बाइनरी बनाने के लिए, java_binary नियम का इस्तेमाल करें:

        java_binary(
    name = "everything",
    srcs = glob(["src/main/java/**/*.java"]),
    resources = glob(["src/main/resources/**"]),
    deps = ["//:all-external-targets"],
    main_class = "com.example.Main"
)

    • एट्रिब्यूट तय करें:

      • name: टारगेट को कोई काम का नाम दें. ऊपर दिए गए उदाहरणों में, टारगेट को "everything" कहा जाता है.
      • srcs: अपने प्रोजेक्ट में मौजूद सभी .java फ़ाइलों की सूची बनाने के लिए, ग्लोबिंग का इस्तेमाल करें.
      • resources: अपने प्रोजेक्ट में मौजूद सभी संसाधनों की सूची बनाने के लिए, ग्लोबिंग का इस्तेमाल करें.
      • deps: आपको यह तय करना होगा कि आपके प्रोजेक्ट के लिए, किन बाहरी डिपेंडेंसी की ज़रूरत है. उदाहरण के लिए, अगर आपने generate_workspace टूल का इस्तेमाल करके, बाहरी डिपेंडेंसी की सूची जनरेट की है, तो java_library के लिए डिपेंडेंसी, generated_java_libraries मैक्रो में शामिल लाइब्रेरी होती हैं.

    • Guava प्रोजेक्ट के माइग्रेशन से, इस टॉप-लेवल BUILD फ़ाइल का उदाहरण यहां दिया गया है.

  3. अब आपके प्रोजेक्ट की रूट डायरेक्ट्री में BUILD फ़ाइल मौजूद है. इसलिए, अपने प्रोजेक्ट को बनाएं, ताकि यह पक्का किया जा सके कि वह काम कर रहा है. कमांड लाइन पर, अपनी वर्कस्पेस डायरेक्ट्री से, Bazel की मदद से अपना प्रोजेक्ट बनाने के लिए bazel build //:everything का इस्तेमाल करें.

    अब Bazel की मदद से प्रोजेक्ट को बनाया जा चुका है. आपको BUILD की ज़्यादा फ़ाइलें जोड़नी होंगी, ताकि प्रोजेक्ट के इंक्रीमेंटल बिल्ड बनाए जा सकें.

Guava प्रोजेक्ट का उदाहरण: एक BUILD फ़ाइल से शुरू करना

Guava प्रोजेक्ट को Bazel पर माइग्रेट करते समय, शुरुआत में पूरी प्रोजेक्ट को बनाने के लिए एक BUILD फ़ाइल का इस्तेमाल किया जाता है. यहां फ़ाइल फ़ोल्डर की डायरेक्ट्री में मौजूद, इस शुरुआती BUILD फ़ाइल का कॉन्टेंट दिया गया है:

java_library(
    name = "everything",
    srcs = glob([
        "guava/src/**/*.java",
        "futures/failureaccess/src/**/*.java",
    ]),
    deps = [
        "@maven//:com_google_code_findbugs_jsr305",
        "@maven//:com_google_errorprone_error_prone_annotations",
        "@maven//:com_google_j2objc_j2objc_annotations",
        "@maven//:org_checkerframework_checker_qual",
        "@maven//:org_codehaus_mojo_animal_sniffer_annotations",
    ],
)

3. ज़्यादा BUILD फ़ाइलें बनाएं (ज़रूरी नहीं)

Bazel सिर्फ़ एक BUILD file के साथ काम करता है. आपने पहले बिल्ड को पूरा करने के बाद देखा होगा. हालांकि, आपको अब भी टारगेट के हिसाब से ज़्यादा BUILD फ़ाइलें जोड़कर, बिल्ड को छोटे-छोटे हिस्सों में बांटना चाहिए.

एक से ज़्यादा टारगेट वाली कई BUILD फ़ाइलों से, बिल्ड की बारीकी बढ़ेगी. इससे ये काम किए जा सकेंगे:

  • प्रोजेक्ट के इंक्रीमेंटल बिल्ड की संख्या बढ़ गई है,
  • बिल्ड को पैरलल तरीके से एक्ज़ीक्यूट करने की सुविधा बेहतर हुई है,
  • आने वाले समय में उपयोगकर्ताओं के लिए, बिल्ड को बेहतर तरीके से बनाए रखने में मदद मिलती है.
  • पैकेज के बीच टारगेट की विज़िबिलिटी को कंट्रोल करने की सुविधा मिलती है. इससे ऐसी समस्याओं को रोका जा सकता है जिनमें लाइब्रेरी में मौजूद, लागू करने से जुड़ी जानकारी सार्वजनिक एपीआई में लीक हो जाती है.

ज़्यादा BUILD फ़ाइलें जोड़ने के लिए सुझाव:

  • हर Java पैकेज में BUILD फ़ाइल जोड़कर शुरू करें. सबसे पहले, उन Java पैकेज को अपडेट करें जिनमें सबसे कम डिपेंडेंसी हैं. इसके बाद, उन पैकेज को अपडेट करें जिनमें सबसे ज़्यादा डिपेंडेंसी हैं.
  • BUILD फ़ाइलें जोड़ते समय और टारगेट तय करते समय, इन नए टारगेट को उन टारगेट के BUILD सेक्शन में जोड़ें जो इन पर निर्भर हैं.deps ध्यान दें कि glob() फ़ंक्शन, पैकेज की सीमाओं को पार नहीं करता. इसलिए, पैकेज की संख्या बढ़ने पर, glob() से मैच होने वाली फ़ाइलें कम हो जाएंगी.
  • जब भी किसी main डायरेक्ट्री में कोई BUILD फ़ाइल जोड़ी जाती है, तो पक्का करें कि आपने उससे जुड़ी test डायरेक्ट्री में भी BUILD फ़ाइल जोड़ी हो.
  • पक्का करें कि पैकेज के बीच में, दिखने की सीमा को सही तरीके से सेट किया गया हो.
  • BUILD फ़ाइलों के सेटअप में आने वाली गड़बड़ियों को आसानी से ठीक करने के लिए, पक्का करें कि हर बिल्ड फ़ाइल को जोड़ते समय, प्रोजेक्ट Bazel के साथ बिल्ड होता रहे. bazel build //... चलाएं, ताकि यह पक्का किया जा सके कि आपके सभी टारगेट अब भी बन रहे हैं.

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

आपने Bazel का इस्तेमाल करके, बिल्ड तैयार किया है. साथ ही, आपने बिल्ड के सेटअप की पुष्टि करने के लिए BUILD फ़ाइलें जोड़ी हैं.

जब आपके पास ज़रूरत के हिसाब से BUILD फ़ाइलें हों, तब Bazel का इस्तेमाल करके सभी बिल्ड बनाए जा सकते हैं.