【完全ガイド】Javaのコマンドライン引数を使いこなす12の必須テクニック

java MyProgram argument1 argument2 argument3

public class CommandLineDemo {
    public static void main(String[] args) {
        // argsにコマンドライン引数が配列として格納される
        System.out.println("受け取った引数の数: " + args.length);
    }
}

public class ArgumentExample {
    public static void main(String[] args) {
        // 引数の数をチェック
        if (args.length == 0) {
            System.out.println("引数が指定されていません");
            return;
        }

        // 各引数を出力
        for (int i = 0; i < args.length; i++) {
            System.out.printf("引数%d: %s%n", i, args[i]);
        }

        // 特定の引数を使用した処理例
        if (args.length >= 2) {
            String name = args[0];    // 1番目の引数
            String age = args[1];     // 2番目の引数
            System.out.printf("名前: %s, 年齢: %s%n", name, age);
        }
    }
}

public class ArgumentConverter {
    public static void main(String[] args) {
        if (args.length < 4) {
            System.out.println("使用法: java ArgumentConverter <整数> <小数> <真偽値> <文字列>");
            return;
        }

        try {
            // 整数への変換
            int intValue = Integer.parseInt(args[0]);
            // 小数への変換
            double doubleValue = Double.parseDouble(args[1]);
            // 真偽値への変換
            boolean boolValue = Boolean.parseBoolean(args[2]);
            // 文字列はそのまま使用
            String stringValue = args[3];

            // 変換結果の出力
            System.out.printf("整数: %d（%s）%n", intValue, intValue.getClass().getSimpleName());
            System.out.printf("小数: %.2f（%s）%n", doubleValue, ((Double)doubleValue).getClass().getSimpleName());
            System.out.printf("真偽値: %b（%s）%n", boolValue, ((Boolean)boolValue).getClass().getSimpleName());
            System.out.printf("文字列: %s（%s）%n", stringValue, stringValue.getClass().getSimpleName());
        } catch (NumberFormatException e) {
            System.out.println("数値の変換に失敗しました: " + e.getMessage());
        }
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class MultipleArgumentsHandler {
    public static void main(String[] args) {
        // Stream APIを使用した処理
        List<String> argList = Arrays.asList(args);

        // フィルタリングと処理
        List<String> filteredArgs = argList.stream()
            .filter(arg -> arg.startsWith("--"))  // オプション引数のフィルタリング
            .collect(Collectors.toList());

        // 可変長引数としての処理
        processVariableArgs(args);

        // 引数のグループ化（2つずつ）
        for (int i = 0; i < args.length - 1; i += 2) {
            String key = args[i];
            String value = args[i + 1];
            System.out.printf("キー: %s, 値: %s%n", key, value);
        }
    }

    // 可変長引数を使用したメソッド
    private static void processVariableArgs(String... args) {
        for (String arg : args) {
            System.out.println("処理: " + arg);
        }
    }
}

import java.util.HashMap;
import java.util.Map;

public class OptionArgumentHandler {
    public static void main(String[] args) {
        // オプションとその値を格納するマップ
        Map<String, String> options = new HashMap<>();

        // デフォルト値の設定
        String outputFormat = "text";  // デフォルトは"text"
        boolean verbose = false;       // デフォルトはfalse

        // 引数の解析
        for (int i = 0; i < args.length; i++) {
            String arg = args[i];

            switch (arg) {
                case "--format":
                    if (i + 1 < args.length) {
                        outputFormat = args[++i];
                    }
                    break;

                case "--verbose":
                    verbose = true;
                    break;

                case "--help":
                    printHelp();
                    return;

                default:
                    if (arg.startsWith("--")) {
                        if (i + 1 < args.length) {
                            options.put(arg.substring(2), args[++i]);
                        }
                    }
                    break;
            }
        }

        // 解析結果の使用
        System.out.println("出力フォーマット: " + outputFormat);
        System.out.println("詳細モード: " + verbose);
        System.out.println("その他のオプション: " + options);
    }

    private static void printHelp() {
        System.out.println("使用法: java OptionArgumentHandler [options]");
        System.out.println("オプション:");
        System.out.println("  --format <format>   出力フォーマットの指定（text/json/xml）");
        System.out.println("  --verbose           詳細モードの有効化");
        System.out.println("  --help              このヘルプメッセージの表示");
    }
}

public class ArgumentBoundsHandler {
    public static void main(String[] args) {
        try {
            // 必須引数の数を定義
            final int REQUIRED_ARGS = 2;

            // 引数の数を検証
            if (args.length < REQUIRED_ARGS) {
                throw new IllegalArgumentException(
                    String.format("引数が不足しています。%d個の引数が必要です。", REQUIRED_ARGS)
                );
            }

            // 安全な引数取得メソッドを使用
            String firstArg = getArgSafely(args, 0);
            String secondArg = getArgSafely(args, 1);

            // 引数を使用した処理
            processArguments(firstArg, secondArg);

        } catch (IllegalArgumentException e) {
            System.err.println("引数エラー: " + e.getMessage());
            printUsage();
            System.exit(1);
        }
    }

    // 安全に引数を取得するユーティリティメソッド
    private static String getArgSafely(String[] args, int index) {
        if (index < 0 || index >= args.length) {
            throw new IllegalArgumentException(
                String.format("インデックス %d の引数は存在しません。", index)
            );
        }
        return args[index];
    }

    private static void processArguments(String arg1, String arg2) {
        System.out.printf("引数1: %s, 引数2: %s%n", arg1, arg2);
    }

    private static void printUsage() {
        System.out.println("使用法: java ArgumentBoundsHandler <arg1> <arg2>");
    }
}

public class NumberFormatHandler {
    public static void main(String[] args) {
        try {
            // 数値引数の処理
            int value = parseIntSafely(args, 0, "数値引数が必要です。");
            double rate = parseDoubleSafely(args, 1, "レート値が必要です。");

            // 値の範囲チェック
            validateNumberRange(value, 0, 100, "値は0から100の間である必要があります。");
            validateNumberRange(rate, 0.0, 1.0, "レートは0.0から1.0の間である必要があります。");

            // 処理の実行
            System.out.printf("計算結果: %.2f%n", value * rate);

        } catch (IllegalArgumentException e) {
            System.err.println("入力エラー: " + e.getMessage());
            System.exit(1);
        }
    }

    // 整数の安全な変換
    private static int parseIntSafely(String[] args, int index, String errorMessage) {
        if (index >= args.length) {
            throw new IllegalArgumentException(errorMessage);
        }
        try {
            return Integer.parseInt(args[index]);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException(
                String.format("'%s'は有効な整数ではありません。", args[index])
            );
        }
    }

    // 小数の安全な変換
    private static double parseDoubleSafely(String[] args, int index, String errorMessage) {
        if (index >= args.length) {
            throw new IllegalArgumentException(errorMessage);
        }
        try {
            return Double.parseDouble(args[index]);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException(
                String.format("'%s'は有効な小数ではありません。", args[index])
            );
        }
    }

    // 数値範囲の検証
    private static <T extends Comparable<T>> void validateNumberRange(
            T value, T min, T max, String errorMessage) {
        if (value.compareTo(min) < 0 || value.compareTo(max) > 0) {
            throw new IllegalArgumentException(errorMessage);
        }
    }
}

public class ArgumentValidator {
    public static void main(String[] args) {
        try {
            // バリデーションの実行
            validateArguments(args);

            // バリデーション済みの引数を使用した処理
            processValidatedArguments(args);

        } catch (ValidationException e) {
            System.err.println("バリデーションエラー: " + e.getMessage());
            printUsage();
            System.exit(1);
        }
    }

    // カスタム例外クラス
    static class ValidationException extends Exception {
        public ValidationException(String message) {
            super(message);
        }
    }

    // 引数のバリデーション
    private static void validateArguments(String[] args) throws ValidationException {
        // 1. 引数の数のチェック
        if (args.length == 0) {
            throw new ValidationException("引数が指定されていません。");
        }

        // 2. 必須オプションのチェック
        boolean hasInputFile = false;
        boolean hasOutputFormat = false;

        for (int i = 0; i < args.length; i++) {
            switch (args[i]) {
                case "--input":
                    if (++i < args.length) {
                        validateFilePath(args[i]);
                        hasInputFile = true;
                    }
                    break;
                case "--format":
                    if (++i < args.length) {
                        validateOutputFormat(args[i]);
                        hasOutputFormat = true;
                    }
                    break;
            }
        }

        // 3. 必須オプションの存在確認
        if (!hasInputFile) {
            throw new ValidationException("入力ファイルが指定されていません。");
        }
        if (!hasOutputFormat) {
            throw new ValidationException("出力フォーマットが指定されていません。");
        }
    }

    // ファイルパスのバリデーション
    private static void validateFilePath(String path) throws ValidationException {
        if (path == null || path.trim().isEmpty()) {
            throw new ValidationException("ファイルパスが空です。");
        }
        if (!path.endsWith(".txt") && !path.endsWith(".csv")) {
            throw new ValidationException("サポートされていないファイル形式です。");
        }
    }

    // 出力フォーマットのバリデーション
    private static void validateOutputFormat(String format) throws ValidationException {
        String[] validFormats = {"json", "xml", "csv"};
        boolean isValid = false;
        for (String validFormat : validFormats) {
            if (validFormat.equals(format.toLowerCase())) {
                isValid = true;
                break;
            }
        }
        if (!isValid) {
            throw new ValidationException("無効な出力フォーマットです。");
        }
    }

    private static void processValidatedArguments(String[] args) {
        // バリデーション済みの引数を使用した処理
        System.out.println("引数の処理を実行中...");
    }

    private static void printUsage() {
        System.out.println("使用法: java ArgumentValidator --input <file> --format <format>");
        System.out.println("サポートされるフォーマット: json, xml, csv");
    }
}

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class ConfigFileHandler {
    public static void main(String[] args) {
        // デフォルトの設定値
        String configPath = "config/default.properties";
        Properties config = new Properties();

        try {
            // コマンドライン引数からconfig pathを取得
            if (args.length > 0 && args[0].startsWith("--config=")) {
                configPath = args[0].substring("--config=".length());
            }

            // 設定ファイルの読み込み
            try (FileInputStream fis = new FileInputStream(configPath)) {
                config.load(fis);
                System.out.println("設定ファイルを読み込みました: " + configPath);

                // 設定値の使用例
                String dbUrl = config.getProperty("database.url", "jdbc:mysql://localhost:3306/mydb");
                String dbUser = config.getProperty("database.user", "root");
                int maxConnections = Integer.parseInt(config.getProperty("database.maxConnections", "10"));

                // 設定値の表示
                System.out.println("データベースURL: " + dbUrl);
                System.out.println("ユーザー名: " + dbUser);
                System.out.println("最大接続数: " + maxConnections);

            } catch (IOException e) {
                System.err.println("設定ファイルの読み込みに失敗しました: " + e.getMessage());
                System.exit(1);
            }

        } catch (Exception e) {
            System.err.println("エラーが発生しました: " + e.getMessage());
            System.out.println("使用法: java ConfigFileHandler [--config=<設定ファイルのパス>]");
            System.exit(1);
        }
    }
}

database.url=jdbc:mysql://localhost:3306/mydb
database.user=admin
database.password=secret
database.maxConnections=20

public class ApplicationModeHandler {
    // 実行モードの列挙型
    private enum Mode {
        DEVELOPMENT,
        PRODUCTION,
        TEST
    }

    public static void main(String[] args) {
        try {
            // デフォルトモード
            Mode currentMode = Mode.DEVELOPMENT;
            boolean verboseLogging = false;

            // 引数の解析
            for (String arg : args) {
                if (arg.startsWith("--mode=")) {
                    String modeStr = arg.substring("--mode=".length()).toUpperCase();
                    try {
                        currentMode = Mode.valueOf(modeStr);
                    } catch (IllegalArgumentException e) {
                        throw new IllegalArgumentException("無効なモード: " + modeStr);
                    }
                } else if (arg.equals("--verbose")) {
                    verboseLogging = true;
                }
            }

            // モードに応じた設定の適用
            configureProgramMode(currentMode, verboseLogging);

            // アプリケーションの実行
            runApplication(currentMode);

        } catch (Exception e) {
            System.err.println("エラー: " + e.getMessage());
            System.out.println("使用法: java ApplicationModeHandler --mode=[DEVELOPMENT|PRODUCTION|TEST] [--verbose]");
            System.exit(1);
        }
    }

    private static void configureProgramMode(Mode mode, boolean verbose) {
        System.out.println("アプリケーションモード: " + mode);
        System.out.println("詳細ログ: " + (verbose ? "有効" : "無効"));

        switch (mode) {
            case DEVELOPMENT:
                // 開発モードの設定
                System.setProperty("debug", "true");
                System.setProperty("cache.enabled", "false");
                break;

            case PRODUCTION:
                // 本番モードの設定
                System.setProperty("debug", "false");
                System.setProperty("cache.enabled", "true");
                break;

            case TEST:
                // テストモードの設定
                System.setProperty("debug", "true");
                System.setProperty("mock.enabled", "true");
                break;
        }
    }

    private static void runApplication(Mode mode) {
        System.out.println(mode + " モードでアプリケーションを実行中...");
        // アプリケーションの実際の処理をここに記述
    }
}

import java.io.*;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

public class BatchProcessor {
    public static void main(String[] args) {
        try {
            // バッチ処理の設定をコマンドライン引数から解析
            BatchConfig config = parseBatchConfig(args);

            // バッチ処理の実行
            processData(config);

        } catch (Exception e) {
            System.err.println("バッチ処理エラー: " + e.getMessage());
            printUsage();
            System.exit(1);
        }
    }

    private static class BatchConfig {
        String inputDir;
        String outputDir;
        LocalDate processDate;
        boolean backupEnabled;
        int batchSize;

        public BatchConfig() {
            // デフォルト値の設定
            this.inputDir = "input";
            this.outputDir = "output";
            this.processDate = LocalDate.now();
            this.backupEnabled = false;
            this.batchSize = 1000;
        }
    }

    private static BatchConfig parseBatchConfig(String[] args) {
        BatchConfig config = new BatchConfig();

        for (int i = 0; i < args.length; i++) {
            String arg = args[i];

            switch (arg) {
                case "--input-dir":
                    if (++i < args.length) config.inputDir = args[i];
                    break;

                case "--output-dir":
                    if (++i < args.length) config.outputDir = args[i];
                    break;

                case "--date":
                    if (++i < args.length) {
                        config.processDate = LocalDate.parse(args[i], 
                            DateTimeFormatter.ISO_DATE);
                    }
                    break;

                case "--backup":
                    config.backupEnabled = true;
                    break;

                case "--batch-size":
                    if (++i < args.length) {
                        config.batchSize = Integer.parseInt(args[i]);
                    }
                    break;
            }
        }

        validateConfig(config);
        return config;
    }

    private static void validateConfig(BatchConfig config) {
        File inputDir = new File(config.inputDir);
        if (!inputDir.exists() || !inputDir.isDirectory()) {
            throw new IllegalArgumentException("入力ディレクトリが存在しません: " + config.inputDir);
        }

        if (config.batchSize <= 0) {
            throw new IllegalArgumentException("バッチサイズは正の整数である必要があります");
        }
    }

    private static void processData(BatchConfig config) {
        System.out.println("バッチ処理を開始します");
        System.out.println("入力ディレクトリ: " + config.inputDir);
        System.out.println("出力ディレクトリ: " + config.outputDir);
        System.out.println("処理日付: " + config.processDate);
        System.out.println("バックアップ: " + (config.backupEnabled ? "有効" : "無効"));
        System.out.println("バッチサイズ: " + config.batchSize);

        // ここに実際のバッチ処理ロジックを実装
    }

    private static void printUsage() {
        System.out.println("使用法: java BatchProcessor [options]");
        System.out.println("オプション:");
        System.out.println("  --input-dir <dir>   入力ディレクトリのパス");
        System.out.println("  --output-dir <dir>  出力ディレクトリのパス");
        System.out.println("  --date <YYYY-MM-DD> 処理日付");
        System.out.println("  --backup            バックアップの有効化");
        System.out.println("  --batch-size <num>  バッチサイズの指定");
    }
}

import org.apache.commons.cli.*;

public class CommonsCLIExample {
    public static void main(String[] args) {
        // オプションの定義
        Options options = new Options();

        // 必須オプション
        Option input = Option.builder("i")
                .longOpt("input")
                .hasArg()
                .required()
                .desc("入力ファイルのパス")
                .build();

        // オプショナルな引数
        Option output = Option.builder("o")
                .longOpt("output")
                .hasArg()
                .desc("出力ファイルのパス")
                .build();

        // フラグオプション
        Option verbose = Option.builder("v")
                .longOpt("verbose")
                .desc("詳細なログ出力の有効化")
                .build();

        // 複数の値を取るオプション
        Option formats = Option.builder("f")
                .longOpt("formats")
                .hasArgs()
                .desc("出力フォーマット（複数指定可）")
                .valueSeparator(',')
                .build();

        options.addOption(input);
        options.addOption(output);
        options.addOption(verbose);
        options.addOption(formats);

        try {
            // コマンドラインの解析
            CommandLineParser parser = new DefaultParser();
            CommandLine cmd = parser.parse(options, args);

            // オプションの取得と使用
            String inputPath = cmd.getOptionValue("input");
            String outputPath = cmd.getOptionValue("output", "output.txt"); // デフォルト値の指定
            boolean isVerbose = cmd.hasOption("verbose");
            String[] outputFormats = cmd.getOptionValues("formats");

            // 処理の実行
            processWithOptions(inputPath, outputPath, isVerbose, outputFormats);

        } catch (ParseException e) {
            System.err.println("引数の解析エラー: " + e.getMessage());
            // ヘルプ情報の表示
            HelpFormatter formatter = new HelpFormatter();
            formatter.printHelp("CommonsCLIExample", options, true);
            System.exit(1);
        }
    }

    private static void processWithOptions(
            String input, String output, boolean verbose, String[] formats) {
        System.out.println("入力ファイル: " + input);
        System.out.println("出力ファイル: " + output);
        System.out.println("詳細ログ: " + (verbose ? "有効" : "無効"));

        if (formats != null) {
            System.out.println("出力フォーマット:");
            for (String format : formats) {
                System.out.println("- " + format);
            }
        }
    }
}

import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.regex.Pattern;

public class SecureArgumentHandler {
    // 安全な文字パターンの定義
    private static final Pattern SAFE_STRING_PATTERN = 
        Pattern.compile("^[a-zA-Z0-9_\\-\\.]+$");

    public static void main(String[] args) {
        try {
            // 引数の検証と安全な処理
            processArgumentsSecurely(args);
        } catch (SecurityException e) {
            System.err.println("セキュリティエラー: " + e.getMessage());
            System.exit(1);
        }
    }

    private static void processArgumentsSecurely(String[] args) {
        for (String arg : args) {
            // コマンドインジェクション対策
            if (containsShellCharacters(arg)) {
                throw new SecurityException("不正な文字が含まれています: " + arg);
            }

            // パストラバーサル対策
            if (arg.startsWith("--file=")) {
                String filePath = arg.substring("--file=".length());
                validateFilePath(filePath);
            }

            // SQLインジェクション対策
            if (arg.startsWith("--query=")) {
                String query = arg.substring("--query=".length());
                validateQueryString(query);
            }
        }
    }

    // シェル特殊文字のチェック
    private static boolean containsShellCharacters(String input) {
        return input.contains("|") || input.contains("&") || 
               input.contains(";") || input.contains("`") ||
               input.contains("$") || input.contains("(");
    }

    // ファイルパスの検証
    private static void validateFilePath(String filePath) {
        try {
            Path normalizedPath = Paths.get(filePath).normalize();
            Path currentDir = Paths.get(".").toAbsolutePath();

            if (!normalizedPath.toAbsolutePath()
                    .startsWith(currentDir)) {
                throw new SecurityException("許可されていないディレクトリへのアクセス");
            }
        } catch (Exception e) {
            throw new SecurityException("無効なファイルパス: " + e.getMessage());
        }
    }

    // クエリ文字列の検証
    private static void validateQueryString(String query) {
        if (!SAFE_STRING_PATTERN.matcher(query).matches()) {
            throw new SecurityException("不正なクエリ文字列");
        }
    }

    // 機密データの安全な処理
    private static void handleSensitiveData(String data) {
        try {
            // 機密データの処理
            // ...
            // 処理後のクリーンアップ
            System.gc();  // 注意: 完全な保証はありません
        } finally {
            // 変数の明示的なクリア
            data = null;
        }
    }
}

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

public class ArgumentProcessorTest {
    @Mock
    private ArgumentParser mockParser;

    private ArgumentProcessor processor;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        processor = new ArgumentProcessor(mockParser);
    }

    // テスト対象のクラス
    public static class ArgumentProcessor {
        private final ArgumentParser parser;

        public ArgumentProcessor(ArgumentParser parser) {
            this.parser = parser;
        }

        public ProcessResult process(String[] args) {
            if (args == null || args.length == 0) {
                throw new IllegalArgumentException("引数が必要です");
            }

            return parser.parse(args);
        }
    }

    // パーサーインターフェース
    public interface ArgumentParser {
        ProcessResult parse(String[] args);
    }

    // 処理結果クラス
    public static class ProcessResult {
        private final boolean success;
        private final String message;

        public ProcessResult(boolean success, String message) {
            this.success = success;
            this.message = message;
        }

        public boolean isSuccess() { return success; }
        public String getMessage() { return message; }
    }

    @Test
    void testValidArguments() {
        // テストデータ
        String[] args = {"--input", "test.txt"};
        ProcessResult expectedResult = 
            new ProcessResult(true, "成功");

        // モックの設定
        when(mockParser.parse(args))
            .thenReturn(expectedResult);

        // テスト実行
        ProcessResult result = processor.process(args);

        // 検証
        assertTrue(result.isSuccess());
        assertEquals("成功", result.getMessage());
        verify(mockParser).parse(args);
    }

    @Test
    void testEmptyArguments() {
        // 空の引数配列でテスト
        assertThrows(IllegalArgumentException.class, 
            () -> processor.process(new String[0]));
    }

    @Test
    void testNullArguments() {
        // null引数でテスト
        assertThrows(IllegalArgumentException.class, 
            () -> processor.process(null));
    }
}

また、ここで紹介したテクニックは、単にコマンドライン引数の処理だけでなく、プログラミング全般における重要な考え方や手法を含んでいます。これらを応用することで、より質の高いソフトウェア開発が実現できるでしょう。

　● 段階的な改善を続ける