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

किसी समस्या की शिकायत करें सोर्स देखें Nightly · 7.4 . 7.3 · 7.2 · 7.1 · 7.0 · 6.5

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

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

ध्यान दें: Bazel, rules_jvm_external के साथ मेवन आर्टफ़ैक्ट को डाउनलोड और पब्लिश करने की सुविधा देता है. हालांकि, यह सीधे तौर पर मेवन पर आधारित प्लग इन के साथ काम नहीं करता. Maven प्लग इन को सीधे तौर पर Bazel से नहीं चलाया जा सकता, क्योंकि Maven के साथ काम करने वाली कोई लेयर मौजूद नहीं है.

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

• अगर 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 से Baze तक के माइग्रेशन से लिया गया है. इस्तेमाल किए गए Guava प्रोजेक्ट का रिलीज़ वर्शन v31.1 है. Guava का इस्तेमाल करने वाले उदाहरणों में, माइग्रेशन के हर चरण के बारे में नहीं बताया गया है. हालांकि, इनमें वे फ़ाइलें और कॉन्टेंट दिखाए गए हैं जिन्हें माइग्रेशन के लिए जनरेट किया गया है या मैन्युअल तरीके से जोड़ा गया है.

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

1. MODULE.baकोई फ़ाइल बनाएं

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

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

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

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

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 फ़ाइल जोड़कर शुरुआत करें. साथ ही, Basel का इस्तेमाल करके शुरुआती बिल्ड करने के लिए इसका इस्तेमाल करें. इसके बाद, ज़्यादा जानकारी वाले टारगेट वाली ज़्यादा 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: टारगेट को ऐसा नाम दें जो समझ में आए. ऊपर दिए गए उदाहरणों में, टारगेट को "सब कुछ" कहा जाता है.
       • srcs: अपने प्रोजेक्ट में मौजूद सभी .java फ़ाइलों की सूची बनाने के लिए, ग्लोबिंग का इस्तेमाल करें.
       • resources: अपने प्रोजेक्ट के सभी संसाधनों की सूची बनाने के लिए, ग्लोबिंग का इस्तेमाल करें.
       • deps: आपको यह तय करना होगा कि आपके प्रोजेक्ट को किन बाहरी डिपेंडेंसी की ज़रूरत है.

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

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

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

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

Guava प्रोजेक्ट को Basel में माइग्रेट करते समय, शुरुआत में एक BUILD फ़ाइल का इस्तेमाल करके, पूरा प्रोजेक्ट बनाया जाता है. Workspace डायरेक्ट्री में मौजूद इस शुरुआती 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",
    ],
)

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

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

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

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

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

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

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

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

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