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

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

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

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

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

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

मेवन और बेज़ेल के बीच अंतर

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

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

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

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

यहां दिए गए उदाहरण, Guava प्रोजेक्ट से मेवेन से Bazel पर माइग्रेट हुए हैं. इस्तेमाल किया गया 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 नियम की मदद से, 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: टारगेट को कोई काम का नाम दें. ऊपर दिए गए उदाहरण में, टारगेट को "सब कुछ" कहा गया है.
      • 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",
    ]),
    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() से मेल खाने वाली फ़ाइलें सिकुड़ती हैं.
  • जब भी आप main डायरेक्ट्री में BUILD फ़ाइल जोड़ें, तो पक्का करें कि आपने उससे जुड़ी test डायरेक्ट्री में BUILD फ़ाइल जोड़ी हो.
  • ध्यान रखें कि अलग-अलग पैकेज के बीच, उनकी जानकारी को ठीक से ऐक्सेस न किया जा सके.
  • BUILD फ़ाइलों के सेटअप में गड़बड़ियों को आसानी से हल करने के लिए, पक्का करें कि हर बिल्ड फ़ाइल को जोड़ने पर प्रोजेक्ट Bazel के साथ बनता रहे. bazel build //... चलाएं, ताकि यह पक्का किया जा सके कि आपके सभी टारगेट अब भी बने रहें.

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

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

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