जावा कमांड-लाइन आर्ग्युमेंट्स में महारत — बुनियादी से लेकर सुरक्षित, व्यावहारिक पैटर्न तक

1 1. परिचय
2 2. जावा में कमांड-लाइन तर्क कैसे प्राप्त करें
3 3. डेटा रूपांतरण और त्रुटि संभालना
4 4. विकल्प‑शैली तर्कों को संभालना
5 5. IDE में कमांड-लाइन आर्ग्युमेंट सेट करना और परीक्षण करना
6 6. त्रुटि प्रबंधन और सुरक्षा डिज़ाइन
7 7. व्यावहारिक उदाहरण — फ़ाइल हैंडलिंग, मोड स्विचिंग, और लॉगिंग नियंत्रण
8 8. वास्तविक-विश्व परिनियोजन में सर्वोत्तम प्रथाएँ
9 9. सारांश और डिज़ाइन टेम्प्लेट
10 अक्सर पूछे जाने वाले प्रश्न (FAQ)

1. परिचय

इस अध्याय का उद्देश्य

जावा में, कमांड-लाइन तर्क एक मौलिक विशेषता है जो कार्यक्रमों को रनटाइम पर बाहरी इनपुट प्राप्त करने और उसके अनुसार अपना व्यवहार बदलने की अनुमति देती है। यह लेख आपको String[] args के अर्थ से लेकर व्यावहारिक डिज़ाइन पैटर्न तक चरणबद्ध तरीके से मार्गदर्शन करता है। इस अध्याय में, हम पहले स्पष्ट करते हैं आप क्या कर सकते हैं और यह क्यों महत्वपूर्ण है।

कमांड-लाइन तर्क क्या हैं?

एक जावा एप्लिकेशन आमतौर पर main विधि से शुरू होता है जिसका हस्ताक्षर निम्नलिखित है:

public class App {
    public static void main(String[] args) {
        // args is an array of strings passed at runtime
    }
}

args पैरामीटर एक स्ट्रिंग ऐरे है जो स्टार्टअप कमांड से जुड़े मानों को संग्रहीत करता है। उदाहरण के लिए:

javac App.java
java App Tokyo 2025 debug

इस मामले में, args में ["Tokyo", "2025", "debug"] शामिल है।
यदि कोई तर्क प्रदान नहीं किए जाते हैं, तो args.length 0 होता है।

उपयोग के मामले

परिवेश या लक्ष्यों को स्विच करें — जैसे उत्पादन/टेस्ट मोड, क्षेत्र कोड, भाषा, या लॉग स्तर।
प्रोसेसिंग लक्ष्यों को बाहरी रूप से निर्दिष्ट करें — फ़ाइल नाम, निर्देशिकाएँ, URLs, या ID सूचियाँ।
स्वचालन और बैच प्रोसेसिंग — क्रॉन जॉब्स या CI/CD पाइपलाइनों से तिथि रेंज जैसे पैरामीटर पास करें।

इन सभी से व्यवहार में परिवर्तन पुनः संकलन के बिना संभव होता है, जो कमांड-लाइन तर्कों को शेल स्क्रिप्ट्स और जॉब शेड्यूलर जैसे cron के साथ एकीकरण के लिए आदर्श बनाता है।

प्रमुख डिज़ाइन विचार

आवश्यक और वैकल्पिक तर्कों के बीच अंतर करें — यदि कोई आवश्यक तर्क गायब है, तो सहायता प्रदर्शित करें या उपयुक्त स्थिति कोड के साथ बाहर निकलें।
जल्दी सत्यापित करें — संख्यात्मक या तिथि प्रकारों में रूपांतरित करें जितनी जल्दी संभव हो, और अमान्य इनपुट के लिए स्पष्ट संदेश प्रदान करें।
डिफ़ॉल्ट मानों का डिज़ाइन करें — सुरक्षित डिफ़ॉल्ट प्रदान करें ताकि कार्यक्रम वैकल्पिक तर्कों के छोड़े जाने पर भी चल सके।
पठनीयता और रखरखावशीलता बनाए रखें — बिखरे हुए कच्चे ऐरे एक्सेस से बचें; उपयोग से पहले तर्कों को संरचित ऑब्जेक्ट्स (DTOs या कॉन्फ़िग क्लासेस) में पार्स करें।

कॉन्फ़िग फ़ाइलों और पर्यावरण चरों के बीच चयन

कमांड-लाइन तर्क: अस्थायी ओवरराइड्स या जॉब-विशिष्ट स्विचों के लिए सर्वोत्तम (उन्हें उच्चतम प्राथमिकता वाले स्थानीय सेटिंग के रूप में माना जाता है)।
पर्यावरण चर: रहस्यों या पर्यावरण-निर्भर सेटिंग्स जैसे एंडपॉइंट्स के लिए उपयुक्त।
कॉन्फ़िगरेशन फ़ाइलें (प्रॉपर्टीज़/JSON/YAML): पुनः उपयोग और संस्करण नियंत्रण के लिए कई आइटमों को व्यवस्थित रूप से प्रबंधित करने के लिए आदर्श।

व्यवहार में, तीनों को संयोजित करना आम है — कॉन्फ़िग फ़ाइलें + पर्यावरण चर + तर्क — और तर्कों को सेटिंग्स को ओवरराइड करने के लिए उच्चतम प्राथमिकता दें।

न्यूनतम उदाहरण (सभी तर्कों को सूचीबद्ध करना)

public class ArgsEcho {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("No arguments were provided.");
            System.out.println("Example: java ArgsEcho input.txt debug");
            return;
        }
        System.out.println("Received arguments:");
        for (int i = 0; i < args.length; i++) {
            System.out.printf("args[%d] = %s%n", i, args[i]);
        }
    }
}

आगे क्या (रोडमैप)

मूल संचालन — String[] args के लिए लंबाई जाँच, तत्व एक्सेस
प्रकार रूपांतरण — int/double/boolean हैंडलिंग और अपवाद सुरक्षा
ऑप्शन-शैली पार्सिंग — उदाहरण के लिए, -v , --help , --mode=prod
IDE कॉन्फ़िगरेशन और टेस्ट के दौरान तर्क पास करना
त्रुटि हैंडलिंग और सुरक्षा विचार — अमान्य इनपुट, अपवाद
व्यावहारिक उदाहरण — फ़ाइल हैंडलिंग, मोड स्विचिंग, लॉग नियंत्रण

सबसे पहले, इस सिद्धांत को याद रखें: सभी तर्क स्ट्रिंग्स के रूप में प्राप्त होते हैं और उपयोग से पहले सुरक्षित रूप से रूपांतरित और सत्यापित किए जाने चाहिए। निम्नलिखित अध्याय व्याकरण और सामान्य पैटर्न को विस्तृत कोड उदाहरणों के साथ समझाते हैं।

2. जावा में कमांड-लाइन तर्क कैसे प्राप्त करें

मूल संरचना

जावा में कमांड‑लाइन आर्ग्युमेंट्स को String[] args नामक स्ट्रिंग्स की एरे के रूप में main मेथड को पास किया जाता है। निष्पादन कमांड में क्लास नाम के बाद दर्ज किया गया प्रत्येक स्पेस‑सेपरेटेड टोकन एरे में एक तत्व बन जाता है।

public class Example {
    public static void main(String[] args) {
        System.out.println("Number of arguments: " + args.length);
        for (String arg : args) {
            System.out.println(arg);
        }
    }
}

जब आप प्रोग्राम को इस प्रकार चलाते हैं:

javac Example.java
java Example apple orange banana

आउटपुट होगा:

Number of arguments: 3
apple
orange
banana

विशिष्ट आर्ग्युमेंट्स तक पहुँच

प्रत्येक तत्व को उसके इंडेक्स से एक्सेस किया जा सकता है, जो 0 से शुरू होता है। हालांकि, ArrayIndexOutOfBoundsException से बचने के लिए हमेशा args.length की जाँच करें।

