मेवन से बैजल में माइग्रेट करना

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

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

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

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

Maven और Bazel में फ़र्क़

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

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

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

  1. WORKSPACE फ़ाइल बनाएं
  2. एक बिल्ड फ़ाइल बनाएं
  3. BUILD फ़ाइलें बनाना
  4. Bzel का इस्तेमाल करके बनाएं

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

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

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

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

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

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

rules_jvm_external नियमों के साथ, गुआवा प्रोजेक्ट की बाहरी डिपेंडेंसी शामिल की जा सकती हैं.

इस स्निपेट को 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 फ़ाइलें बनानी होंगी कि आपका प्रोजेक्ट कैसे बनाया जाना चाहिए. Maven में अपनी pom.xml फ़ाइल की तरह, Bazel प्रोजेक्ट बनाने के लिए कई BUILD फ़ाइलों का इस्तेमाल कर सकता है. इन फ़ाइलों में एक से ज़्यादा बिल्ड टारगेट के बारे में बताया गया है. इनकी मदद से, बेज़ल इंक्रीमेंटल बिल्ड बना सकता है.

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

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

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

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

जब भी ग्वावा प्रोजेक्ट को 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 फ़ाइलें बनाएं (वैकल्पिक)

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

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

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

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

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

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

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

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