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

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

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

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

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

वेब कंटेनर इंस्टॉल करने से पहले

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

Maven और Baज़र के बीच अंतर

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

Maven से बेज़ल में माइग्रेट करें

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

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

यहां Guava प्रोजेक्ट को Maven से Baज़र में माइग्रेट करने से जुड़े उदाहरण दिए गए हैं. 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 देखें.

ध्यान दें: पहले सुझाए गए टूल, generate_workspace का रखरखाव अब Basel की टीम नहीं कर रही है.

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

BUILD फ़ाइलों को अलग-अलग चरणों में जोड़ें. अपने प्रोजेक्ट के रूट में एक BUILD फ़ाइल जोड़कर शुरुआत करें. साथ ही, Basel का इस्तेमाल करके शुरुआती बिल्ड करने के लिए इसका इस्तेमाल करें. इसके बाद, ज़्यादा जानकारी वाले टारगेट वाली ज़्यादा 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 build //:everything का इस्तेमाल करके, Basel की मदद से अपना प्रोजेक्ट बनाएं.

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

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

Guava प्रोजेक्ट को Basel में माइग्रेट करते समय, शुरुआत में एक 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 फ़ाइलें बनाएं (वैकल्पिक)

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

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

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

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

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

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

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

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