public class AccessExample {
    public static void main(String[] args) {
        if (args.length < 2) {
            System.out.println("Usage: java AccessExample <name> <age>");
            return;
        }

        String name = args[0];
        String age  = args[1];
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

जब इसे java AccessExample Alice 30 के रूप में चलाया जाता है, तो परिणाम होगा:

Name: Alice
Age: 30

गायब आर्ग्युमेंट्स को सुरक्षित रूप से संभालना

चूँकि args में सभी मान स्ट्रिंग्स होते हैं, वे अनुपलब्ध, गलत स्वरूपित, या अपेक्षित प्रकार में परिवर्तित न हो पाते हैं। उपयोग करने से पहले उन्हें वैधता जाँचना एक अच्छा अभ्यास है।

if (args.length == 0) {
    System.out.println("No arguments provided. Please specify input parameters.");
    System.exit(1); // Exit with an error code
}

आप System.exit(int) का उपयोग करके एग्ज़िट स्टेटस दर्शा सकते हैं। परम्परा के अनुसार, 0 सफलता को दर्शाता है, और शून्य‑से‑भिन्न मान (जैसे 1 या 2) विभिन्न त्रुटि प्रकारों को दर्शाते हैं।

उद्धरण और व्हाइटस्पेस

स्पेस द्वारा अलग किए गए आर्ग्युमेंट्स को अलग-अलग मान माना जाता है। यदि आपको एक ही आ्युमेंट के भीतर स्पेस शामिल करने की आवश्यकता है, तो उसे डबल कोट्स में घेरें:

java Example "New York" Japan

यह देगा:

args[0] = New York
args[1] = Japan

जब कोई आर्ग्युमेंट प्रदान नहीं किया गया हो

यदि कोई आर्ग्युमेंट नहीं दिया गया है, तो args.length 0 के बराबर होता। आप इस मान का उपयोग करके अपनी लॉजिक को शर्तानुसार विभाजित कर सकते हैं, उदाहरण के लिए:

if (args.length == 0) {
    System.out.println("Running in interactive mode...");
} else {
    System.out.println("Running with parameters...");
}

यह पैटर्न विशेष रूप से उन टूल्स में उपयोगी है जो इंटरैक्टिव और बैच दोनों मोड में चलाने का समर्थन करते हैं।

3. डेटा रूपांतरण और त्रुटि संभालना

सभी कमांड‑लाइन आर्ग्युमेंट्स स्ट्रिंग्स (String) के रूप में पास किए जाते हैं। इसलिए, उन्हें संख्याओं, बूलियन्स या अन्य प्रकारों के रूप में उपयोग करने के लिए आपको स्पष्ट रूप से रूपांतरित करना होगा। यह अध्याय डेटा प्रकारों को सुरक्षित रूप से कैसे बदलें और संभावित त्रुटियों को कैसे संभालें, यह समझाता है।

स्ट्रिंग्स को इंटीजर और डबल में बदलना

Integer.parseInt() और Double.parseDouble() मेथड्स का उपयोग स्ट्रिंग मानों को संख्यात्मक प्रकारों में बदलने के लिए किया जाता है। यदि इनपुट को संख्या के रूप में पार्स नहीं किया जा सकता, तो NumberFormatException फेंका जाएगा।

public class ParseExample {
    public static void main(String[] args) {
        if (args.length < 2) {
            System.out.println("Usage: java ParseExample <price> <quantity>");
            return;
        }

        try {
            double price = Double.parseDouble(args[0]);
            int quantity = Integer.parseInt(args[1]);
            System.out.println("Total: " + (price * quantity));
        } catch (NumberFormatException e) {
            System.out.println("Error: Please enter numeric values only.");
        }
    }
}

निष्पादन उदाहरण:

java ParseExample 120.5 3
Total: 361.5

बूलियन्स को संभालना

डिबग मोड या वर्बोज़ जैसे बूलियन फ़्लैग्स को पार्स करने के लिए आप Boolean.parseBoolean() का उपयोग कर सकते हैं। यह केवल तब true लौटाता है जब आर्ग्युमेंट “true” (केस‑इंसेंसिटिव) के बराबर हो।

boolean debug = false;
if (args.length > 0) {
    debug = Boolean.parseBoolean(args[0]);
}

if (debug) {
    System.out.println("Debug mode enabled");
} else {
    System.out.println("Debug mode disabled");
}

कार्यान्वयन उदाहरण:

java Example true
Debug mode enabled

java Example false
Debug mode disabled

डिफ़ॉल्ट मानों के साथ सुरक्षित रूपांतरण

गुम या अमान्य इनपुट की स्थिति में डिफ़ॉल्ट मान प्रदान करना एक अच्छी प्रथा है। यह रनटाइम त्रुटियों को रोकता है और उपयोगकर्ता अनुभव को बेहतर बनाता है।

public static int parseIntOrDefault(String s, int defaultValue) {
    try {
        return Integer.parseInt(s);
    } catch (Exception e) {
        return defaultValue;
    }
}

यह पैटर्न आपके आवश्यकतानुसार फ्लोटिंग‑पॉइंट संख्याओं या तिथियों तक भी विस्तारित किया जा सकता है।

त्रुटियों को सहजता से पकड़ना और रिपोर्ट करना

उपयोगकर्ता इनपुट को संभालते समय त्रुटि संदेश स्पष्ट और सहायक होने चाहिए। केवल स्टैक ट्रेस प्रिंट करने के बजाय, सही उपयोग के लिए मार्गदर्शन प्रदान करें।

try {
    int age = Integer.parseInt(args[0]);
    if (age < 0) throw new IllegalArgumentException("Age cannot be negative");
    System.out.println("Age: " + age);
} catch (NumberFormatException e) {
    System.err.println("Error: Please enter a valid number for age.");
} catch (IllegalArgumentException e) {
    System.err.println(e.getMessage());
}

System.err.println() का उपयोग करने से त्रुटि संदेश मानक त्रुटि स्ट्रीम पर भेजे जाते हैं, जिससे लॉग या पाइपलाइन में सामान्य आउटपुट से अलगाव संभव होता है।

वैकल्पिक: जावा के Optional क्लास का उपयोग

नल जांच से बचने और पठनीयता बढ़ाने के लिए, तर्क पार्सिंग के लिए Optional<T> का उपयोग करने पर विचार करें। उदाहरण के लिए:

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> arg0 = (args.length > 0) ? Optional.of(args[0]) : Optional.empty();
        String message = arg0.orElse("default");
        System.out.println("Argument: " + message);
    }
}

यह सुनिश्चित करता है कि यदि कोई तर्क प्रदान नहीं किया गया हो तो भी प्रोग्राम सुरक्षित रूप से चले।

सारांश: मजबूत कमांड‑लाइन प्रोग्राम बनाने के लिए, हमेशा मान लें कि उपयोगकर्ता इनपुट गुम या गलत हो सकता है। स्थिरता सुनिश्चित करने के लिए पार्सिंग, वैधता जाँच और सार्थक त्रुटि संदेशों को मिलाकर उपयोग करें।

4. विकल्प‑शैली तर्कों को संभालना

जैसे-जैसे आपके जावा प्रोग्राम बढ़ते हैं, -h, --help या --mode=prod जैसे रूप में तर्कों को संभालना आवश्यक हो जाता है। ये विकल्प‑शैली तर्क आपके प्रोग्राम को अधिक पठनीय और उपयोगकर्ता‑मित्र बनाते हैं, विशेषकर कमांड‑लाइन यूटिलिटीज़ या ऑटोमेशन स्क्रिप्ट्स के लिए।

छोटे और लंबे विकल्प

विकल्प आमतौर पर दो शैलियों में आते हैं:

छोटे विकल्प — एकल हाइफ़न से शुरू होते हैं, जैसे -v या -h।
लंबे विकल्प — दोहरे हाइफ़न से शुरू होते हैं, जैसे --help या --mode=prod।

आप इन्हें startsWith() और split() जैसी स्ट्रिंग ऑपरेशन्स का उपयोग करके मैन्युअल रूप से पार्स कर सकते हैं।

public class OptionExample {
    public static void main(String[] args) {
        boolean help = false;
        String mode = "dev";

        for (String arg : args) {
            if (arg.equals("-h") || arg.equals("--help")) {
                help = true;
            } else if (arg.startsWith("--mode=")) {
                mode = arg.split("=", 2)[1];
            }
        }

        if (help) {
            System.out.println("Usage: java OptionExample [--mode=<mode>] [-h|--help]");
            return;
        }

        System.out.println("Mode: " + mode);
    }
}

कार्यान्वयन उदाहरण:

java OptionExample
Mode: dev

java OptionExample --mode=prod
Mode: prod

java OptionExample -h
Usage: java OptionExample [--mode=<mode>] [-h|--help]

फ़्लैग्स और मानों को मिलाना

कभी-कभी आपको ऐसे फ़्लैग्स को संभालना पड़ता है जो अलग मानों के साथ आते हैं, जैसे --input data.txt। ऐसे मामलों में, आप तर्कों के माध्यम से एक इंडेक्स के साथ इटररेट कर सकते हैं और अगला मान सुरक्षित रूप से पढ़ सकते हैं।

public class InputExample {
    public static void main(String[] args) {
        String inputFile = null;

        for (int i = 0; i < args.length; i++) {
            if (args[i].equals("--input") && i + 1 < args.length) {
                inputFile = args[i + 1];
            }
        }

        if (inputFile == null) {
            System.out.println("Please specify an input file using --input <filename>");
            return;
        }

        System.out.println("Processing file: " + inputFile);
    }
}

कार्यान्वयन उदाहरण:

java InputExample --input report.csv
Processing file: report.csv

कई विकल्पों को मिलाना

वास्तविक दुनिया के टूल अक्सर कई विकल्प स्वीकार करते हैं — उदाहरण के लिए, --mode=prod --debug --log-level=2। इन्हें साफ़-सुथरे ढंग से प्रबंधित करने के लिए, सभी विकल्पों को एक कॉन्फ़िगरेशन ऑब्जेक्ट में पार्स करने पर विचार करें।

