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

इस पेज पर, 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. MODULE.bazel फ़ाइल बनाना
2. एक BUILD फ़ाइल बनाना
3. ज़्यादा BUILD फ़ाइलें बनाना
4. Bazel का इस्तेमाल करके बिल्ड करना

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

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

1. MODULE.bazel फ़ाइल बनाना

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

अगर आपका प्रोजेक्ट, उन फ़ाइलों या पैकेज पर निर्भर करता है जो प्रोजेक्ट की किसी डायरेक्ट्री में नहीं हैं, तो MODULE.bazel फ़ाइल में इन बाहरी डिपेंडेंसी के बारे में बताएं. rules_jvm_external का इस्तेमाल करके, Maven से डिपेंडेंसी मैनेज की जा सकती हैं. इस नियम सेट का इस्तेमाल करने के निर्देशों के लिए, the README देखें.

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

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

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

bazel_dep(name = "rules_jvm_external", version = "6.2")
maven = use_extension("@rules_jvm_external//:extensions.bzl", "maven")
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",
    ],
)
use_repo(maven, "maven")

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

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

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

1. अपनी MODULE.bazel फ़ाइल वाली डायरेक्ट्री में, एक टेक्स्ट फ़ाइल बनाएं और उसका नाम 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: आपको यह तय करना होगा कि आपके प्रोजेक्ट को किन बाहरी डिपेंडेंसी की ज़रूरत है.

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

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

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

java_library(
    name = "everything",
    srcs = glob([
        "guava/src/**/*.java",
        "futures/failureaccess/src/**/*.java",
    ]),
    javacopts = ["-XepDisableAllChecks"],
    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",
    ],
)