class Config {
    String mode = "dev";
    boolean debug = false;
    int logLevel = 1;
}

public class ConfigExample {
    public static void main(String[] args) {
        Config cfg = new Config();

        for (String arg : args) {
            if (arg.startsWith("--mode=")) {
                cfg.mode = arg.split("=", 2)[1];
            } else if (arg.equals("--debug")) {
                cfg.debug = true;
            } else if (arg.startsWith("--log-level=")) {
                try {
                    cfg.logLevel = Integer.parseInt(arg.split("=", 2)[1]);
                } catch (NumberFormatException e) {
                    System.err.println("Invalid log level. Using default value: 1");
                }
            }
        }

        System.out.println("Mode: " + cfg.mode);
        System.out.println("Debug: " + cfg.debug);
        System.out.println("Log Level: " + cfg.logLevel);
    }
}

Apache Commons CLI का उपयोग (सिफ़ारिश किया गया)

बड़े प्रोजेक्ट्स के लिए, मैन्युअल रूप से आर्ग्युमेंट्स को पार्स करना त्रुटिप्रवण हो जाता है। Apache Commons CLI लाइब्रेरी एक मानकीकृत तरीका प्रदान करती है जिससे आप कमांड-लाइन विकल्पों को परिभाषित और संभाल सकते हैं, साथ ही मदद संदेश और वैधता जाँच भी मिलती है।

import org.apache.commons.cli.*;

public class CLIExample {
    public static void main(String[] args) throws Exception {
        Options options = new Options();
        options.addOption("h", "help", false, "Show help message");
        options.addOption("m", "mode", true, "Execution mode (dev/prod)");

        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = parser.parse(options, args);

        if (cmd.hasOption("h")) {
            HelpFormatter formatter = new HelpFormatter();
            formatter.printHelp("CLIExample", options);
            return;
        }

        String mode = cmd.getOptionValue("m", "dev");
        System.out.println("Mode: " + mode);
    }
}

यह तरीका स्वचालित रूप से मदद उत्पन्न करना, इनपुट वैधता, और परिभाषा व लॉजिक के बीच स्पष्ट कोड विभाजन को समर्थन देता है।

सर्वोत्तम प्रथाओं का सारांश

छोटे ( -h ) और बड़े ( --help ) दोनों फ़्लैग्स का समर्थन करें।
सरल पार्सिंग के लिए startsWith() और split("=") का उपयोग करें।
रखरखाव को बेहतर बनाने के लिए कॉन्फ़िगरेशन क्लासेज़ का उपयोग करें।
स्केलेबल इम्प्लीमेंटेशन के लिए Apache Commons CLI जैसी लाइब्रेरीज़ अपनाएँ।
स्पष्टता के लिए हमेशा --help या उपयोग आउटपुट प्रदान करें।

इस प्रकार अपने आर्ग्युमेंट पार्सिंग को डिज़ाइन करके, आप अपने जावा टूल्स को अधिक सहज, पूर्वानुमेय और रखरखाव योग्य बना सकते हैं — बिल्कुल पेशेवर कमांड-लाइन एप्लिकेशन की तरह।

5. IDE में कमांड-लाइन आर्ग्युमेंट सेट करना और परीक्षण करना

जावा एप्लिकेशन विकसित करते समय, आप अक्सर यह परीक्षण करना चाहेंगे कि आपका प्रोग्राम विभिन्न कमांड-लाइन आर्ग्युमेंट्स के साथ कैसे व्यवहार करता है — बिना टर्मिनल से सीधे चलाए। यह अनुभाग लोकप्रिय IDEs जैसे Eclipse और IntelliJ IDEA में आर्ग्युमेंट्स को कॉन्फ़िगर करने के तरीके को समझाता है।

Eclipse में आर्ग्युमेंट सेट करना

Eclipse में, आप “Run Configurations” डायलॉग के माध्यम से आर्ग्युमेंट्स को कॉन्फ़िगर कर सकते हैं। इन चरणों का पालन करें:

1️⃣ अपने Java फ़ाइल को खोलें और संपादक पर राइट‑क्लिक करें।
2️⃣ Run As → Run Configurations… चुनें।
3️⃣ संवाद में, “Java Application” के तहत अपनी क्लास चुनें।
4️⃣ Arguments टैब पर क्लिक करें।
5️⃣ Program arguments बॉक्स में, इच्छित तर्कों को स्पेस से अलग करके दर्ज करें।

उदाहरण:

Tokyo 2025 debug

जब आप प्रोग्राम चलाते हैं, तो Eclipse स्वचालित रूप से इन तर्कों को String[] args को पास कर देता है।

टिप: आप कई कॉन्फ़िगरेशन बना सकते हैं — उदाहरण के लिए, एक “production mode” के लिए और एक “debug mode” के लिए — और उन्हें आसानी से स्विच कर सकते हैं।

IntelliJ IDEA में तर्क सेट करना

IntelliJ IDEA में प्रक्रिया समान रूप से सरल है:

1️⃣ Run बटन के बगल में ड्रॉप‑डाउन पर क्लिक करें (ऊपरी‑दाएँ कोने में)।
2️⃣ Edit Configurations… चुनें।
3️⃣ “Run/Debug Configurations” विंडो में, “Application” के तहत अपनी Java क्लास खोजें।
4️⃣ Program arguments फ़ील्ड में, अपने तर्कों को उसी तरह दर्ज करें जैसे आप कमांड लाइन पर करेंगे।

उदाहरण:

--mode=prod --debug true

Apply पर क्लिक करें और फिर Run। IntelliJ आपके प्रोग्राम को उन पैरामीटरों के साथ लॉन्च करेगा जो args एरे को पास किए गए हैं।

कई पैटर्न को जल्दी परीक्षण करना

ऑटोमेशन या बैच टूल्स का परीक्षण करते समय, आप विभिन्न तर्क सेटों के साथ कई रन कॉन्फ़िगरेशन पंजीकृत करके समय बचा सकते हैं — उदाहरण के लिए:

config-dev : --mode=dev --debug
config-prod : --mode=prod --log-level=2
config-local : input.txt output.txt

यह आपको स्रोत कोड या टर्मिनल कमांड को बदले बिना एक‑क्लिक से परीक्षण स्थितियों के बीच स्विच करने की सुविधा देता है।

JUnit परीक्षणों के दौरान तर्क पास करना

यदि आपको ऑटोमेटेड टेस्ट में तर्क हैंडलिंग को सत्यापित करने की आवश्यकता है, तो आप JUnit के भीतर अपने main मेथड को स्पष्ट रूप से String[] पास करके तर्कों का सिमुलेशन कर सकते हैं।

import org.junit.jupiter.api.Test;

public class ArgsTest {
    @Test
    void testArguments() {
        String[] args = {"--mode=prod", "--debug"};
        MyApp.main(args);
    }
}

यह पैटर्न आपको अपने प्रोग्राम लॉजिक को उसी JVM वातावरण में परीक्षण करने की अनुमति देता है जैसा कि आपका सामान्य एप्लिकेशन कोड चलता है, जिससे पूर्ण CI/CD ऑटोमेशन संभव हो जाता है।

IDE तर्क परीक्षण में सामान्य गलतियाँ

🧩 चलाने से पहले कॉन्फ़िगरेशन को सहेजना भूल जाना (विशेषकर Eclipse में)।
🧩 स्पेस को गलत टाइप करना — प्रत्येक स्पेस तर्कों को अलग करता है जब तक कि वह कोट्स में न हो।
🧩 तर्क संपादित करने के बाद पुनः चलाना न भूलें — कुछ IDE पुराने कॉन्फ़िगरेशन को कैश कर लेते हैं।
🧩 यह उम्मीद करना कि पर्यावरण वेरिएबल्स स्वचालित रूप से बदलेंगे (इन्हें IDE सेटिंग्स में अलग से कॉन्फ़िगर करें)।

इन IDE तर्क सेटिंग्स में निपुण होकर, आप स्थानीय रूप से प्रोडक्शन‑जैसा व्यवहार दोहरा सकते हैं और अप्रत्याशित रन‑टाइम समस्याओं को कम कर सकते हैं।

6. त्रुटि प्रबंधन और सुरक्षा डिज़ाइन

कमांड‑लाइन इनपुट स्वीकार करते समय, आपका Java प्रोग्राम अवैध, अप्रत्याशित या दुर्भावनापूर्ण तर्कों को सहजता से संभालना चाहिए। यह अनुभाग सुरक्षित वैलिडेशन प्रैक्टिस और सुरक्षा सिद्धांतों को कवर करता है जो सिस्टम विफलताओं या दुरुपयोग को रोकते हैं।

उपयोग से पहले सत्यापित करें

उपयोगकर्ता इनपुट को वैध मानने की कभी भी धारण न रखें। गणनाओं, फ़ाइल ऑपरेशनों या सिस्टम कॉल्स में उपयोग करने से पहले हमेशा तर्कों को वैलिडेट करें। सामान्य वैलिडेशन में शामिल हैं:

तर्कों की संख्या जाँचें (args.length)।
फ़ॉर्मेट सत्यापित करें (जैसे, संख्यात्मक, बूलियन, URL, या तिथि)।
फ़ाइल पाथ मौजूद हैं और पहुँच योग्य हैं, यह पुष्टि करें।
अवैध अक्षर को अस्वीकार करें जो इंजेक्शन या पाथ ट्रैवर्सल का कारण बन सकते हैं।

उदाहरण: उपयोग से पहले संख्यात्मक इनपुट रेंज को वैलिडेट करना:

try {
    int threads = Integer.parseInt(args[0]);
    if (threads < 1 || threads > 64) {
        throw new IllegalArgumentException("Thread count must be between 1 and 64.");
    }
    System.out.println("Using " + threads + " threads.");
} catch (Exception e) {
    System.err.println("Error: " + e.getMessage());
}

फ़ाइल पाथ दुरुपयोग को रोकें

जब तर्क फ़ाइल पाथ का प्रतिनिधित्व करते हैं, तो सुनिश्चित करें कि उपयोगकर्ता ../ या सिम्बॉलिक लिंक का उपयोग करके इच्छित डायरेक्टरी से बाहर नेविगेट न कर सके। उदाहरण के लिए:

import java.nio.file.*;

Path baseDir = Paths.get("/var/app/data");
Path inputPath = baseDir.resolve(args[0]).normalize();

if (!inputPath.startsWith(baseDir)) {
    throw new SecurityException("Access outside of permitted directory is not allowed.");
}

यह पाथ ट्रैवर्सल हमलों को रोकता है जहाँ उपयोगकर्ता निर्दिष्ट क्षेत्र के बाहर संवेदनशील फ़ाइलों तक पहुँचने की कोशिश करते हैं।

मनमाने कमांड निष्पादित करने से बचें

आर्ग्युमेंट्स को कभी भी बिना सफ़ाई के सीधे सिस्टम कमांड या बाहरी प्रक्रियाओं को पास नहीं किया जाना चाहिए। अन्यथा, आपका प्रोग्राम कमांड इंजेक्शन के प्रति संवेदनशील हो सकता है।

// ❌ Dangerous example (do not use)
Runtime.getRuntime().exec("cat " + args[0]);

// ✅ Safe alternative using ProcessBuilder
ProcessBuilder pb = new ProcessBuilder("cat", args[0]);
pb.redirectErrorStream(true);
pb.start();

ProcessBuilder API प्रत्येक आर्ग्युमेंट को अलग-अलग संभालता है, जिससे दुर्भावनापूर्ण शेल व्याख्या रोकी जा सके।

त्रुटि रिपोर्टिंग और एग्ज़िट कोड

पेशेवर टूल्स के लिए, स्पष्ट एग्ज़िट कोड और त्रुटि संदेश डिज़ाइन करें ताकि उपयोगकर्ता समझ सकें कि क्या गलत हुआ। उदाहरण वर्गीकरण:

0 — सफल निष्पादन
1 — अमान्य इनपुट या आर्ग्युमेंट त्रुटि
2 — फ़ाइल या संसाधन अनुपलब्ध
3 — अनुमति अस्वीकृत
99 — अज्ञात या अनहैंडल्ड अपवाद

उदाहरण कार्यान्वयन:

try {
    // business logic
} catch (IllegalArgumentException e) {
    System.err.println("Invalid argument: " + e.getMessage());
    System.exit(1);
} catch (SecurityException e) {
    System.err.println("Permission error: " + e.getMessage());
    System.exit(3);
} catch (Exception e) {
    e.printStackTrace();
    System.exit(99);
}

लॉग और त्रुटि आउटपुट को साफ़ करें

जब उपयोगकर्ता द्वारा प्रदान किए गए आर्ग्युमेंट्स को लॉग किया जाए, तो पासवर्ड, टोकन या व्यक्तिगत डेटा जैसी संवेदनशील जानकारी शामिल न करें। उदाहरण:

String password = args[0];
// ❌ Don't log this directly
// System.out.println("Password: " + password);

// ✅ Use placeholders or masked output
System.out.println("Password provided: [REDACTED]");

यह विशेष रूप से साझा वातावरण या CI/CD पाइपलाइन में लॉग या कंसोल आउटपुट में आकस्मिक डेटा लीक को रोकने में मदद करता है।

डिफेंसिव कोडिंग सारांश

उपयोग से पहले हमेशा आर्ग्युमेंट्स को वैध करें।
डायरेक्टरी ट्रैवर्सल को रोकने के लिए पाथ को सामान्यीकृत और जांचें।
उपयोगकर्ता इनपुट को शेल कमांड में कभी न जोड़ें।
ऑटोमेशन संगतता के लिए स्पष्ट एग्ज़िट कोड डिज़ाइन करें।
लॉग और संदेशों में संवेदनशील डेटा को छुपाएँ।
तेज़ी से फेल हों लेकिन सुरक्षित रूप से — ऐसे प्रोग्राम क्रैश से बचें जो स्टैक ट्रेस उजागर करें।

इन डिफेंसिव तकनीकों को लागू करके, आपके जावा एप्लिकेशन मजबूत, सुरक्षित और पेशेवर बने रहेंगे — यहाँ तक कि अप्रत्याशित रनटाइम वातावरण में चलाए जाने पर भी।

7. व्यावहारिक उदाहरण — फ़ाइल हैंडलिंग, मोड स्विचिंग, और लॉगिंग नियंत्रण

आर्ग्युमेंट्स को संभालने के सिंटैक्स और सर्वोत्तम प्रथाओं को समझने के बाद, अब व्यावहारिक उपयोग मामलों की खोज का समय है। यह अनुभाग तीन सामान्य पैटर्न प्रस्तुत करता है: फ़ाइल ऑपरेशन्स, पर्यावरण मोड स्विचिंग, और डायनेमिक लॉग नियंत्रण। ये वास्तविक दुनिया के एप्लिकेशन्स और ऑटोमेशन वर्कफ़्लो में आम हैं।

उदाहरण 1: फ़ाइल प्रोसेसिंग प्रोग्राम

कई ऑटोमेशन स्क्रिप्ट्स में, कमांड-लाइन आर्ग्युमेंट्स का उपयोग इनपुट और आउटपुट के लिए फ़ाइल पाथ निर्दिष्ट करने के लिए किया जाता है। नीचे एक सरल उदाहरण है जो एक फ़ाइल की सामग्री को दूसरी फ़ाइल में कॉपी करता है:

import java.nio.file.*;
import java.io.IOException;

public class FileCopy {
    public static void main(String[] args) {
        if (args.length < 2) {
            System.out.println("Usage: java FileCopy <source> <destination>");
            System.exit(1);
        }

        Path src = Paths.get(args[0]);
        Path dst = Paths.get(args[1]);

        try {
            Files.copy(src, dst, StandardCopyOption.REPLACE_EXISTING);
            System.out.println("File copied successfully: " + dst);
        } catch (IOException e) {
            System.err.println("File copy failed: " + e.getMessage());
            System.exit(2);
        }
    }
}

कार्यान्वयन उदाहरण:

java FileCopy input.txt backup/input_copy.txt

फ़ाइल पाथ को पैरामीटराइज़ करके, आप इस प्रोग्राम को ऑटोमेशन पाइपलाइन, बैकअप स्क्रिप्ट्स, या क्रॉन जॉब्स में पुन: उपयोग कर सकते हैं।

उदाहरण 2: मोड्स के बीच स्विच करना (डेवलपमेंट / प्रोडक्शन)

एप्लिकेशन अक्सर उनके पर्यावरण के आधार पर अलग व्यवहार करते हैं — उदाहरण के लिए, विभिन्न डेटाबेस या API एंडपॉइंट्स का उपयोग करना। आप --mode=prod जैसे तर्क का उपयोग करके व्यवहार को गतिशील रूप से स्विच कर सकते हैं।

public class ModeSwitch {
    public static void main(String[] args) {
        String mode = "dev"; // default mode

        for (String arg : args) {
            if (arg.startsWith("--mode=")) {
                mode = arg.split("=", 2)[1];
            }
        }

        switch (mode) {
            case "dev":
                System.out.println("Running in Development Mode");
                break;
            case "prod":
                System.out.println("Running in Production Mode");
                break;
            case "test":
                System.out.println("Running in Test Mode");
                break;
            default:
                System.err.println("Unknown mode: " + mode);
                System.exit(1);
        }
    }
}

कार्यान्वयन उदाहरण:

java ModeSwitch --mode=dev
Running in Development Mode

java ModeSwitch --mode=prod
Running in Production Mode

यह डिज़ाइन आपको कई कॉन्फ़िगरेशन को साफ़-सुथरे ढंग से प्रबंधित करने और पर्यावरण-विशिष्ट लॉजिक को हार्डकोड करने से बचने की अनुमति देता है।

उदाहरण 3: लॉग लेवल और डिबग नियंत्रण

लॉगिंग लेवल अक्सर कमांड-लाइन तर्कों के माध्यम से नियंत्रित किए जाते हैं, जिससे कोड में बदलाव किए बिना लचीली डायग्नॉस्टिक्स संभव होती है।

public class LogControl {
    public static void main(String[] args) {
        int logLevel = 1; // 1: normal, 2: verbose, 3: debug

        for (String arg : args) {
            if (arg.startsWith("--log=")) {
                try {
                    logLevel = Integer.parseInt(arg.split("=", 2)[1]);
                } catch (NumberFormatException e) {
                    System.err.println("Invalid log level. Using default: 1");
                }
            }
        }

        if (logLevel >= 3) System.out.println("[DEBUG] Debug information enabled");
        if (logLevel >= 2) System.out.println("[INFO] Detailed information shown");
        System.out.println("[NORMAL] Application started");
    }
}

कार्यान्वयन उदाहरण:

java LogControl --log=3
[DEBUG] Debug information enabled
[INFO] Detailed information shown
[NORMAL] Application started

यह पैटर्न प्रोडक्शन टूल्स में सामान्य है जहाँ लॉगिंग वर्बोसिटी को पुनः संकलन किए बिना गतिशील रूप से समायोजित करना आवश्यक होता है।

सभी पैटर्न को मिलाना

आप इन उदाहरणों को एक ही कॉन्फ़िगरेबल टूल में मिलाकर कई ज़िम्मेदारियों को संभाल सकते हैं। उदाहरण के लिए, एक फ़ाइल-प्रोसेसिंग प्रोग्राम जो एक साथ --mode, --log, और --input विकल्पों को स्वीकार करता है।

java App --mode=prod --log=2 --input data.txt

अपने तर्क पार्सिंग को सावधानीपूर्वक संरचित करके, आप वास्तविक डिप्लॉयमेंट पर्यावरणों के लिए उपयुक्त लचीले और पुन: उपयोग योग्य कमांड-लाइन यूटिलिटीज़ बना सकते हैं।

व्यावहारिक पैटर्न का सारांश

✅ फ़ाइल इनपुट/आउटपुट लचीलापन के लिए तर्कों (arguments) का उपयोग करें।
✅ विकास, परीक्षण और उत्पादन के लिए मोड स्विचिंग की अनुमति दें।
✅ कमांड लाइन से लॉगिंग और डिबगिंग नियंत्रण सक्षम करें।
✅ इन पैरामीटरों को मिलाकर बहुमुखी ऑटोमेशन टूल बनाएं।

ये उदाहरण आधुनिक जावा ऑटोमेशन टूल्स की नींव का प्रतिनिधित्व करते हैं — हल्के, पैरामीटरयुक्त, और स्क्रिप्ट्स या शेड्यूलर्स के साथ एकीकृत करने में आसान।

8. वास्तविक-विश्व परिनियोजन में सर्वोत्तम प्रथाएँ

जब आपका जावा एप्लिकेशन उत्पादन वातावरण में उपयोग होना शुरू करता है, तो कमांड-लाइन तर्कों को लगातार और सुरक्षित रूप से संभालना पेशेवर सॉफ़्टवेयर डिज़ाइन का हिस्सा बन जाता है। यह अनुभाग रखरखाव योग्य, सुरक्षित, और स्केलेबल तर्क हैंडलिंग के लिए वास्तविक-विश्व सर्वोत्तम प्रथाओं का सार प्रस्तुत करता है।

1. इंटरफ़ेस को सुसंगत रखें

एक बार रिलीज़ होने के बाद, प्रत्येक कमांड-लाइन तर्क का अर्थ स्थिर रहना चाहिए। जब तक बिल्कुल आवश्यक न हो, मौजूदा विकल्पों का नाम बदलने या हटाने से बचें। नए पैरामीटर जोड़ते समय, डिफ़ॉल्ट व्यवहार को अपरिवर्तित रखकर बैकवर्ड संगतता सुनिश्चित करें।

// Old version
java ReportTool --mode=prod

// New version (compatible)
java ReportTool --mode=prod --log=2

यह दृष्टिकोण आपके टूल पर निर्भर ऑटोमेशन स्क्रिप्ट्स, CI पाइपलाइन्स, या क्रॉन जॉब्स को टूटने से बचाता है।

2. हेल्प विकल्प प्रदान करें

हर पेशेवर कमांड-लाइन टूल को उपयोग, उपलब्ध विकल्प, और उदाहरणों को समझाने के लिए एक सुलभ --help या -h फ़्लैग प्रदान करना चाहिए।

if (args.length == 0 || Arrays.asList(args).contains("--help")) {
    System.out.println("Usage: java MyTool [options]");
    System.out.println("  --input <file>     Specify input file");
    System.out.println("  --mode <type>      Choose mode: dev, test, prod");
    System.out.println("  --log <level>      Set log verbosity (1-3)");
    System.exit(0);
}

यह न केवल उपयोगिता को सुधारता है बल्कि उपयोगकर्ता त्रुटियों और समर्थन अनुरोधों को भी कम करता है।

3. तर्क व्यवहार को स्पष्ट रूप से दस्तावेज़ करें

एक अद्यतन README या ऑनलाइन दस्तावेज़ रखें जो सभी समर्थित तर्कों, डिफ़ॉल्ट्स, और नमूना निष्पादनों को सूचीबद्ध करता हो। जब कई विकल्प परस्पर क्रिया करते हैं (जैसे, --mode=prod डिबगिंग को निष्क्रिय करता है), तो उन संबंधों को स्पष्ट रूप से स्पष्ट करें।

# Example documentation section

### Options
--mode=<value>     Select execution mode (dev/test/prod)
--log=<level>      Verbosity (1: normal, 2: verbose, 3: debug)
--input=<path>     Input file path

### Example
java MyTool --mode=prod --log=2 --input report.csv

4. कॉन्फ़िगरेशन को कोड से अलग रखें

ऑपरेशनल पैरामीटरों को हार्ड-कोड न करें। संवेदनशील डेटा या डिफ़ॉल्ट्स के लिए कॉन्फ़िगरेशन फ़ाइलें या पर्यावरण वेरिएबल्स का उपयोग करें, और आवश्यक होने पर कमांड-लाइन तर्कों को उन्हें ओवरराइड करने दें।

String defaultMode = System.getenv().getOrDefault("APP_MODE", "dev");
String mode = defaultMode;

// CLI arguments override environment variable
for (String arg : args) {
    if (arg.startsWith("--mode=")) {
        mode = arg.split("=", 2)[1];
    }
}
System.out.println("Running in " + mode + " mode");

यह संरचना दोनों डेवलपर्स और ऑपरेटरों को कोड को पुनः संकलित या संशोधित किए बिना व्यवहार को कॉन्फ़िगर करने की अनुमति देती है।

5. छोटे और लंबे दोनों रूपों का समर्थन करें

छोटे (-v) और लंबे (--verbose) दोनों विकल्प प्रदान करने से विभिन्न उपयोगकर्ता प्राथमिकताओं के लिए सुविधा बढ़ती है:

if (arg.equals("-v") || arg.equals("--verbose")) {
    verbose = true;
}

यह द्वि-रूप आपके टूल को UNIX/Linux मानकों के साथ भी संरेखित करता है, जिससे अनुभवी इंजीनियरों के लिए उपयोगिता में सुधार होता है।

6. अर्थपूर्ण एग्ज़िट कोड लौटाएँ

जेनकिंस, शेल स्क्रिप्ट्स, या ऑर्केस्ट्रेशन सिस्टम जैसे इंटीग्रेशन प्रोसेस एग्ज़िट कोड पर निर्भर होते हैं। सफलता, चेतावनियों, और त्रुटियों को स्पष्ट रूप से संकेत करने के लिए अलग-अलग कोड उपयोग करें। उदाहरण के लिए:

0 — सफलता
10 — आवश्यक तर्क अनुपलब्ध
20 — वैधता त्रुटि
30 — रनटाइम अपवाद

यह बाहरी ऑटोमेशन को बुद्धिमानी से प्रतिक्रिया देने में सक्षम बनाता है — उदाहरण के लिए, केवल पुनर्प्राप्ति योग्य त्रुटियों पर पुनः प्रयास करना।

7. तर्कों और पर्यावरण को सुरक्षित रूप से लॉग करें

जब आप प्रोडक्शन समस्याओं का डिबग कर रहे हों, तो यह जानना कि कौन से आर्ग्यूमेंट पास हुए थे, अत्यंत महत्वपूर्ण है। हालांकि, आपको इन्हें सावधानीपूर्वक लॉग करना चाहिए:

पासवर्ड या टोकन जैसे संवेदनशील मानों को मास्क करें ( ****** )।
केवल सुरक्षित, गैर‑व्यक्तिगत पैरामीटर ही लॉग करें।
टाइमस्टैम्प और प्रोसेस आइडेंटिफ़ायर शामिल करें।

उदाहरण सुरक्षित लॉग आउटपुट:

[2025-11-11 09:30:15] App started
Mode: prod
Log level: 2
Input: data.csv
Password: [REDACTED]

8. स्केलेबिलिटी के लिए लाइब्रेरीज़ का उपयोग करें

बड़े‑पैमाने के टूल्स के लिए, मैन्युअल स्ट्रिंग पार्सिंग से बचें और इसके बजाय निम्नलिखित लाइब्रेरीज़ का उपयोग करें:

Apache Commons CLI — सरल और परिपक्व।
Picocli — आधुनिक, एनोटेशन‑आधारित, और रंगीन हेल्प आउटपुट को सपोर्ट करता है।
JCommander — आर्ग्यूमेंट बाइंडिंग के लिए सहज और हल्का।

उदाहरण (Picocli):

import picocli.CommandLine;
import picocli.CommandLine.Option;

public class App implements Runnable {
    @Option(names = {"-m", "--mode"}, description = "Execution mode")
    String mode = "dev";

    @Option(names = {"-l", "--log"}, description = "Log level")
    int log = 1;

    public void run() {
        System.out.println("Mode: " + mode + ", Log: " + log);
    }

    public static void main(String[] args) {
        new CommandLine(new App()).execute(args);
    }
}

Picocli जैसी लाइब्रेरीज़ बायलरप्लेट को काफी हद तक कम करती हैं, स्वचालित वैलिडेशन प्रदान करती हैं, और हेल्प मैसेजेज़ को स्वतः जनरेट करती हैं।

9. अंतर्राष्ट्रीयकरण (Internationalization) के लिए तैयारी करें

यदि आपका एप्लिकेशन वैश्विक उपयोगकर्ताओं को लक्षित करता है, तो हेल्प मैसेजेज़ और लॉग्स को लोकलाइज़ेशन को ध्यान में रखकर डिज़ाइन करें। संदेशों के लिए रिसोर्स बंडल (.properties फ़ाइलें) का उपयोग करें, न कि हार्ड‑कोडेड अंग्रेज़ी टेक्स्ट।

ResourceBundle bundle = ResourceBundle.getBundle("messages", Locale.getDefault());
System.out.println(bundle.getString("usage.help"));

यह आपके प्रोग्राम को सिस्टम लोकेल के आधार पर स्वचालित रूप से भाषा बदलने में सक्षम बनाता है।

10. आर्ग्यूमेंट लॉजिक के लिए ऑटोमेटेड टेस्टिंग

सुनिश्चित करें कि आर्ग्यूमेंट पार्सिंग को यूनिट टेस्ट्स द्वारा कवर किया गया है, ताकि विकल्पों के जोड़े या संशोधित होने पर रिग्रेशन न हो।

@Test
void testModeArgument() {
    String[] args = {"--mode=prod"};
    assertDoesNotThrow(() -> MyApp.main(args));
}

ऑटोमेटेड टेस्ट्स यह भरोसा दिलाते हैं कि आपका CLI अपडेट्स और रीफ़ैक्टरिंग के दौरान स्थिर बना रहे।

सारांश

बैकवर्ड‑कम्पैटिबल आर्ग्यूमेंट स्ट्रक्चर को बनाए रखें।
स्पष्ट --help डॉक्यूमेंटेशन प्रदान करें।
लचीलापन के लिए कॉन्फ़िगरेशन को कोड से अलग रखें।
विश्वसनीयता और मेंटेनेबिलिटी के लिए लाइब्रेरीज़ और ऑटोमेशन का उपयोग करें।
शुरुआत से ही अंतर्राष्ट्रीयकरण और सुरक्षा पर विचार करें।

इन दिशानिर्देशों को अपनाकर, आपके जावा कमांड‑लाइन टूल्स स्थानीय और वैश्विक दोनों वातावरणों में प्रोफेशनल‑ग्रेड स्थिरता और उपयोगिता प्राप्त करेंगे।

9. सारांश और डिज़ाइन टेम्प्लेट

इस लेख में हमने जावा में कमांड‑लाइन आर्ग्यूमेंट्स को संभालने के पूरे जीवन‑चक्र को कवर किया — बुनियादी सिंटैक्स से लेकर वास्तविक‑दुनिया की सुरक्षा और डिप्लॉयमेंट विचारों तक। अब आइए मुख्य अवधारणाओं का सारांश लें और एक पुन: उपयोग योग्य डिज़ाइन टेम्प्लेट प्रदान करें जिसे आप अपने प्रोजेक्ट्स में अनुकूलित कर सकते हैं।

मुख्य बिंदु

✅ बेसिक स्ट्रक्चर: main मेथड में String[] args का उपयोग करके पैरामीटर प्राप्त करें।
✅ वैलिडेशन: हमेशा लापता या अमान्य इनपुट की जाँच करें और उपयोगी फीडबैक दें।
✅ कन्वर्ज़न: स्ट्रिंग आर्ग्यूमेंट्स को सुरक्षित रूप से न्यूमेरिक, बूलियन या कस्टम टाइप्स में बदलें।
✅ ऑप्शन पार्सिंग: स्पष्टता के लिए शॉर्ट ( -h ) और लॉन्ग ( --help ) दोनों विकल्पों को सपोर्ट करें।
✅ सिक्योरिटी: पाथ्स को नॉर्मलाइज़ करें, इनपुट को सैनिटाइज़ करें, और असुरक्षित कमांड एक्सीक्यूशन से बचें।
✅ प्रैक्टिकल यूज़: फ़ाइल प्रोसेसिंग, मोड कंट्रोल, और लॉगिंग कॉन्फ़िगरेशन के लिए आर्ग्यूमेंट्स का उपयोग करें।
✅ प्रोफेशनल प्रैक्टिस: डॉक्यूमेंटेशन, कंसिस्टेंट इंटरफ़ेस, और एग्ज़िट कोड्स प्रदान करें।
✅ स्केलेबिलिटी: बड़े प्रोजेक्ट्स के लिए Picocli या Commons CLI जैसी लाइब्रेरीज़ का उपयोग करें।
✅ ऑटोमेशन: JUnit या CI पाइपलाइन्स के माध्यम से आर्ग्यूमेंट हैंडलिंग का टेस्ट करें।

पुन: उपयोग योग्य डिज़ाइन टेम्प्लेट

निम्नलिखित टेम्प्लेट इस गाइड में चर्चा किए गए सर्वोत्तम अभ्यासों — वैधता, सहायता प्रदर्शन, पर्यावरण मोड हैंडलिंग, और लॉगिंग स्तर — को एक संक्षिप्त प्रोग्राम में एकीकृत करता है।

import java.util.*;

public class AppTemplate {

    static class Config {
        String mode = "dev";
        int logLevel = 1;
        String input = null;
        boolean help = false;
    }

    public static void main(String[] args) {
        Config cfg = parseArgs(args);

        if (cfg.help) {
            printHelp();
            System.exit(0);
        }

        // Logging example
        if (cfg.logLevel >= 3) System.out.println("[DEBUG] Mode = " + cfg.mode);
        if (cfg.logLevel >= 2) System.out.println("[INFO] Log level set to " + cfg.logLevel);

        if (cfg.input != null) {
            System.out.println("[INFO] Processing input file: " + cfg.input);
        } else {
            System.out.println("[WARN] No input file specified. Running default mode.");
        }

        // Main logic
        System.out.println("Running in " + cfg.mode + " mode.");
    }

    private static Config parseArgs(String[] args) {
        Config cfg = new Config();
        for (String arg : args) {
            if (arg.equals("-h") || arg.equals("--help")) {
                cfg.help = true;
            } else if (arg.startsWith("--mode=")) {
                cfg.mode = arg.split("=", 2)[1];
            } else if (arg.startsWith("--log=")) {
                try {
                    cfg.logLevel = Integer.parseInt(arg.split("=", 2)[1]);
                } catch (NumberFormatException e) {
                    System.err.println("Invalid log level, using default (1).");
                }
            } else if (arg.startsWith("--input=")) {
                cfg.input = arg.split("=", 2)[1];
            }
        }
        return cfg;
    }

    private static void printHelp() {
        System.out.println("Usage: java AppTemplate [options]");
        System.out.println("Options:");
        System.out.println("  --mode=<dev|test|prod>    Execution mode (default: dev)");
        System.out.println("  --log=<1|2|3>              Log level (1:normal, 2:verbose, 3:debug)");
        System.out.println("  --input=<file>             Input file path");
        System.out.println("  -h, --help                 Show this help message");
    }
}

यह डिज़ाइन प्रदान करता है:

व्यवसायिक लॉजिक से अलग स्पष्ट तर्क (आर्ग्युमेंट) पार्सिंग।
स्वचालित सहायता प्रदर्शन।
सुरक्षित संख्यात्मक रूपांतरण और डिफ़ॉल्ट मान।
डिबगिंग और प्रोडक्शन मोड के लिए सरल लॉगिंग नियंत्रण।

टेम्प्लेट का विस्तार

आप इस बेस टेम्प्लेट को कई दिशाओं में विस्तारित कर सकते हैं:

फ़ाइल अस्तित्व जाँच और अपवाद (एक्सेप्शन) हैंडलिंग जोड़ें।
Properties या JSON कॉन्फ़िगरेशन फ़ाइलों के साथ एकीकृत करें।
सबकमांड्स का समर्थन करें (उदा., java Tool analyze, java Tool export)।
रंगीन कंसोल आउटपुट या संरचित लॉगिंग लागू करें।
गुम तर्कों के लिए डिफ़ॉल्ट के रूप में पर्यावरण वेरिएबल्स लोड करें।

इन सुधारों को मिलाकर, आप इस हल्के संरचना को अपने प्रोजेक्ट की आवश्यकताओं के अनुसार एक मजबूत CLI फ्रेमवर्क में विकसित कर सकते हैं।

अंतिम शब्द

कमांड‑लाइन तर्क सरल लग सकते हैं, लेकिन वे कॉन्फ़िगर‑योग्य, परीक्षण‑योग्य और स्वचालित सॉफ़्टवेयर की नींव बनाते हैं। इन्हें उसी सावधानी से डिज़ाइन करें जैसे आप अपने API इंटरफ़ेस को बनाते हैं — साफ़, पूर्वानुमेय और सुरक्षित।

संक्षेप में: सुव्यवस्थित तर्क डिज़ाइन में प्रयास निवेश करने से विकास के सभी चरणों में लाभ मिलता है — डिबगिंग और ऑटोमेशन से लेकर डिप्लॉयमेंट और दीर्घकालिक रखरखाव तक।

इन सिद्धांतों और टेम्प्लेट्स के साथ, आप अब पेशेवर‑ग्रेड कमांड‑लाइन टूल्स डिज़ाइन कर सकते हैं जो पर्यावरण, टीम और वर्षों के विकास में लगातार समान व्यवहार करते हैं।

अक्सर पूछे जाने वाले प्रश्न (FAQ)

यह अनुभाग जावा में कमांड‑लाइन तर्कों को संभालने के बारे में डेवलपर्स के सामान्य प्रश्नों का सार प्रस्तुत करता है। प्रत्येक उत्तर में संक्षिप्त उदाहरण या व्यावहारिक मार्गदर्शन शामिल है।

Q1. वैकल्पिक और आवश्यक दोनों तर्कों को मैं कैसे संभाल सकता हूँ?

आवश्यक तर्कों को स्पष्ट रूप से मान्य किया जाना चाहिए — उदाहरण के लिए, args.length की जाँच करके या किसी विशिष्ट फ़्लैग की उपस्थिति को देख कर। वैकल्पिक तर्कों के लिए सुरक्षित डिफ़ॉल्ट मान रखे जा सकते हैं।

if (args.length < 1) {
    System.err.println("Error: Missing input file");
    System.exit(1);
}

String input = args[0];
String mode = (args.length > 1) ? args[1] : "dev";

बड़े प्रोजेक्ट्स में, अपने तर्क स्कीमा को Picocli या Apache Commons CLI जैसी लाइब्रेरीज़ का उपयोग करके परिभाषित करें, जो आवश्यक/वैकल्पिक फ़्लैग्स को स्वचालित रूप से समर्थन करती हैं।

Q2. तर्क में स्पेस (जैसे फ़ाइल नाम या वाक्यांश) कैसे शामिल करें?

टर्मिनल से चलाते समय तर्क को डबल कोट्स में घेरें:

java Example "New York City" Japan

आउटपुट:

args[0] = New York City
args[1] = Japan

यह सुनिश्चित करता है कि पूरा वाक्यांश एक ही तर्क के रूप में माना जाए, न कि कई शब्दों के रूप में।

Q3. यदि कोई तर्क प्रदान नहीं किया गया तो क्या होता है?

यदि कोई तर्क पास नहीं किया जाता है, तो args.length 0 के बराबर होता है। आप इसे सुरक्षित रूप से पहचान कर एक मदद संदेश दिखा कर या डिफ़ॉल्ट मानों का उपयोग करके संभाल सकते हैं।

if (args.length == 0) {
    System.out.println("No arguments provided. Running default mode...");
}

Q4. IntelliJ या Eclipse जैसे IDE में तर्कों का परीक्षण कैसे करें?

दोनों IDE में प्रोग्राम तर्कों के लिए कॉन्फ़िगरेशन डायलॉग होते हैं:

Eclipse: Run → Run Configurations → Arguments टैब → तर्क दर्ज करें।
IntelliJ IDEA: Run → Edit Configurations → Program arguments फ़ील्ड।

उदाहरण: --mode=prod --log=2 --input=data.txt

Q5. “–debug” या “–verbose” जैसे बूलियन फ़्लैग्स को कैसे संभालें?

बूलियन फ़्लैग्स आमतौर पर बिना किसी मान के आते हैं। आप उन्हें equals() या contains() मेथड्स का उपयोग करके पहचान सकते हैं।

boolean debug = false;
for (String arg : args) {
    if (arg.equals("--debug") || arg.equals("-d")) {
        debug = true;
    }
}

if (debug) System.out.println("Debug mode enabled.");

Q6. “java -jar” एप्लिकेशन को कई तर्क कैसे पास करें?

जब आप एक पैकेज्ड JAR फ़ाइल चलाते हैं, तो JAR नाम के बाद तर्क रखें। उदाहरण:

java -jar MyApp.jar --mode=prod input.txt --log=3

एप्लिकेशन का main(String[] args) मानक निष्पादन की तरह ही वही तर्क प्राप्त करता है।

Q7. कमांड लाइन के बजाय कॉन्फ़िगरेशन फ़ाइल से तर्क कैसे पढ़ें?

आप Java की Properties या YAML/JSON लाइब्रेरीज़ का उपयोग करके डिफ़ॉल्ट सेटिंग्स लोड कर सकते हैं, और फिर यदि निर्दिष्ट किया गया हो तो CLI तर्कों से उन्हें ओवरराइड कर सकते हैं।

Properties props = new Properties();
props.load(new FileInputStream("config.properties"));
String mode = props.getProperty("mode", "dev");

// CLI overrides file
for (String arg : args) {
    if (arg.startsWith("--mode=")) {
        mode = arg.split("=", 2)[1];
    }
}

Q8. क्या मैं तर्कों में Unicode या गैर‑ASCII अक्षर उपयोग कर सकता हूँ?

हां, Java args में Unicode स्ट्रिंग्स को पूरी तरह समर्थन करता है। हालांकि, आपका टर्मिनल या ऑपरेटिंग सिस्टम एन्कोडिंग भी उन अक्षरों को समर्थन देना चाहिए जो आप उपयोग करते हैं। Windows पर, UTF-8 लोकल (chcp 65001) के साथ चलाने पर विचार करें, और Linux/macOS पर, सुनिश्चित करें कि शेल UTF-8 एन्कोडिंग का उपयोग करता है।

Q9. उपयोगकर्ता‑द्वारा प्रदान किए गए तर्कों से सुरक्षा समस्याओं को कैसे रोकें?

✅ सभी इनपुट्स को मान्य करें (संख्यात्मक रेंज, फ़ाइल पाथ, URLs)।
✅ पाथ को सामान्यीकृत करें ताकि डायरेक्टरी ट्रैवर्सल ( ../ ) रोका जा सके।
✅ उपयोगकर्ता इनपुट को शेल कमांड में कभी न जोड़ें।
✅ सख्त मान्यकरण के लिए व्हाइटलिस्ट या रेगेक्स पैटर्न का उपयोग करें।

प्रोडक्शन टूल्स के लिए, ऐसे अक्षरों जैसे ;, |, या && को अस्वीकार करने या एस्केप करने पर विचार करें, जो शेल निष्पादन को ट्रिगर कर सकते हैं।

Q10. क्या मुझे अभी भी “args” को मैन्युअल रूप से उपयोग करना चाहिए या लाइब्रेरी अपनानी चाहिए?

छोटे यूटिलिटीज़ के लिए, String[] args के साथ मैन्युअल पार्सिंग ठीक है। दीर्घकालिक या एंटरप्राइज़‑ग्रेड टूल्स के लिए, एक समर्पित लाइब्रेरी का उपयोग करें:

Picocli — एनोटेशन‑आधारित, एकीकृत करने में आसान।
Apache Commons CLI — बारीकी से परीक्षणित क्लासिक लाइब्रेरी।
JCommander — सरल और हल्का।

एक लाइब्रेरी का उपयोग बग्स को कम करता है, पठनीयता में सुधार करता है, और अंतर्निहित सहायता और वैधता सुविधाएँ प्रदान करता है।

Q11. मैं सभी प्राप्त तर्कों को आसानी से कैसे प्रिंट कर सकता हूँ?

System.out.println("Received arguments:");
for (int i = 0; i < args.length; i++) {
    System.out.printf("args[%d] = %s%n", i, args[i]);
}

यह स्निपेट तर्क पार्सिंग लॉजिक को डिबग करने के लिए बिल्कुल उपयुक्त है।

Q12. क्या मैं तर्कों और पर्यावरण वेरिएबल्स को मिलाकर उपयोग कर सकता हूँ?

हाँ। पर्यावरण वेरिएबल्स सिस्टम-व्यापी कॉन्फ़िगरेशन (जैसे API कुंजियों) के लिए उत्कृष्ट हैं, जबकि कमांड-लाइन तर्क अस्थायी ओवरराइड के लिए सबसे उपयुक्त हैं।

String apiKey = System.getenv().getOrDefault("API_KEY", "none");
for (String arg : args) {
    if (arg.startsWith("--api=")) {
        apiKey = arg.split("=", 2)[1];
    }
}
System.out.println("API Key: " + (apiKey.equals("none") ? "not set" : "[REDACTED]"));

यह स्तरित कॉन्फ़िगरेशन मॉडल आपके सॉफ़्टवेयर को लचीला और सुरक्षित दोनों बनाता है।

Q13. मैं गलत तर्क प्रकारों को सहजता से कैसे संभालूँ?

try-catch ब्लॉक्स का उपयोग करें और प्रोग्राम को क्रैश किए बिना सार्थक त्रुटि संदेश प्रदान करें:

try {
    int threads = Integer.parseInt(args[0]);
} catch (NumberFormatException e) {
    System.err.println("Invalid number format: " + args[0]);
    System.exit(1);
}

यह साफ़ समाप्ति सुनिश्चित करता है और उपयोगकर्ताओं को उनका इनपुट शीघ्रता से सुधारने में मदद करता है।

Q14. क्या मैं सहायता या त्रुटियों के लिए रंगीन आउटपुट प्रदर्शित कर सकता हूँ?

हाँ, आप अधिकांश टर्मिनलों में रंगीन आउटपुट के लिए ANSI एस्केप कोड का उपयोग कर सकते हैं:

final String RED = "u001B[31m";
final String RESET = "u001B[0m";
System.err.println(RED + "Error: Invalid argument" + RESET);

Picocli और Jansi जैसी लाइब्रेरीज़ इसे स्वचालित रूप से क्रॉस-प्लेटफ़ॉर्म संगतता के साथ संभाल सकती हैं।

Q15. मैं तर्क पार्सिंग को अधिक कुशलता से कैसे डिबग कर सकता हूँ?

स्टार्टअप के दौरान सभी आंतरिक स्थिति को प्रिंट करने वाले --debug या --trace फ़्लैग्स के साथ एक “डायग्नोस्टिक” मोड जोड़ें। उदाहरण:

if (Arrays.asList(args).contains("--debug")) {
    System.out.println("[TRACE] Arguments: " + Arrays.toString(args));
}

यह उत्पादन वातावरण में ऑटोमेशन या कॉन्फ़िगरेशन समस्याओं को हल करने के समय अत्यंत उपयोगी है।

जावा कमांड-लाइन आर्ग्युमेंट्स में महारत — बुनियादी से लेकर सुरक्षित, व्यावहारिक पैटर्न तक

1. परिचय

इस अध्याय का उद्देश्य

कमांड-लाइन तर्क क्या हैं?

उपयोग के मामले

प्रमुख डिज़ाइन विचार

कॉन्फ़िग फ़ाइलों और पर्यावरण चरों के बीच चयन

न्यूनतम उदाहरण (सभी तर्कों को सूचीबद्ध करना)

आगे क्या (रोडमैप)

2. जावा में कमांड-लाइन तर्क कैसे प्राप्त करें

मूल संरचना

विशिष्ट आर्ग्युमेंट्स तक पहुँच

गायब आर्ग्युमेंट्स को सुरक्षित रूप से संभालना

उद्धरण और व्हाइटस्पेस

जब कोई आर्ग्युमेंट प्रदान नहीं किया गया हो

3. डेटा रूपांतरण और त्रुटि संभालना

स्ट्रिंग्स को इंटीजर और डबल में बदलना

बूलियन्स को संभालना

डिफ़ॉल्ट मानों के साथ सुरक्षित रूपांतरण

त्रुटियों को सहजता से पकड़ना और रिपोर्ट करना

वैकल्पिक: जावा के Optional क्लास का उपयोग

4. विकल्प‑शैली तर्कों को संभालना

छोटे और लंबे विकल्प

फ़्लैग्स और मानों को मिलाना

कई विकल्पों को मिलाना

Apache Commons CLI का उपयोग (सिफ़ारिश किया गया)

सर्वोत्तम प्रथाओं का सारांश

5. IDE में कमांड-लाइन आर्ग्युमेंट सेट करना और परीक्षण करना

Eclipse में आर्ग्युमेंट सेट करना

IntelliJ IDEA में तर्क सेट करना

कई पैटर्न को जल्दी परीक्षण करना

JUnit परीक्षणों के दौरान तर्क पास करना

IDE तर्क परीक्षण में सामान्य गलतियाँ

6. त्रुटि प्रबंधन और सुरक्षा डिज़ाइन

उपयोग से पहले सत्यापित करें

फ़ाइल पाथ दुरुपयोग को रोकें

मनमाने कमांड निष्पादित करने से बचें

त्रुटि रिपोर्टिंग और एग्ज़िट कोड

लॉग और त्रुटि आउटपुट को साफ़ करें

डिफेंसिव कोडिंग सारांश

7. व्यावहारिक उदाहरण — फ़ाइल हैंडलिंग, मोड स्विचिंग, और लॉगिंग नियंत्रण

उदाहरण 1: फ़ाइल प्रोसेसिंग प्रोग्राम

उदाहरण 2: मोड्स के बीच स्विच करना (डेवलपमेंट / प्रोडक्शन)

उदाहरण 3: लॉग लेवल और डिबग नियंत्रण

सभी पैटर्न को मिलाना

व्यावहारिक पैटर्न का सारांश

8. वास्तविक-विश्व परिनियोजन में सर्वोत्तम प्रथाएँ

1. इंटरफ़ेस को सुसंगत रखें

2. हेल्प विकल्प प्रदान करें

3. तर्क व्यवहार को स्पष्ट रूप से दस्तावेज़ करें

4. कॉन्फ़िगरेशन को कोड से अलग रखें

5. छोटे और लंबे दोनों रूपों का समर्थन करें

6. अर्थपूर्ण एग्ज़िट कोड लौटाएँ

7. तर्कों और पर्यावरण को सुरक्षित रूप से लॉग करें

8. स्केलेबिलिटी के लिए लाइब्रेरीज़ का उपयोग करें

9. अंतर्राष्ट्रीयकरण (Internationalization) के लिए तैयारी करें

10. आर्ग्यूमेंट लॉजिक के लिए ऑटोमेटेड टेस्टिंग

सारांश

9. सारांश और डिज़ाइन टेम्प्लेट

मुख्य बिंदु

पुन: उपयोग योग्य डिज़ाइन टेम्प्लेट

टेम्प्लेट का विस्तार

अंतिम शब्द

अक्सर पूछे जाने वाले प्रश्न (FAQ)

Q1. वैकल्पिक और आवश्यक दोनों तर्कों को मैं कैसे संभाल सकता हूँ?

Q2. तर्क में स्पेस (जैसे फ़ाइल नाम या वाक्यांश) कैसे शामिल करें?

Q3. यदि कोई तर्क प्रदान नहीं किया गया तो क्या होता है?

Q4. IntelliJ या Eclipse जैसे IDE में तर्कों का परीक्षण कैसे करें?

Q5. “–debug” या “–verbose” जैसे बूलियन फ़्लैग्स को कैसे संभालें?

Q6. “java -jar” एप्लिकेशन को कई तर्क कैसे पास करें?

Q7. कमांड लाइन के बजाय कॉन्फ़िगरेशन फ़ाइल से तर्क कैसे पढ़ें?

Q8. क्या मैं तर्कों में Unicode या गैर‑ASCII अक्षर उपयोग कर सकता हूँ?

Q9. उपयोगकर्ता‑द्वारा प्रदान किए गए तर्कों से सुरक्षा समस्याओं को कैसे रोकें?

Q10. क्या मुझे अभी भी “args” को मैन्युअल रूप से उपयोग करना चाहिए या लाइब्रेरी अपनानी चाहिए?

Q11. मैं सभी प्राप्त तर्कों को आसानी से कैसे प्रिंट कर सकता हूँ?

Q12. क्या मैं तर्कों और पर्यावरण वेरिएबल्स को मिलाकर उपयोग कर सकता हूँ?

Q13. मैं गलत तर्क प्रकारों को सहजता से कैसे संभालूँ?

Q14. क्या मैं सहायता या त्रुटियों के लिए रंगीन आउटपुट प्रदर्शित कर सकता हूँ?

Q15. मैं तर्क पार्सिंग को अधिक कुशलता से कैसे डिबग कर सकता हूँ?

जावा प्रोग्राम को कैसे कंपाइल करें: शुरुआती‑अनुकूल गाइड javac, PATH सेटअप और सामान्य त्रुटियों के लिए