picocli | modern framework for building powerful | Parser library

@Command(name = "help", helpCommand = true)
class Help implements Runnable {
    public static Map<String, String[]> commandGroups;
    static {
        commandGroups = new HashMap<>();
        commandGroups.put("group1", new String[]{
            "function1", "function2", "function3"});
        commandGroups.put("group2", new String[]{
            "function3", "function4", "function5"});
}

@Override
public void run() {
    CommandLine cmd = new CommandLine(new Tool());

    cmd.getHelpSectionMap().remove(SECTION_KEY_COMMAND_LIST_HEADING);
    cmd.getHelpSectionMap().remove(SECTION_KEY_COMMAND_LIST);
    List<String> keys = new ArrayList<>(cmd.getHelpSectionKeys());

    for (String group : commandGroups.keySet()) {
        String headerSection = "SECTION_KEY_" + group + "_HEADING";
        String commandSection = "SECTION_KEY_" + group;
        cmd.getHelpSectionMap().put(headerSection,
                help -> help.createHeading("%n" + group + ":%n"));
        cmd.getHelpSectionMap().put(commandSection,
                new CommandListRenderer(commandGroups.get(group)));
        keys.add(headerSection);
        keys.add(commandSection);
    }

    cmd.setHelpSectionKeys(keys);
    cmd.usage(System.out);

    }
}

class CommandListRenderer implements IHelpSectionRenderer {
    String[] functions;


    public CommandListRenderer(String[] f) {
        functions = f;
    }

    //@Override
    public String render(Help help) {
        CommandSpec spec = help.commandSpec();
        if (spec.subcommands().isEmpty()) { return ""; }

        // prepare layout: two columns
        // the left column overflows, the right column wraps if text is too long
        Help.TextTable textTable = 
        Help.TextTable.forColumns(help.colorScheme(),
            new Help.Column(30, 2, Help.Column.Overflow.SPAN),
            new Help.Column(spec.usageMessage().width() - 30, 2, 
        Help.Column.Overflow.TRUNCATE));

        for (String f : functions) {
            CommandLine subcommand = spec.subcommands().get(f);
            if (subcommand == null) {
                throw new NotFoundException("Function not found: " + f);
            }
            addCommand(subcommand, textTable);
        }
        return textTable.toString();
    }

public void addCommand(CommandLine cmd, Help.TextTable textTable) {
    // create comma-separated list of command name and aliases
    String names = cmd.getCommandSpec().names().toString();
    names = names.substring(1, names.length() - 1); // remove leading '[' and trailing ']'

    // command description is taken from header or description
    String description = description(cmd.getCommandSpec().usageMessage());

    // add a line for this command to the layout
    textTable.addRowValues(names, description);
}

private String description(Model.UsageMessageSpec usageMessage) {
    if (usageMessage.header().length > 0) {
        return usageMessage.header()[0];
    }
    if (usageMessage.description().length > 0) {
        return usageMessage.description()[0];
    }
    return "";
}

task createExe(type: Launch4jLibraryTask) {
    jarTask = shadowJar
    dontWrapJar true // <<<< THIS IS THE ADDED LINE
    icon = "${projectDir}/src/main/installer/nsis/Icon.ico"
    outfile = "${appName}.exe"
    copyConfigurable = files {}
    stayAlive = 'true'
    bundledJrePath = 'jre'
    bundledJre64Bit = true
    jvmOptions = [
            '-Xmx1024m',
            '-Dsun.java2d.d3d=false'
    ]
    fileDescription = appName + ' Application'
    productName = appName
    internalName = appName
    copyright = 'My Company'
    companyName = 'My Company'
}

@Command
public class CMD implements Runnable {

    @Parameters
    private String x;
    
    @ArgGroup(exclusive = false)
    private Group group = new Group();

    static class Group {
        @Option(names = "-a", required = true, defaultValue = "aa")
        public static String a = "aa";

        @Option(names = "-b", required = true, defaultValue = "bb")
        public static String b = "bb";

        @Option(names = "-c", required = false, defaultValue = "cc")
        public static String c = "cc";
    }

@Command
static class CMD implements Runnable {

    @Parameters
    private String x;

    @ArgGroup(exclusive = false)
    private Group group = new Group();

    static class Group {
        @ArgGroup(exclusive = false)
        private InnerGroup inner = new InnerGroup("aa", "bb"); // default values

        @Option(names = "-c", required = false, defaultValue = "cc")
        public String c = "cc";
    }

    static class InnerGroup {
        // default constructor, used by picocli when
        // one or more options in this group are 
        // matched on the command line
        public InnerGroup() {}

        // this constructor assigns default values,
        // used only when *both* options are missing
        public InnerGroup(String a, String b) {
            this.a = a;
            this.b = b;
        }

        @Option(names = "-a", required = true)
        public String a;

        @Option(names = "-b", required = true)
        public String b;
    }

    @Override
    public void run() {
        System.out.printf("a=%s, b=%s, c=%s, x=%s%n", 
                group.inner.a, group.inner.b, group.c, x);
    }
}

@Command
public class CMD implements Runnable {

    @Parameters
    private String x;
    
    @ArgGroup(exclusive = false)
    private Group group = new Group();

    static class Group {
        @Option(names = "-a", required = true, defaultValue = "aa")
        public static String a = "aa";

        @Option(names = "-b", required = true, defaultValue = "bb")
        public static String b = "bb";

        @Option(names = "-c", required = false, defaultValue = "cc")
        public static String c = "cc";
    }

@Command
static class CMD implements Runnable {

    @Parameters
    private String x;

    @ArgGroup(exclusive = false)
    private Group group = new Group();

    static class Group {
        @ArgGroup(exclusive = false)
        private InnerGroup inner = new InnerGroup("aa", "bb"); // default values

        @Option(names = "-c", required = false, defaultValue = "cc")
        public String c = "cc";
    }

    static class InnerGroup {
        // default constructor, used by picocli when
        // one or more options in this group are 
        // matched on the command line
        public InnerGroup() {}

        // this constructor assigns default values,
        // used only when *both* options are missing
        public InnerGroup(String a, String b) {
            this.a = a;
            this.b = b;
        }

        @Option(names = "-a", required = true)
        public String a;

        @Option(names = "-b", required = true)
        public String b;
    }

    @Override
    public void run() {
        System.out.printf("a=%s, b=%s, c=%s, x=%s%n", 
                group.inner.a, group.inner.b, group.c, x);
    }
}

import picocli.CommandLine.PropertiesDefaultProvider;

@Command(name = "myapp", defaultValueProvider = PropertiesDefaultProvider.class)
class MyApp { }

class MyApp { 
    @Option(names = "-D")
    void setSystemProperty(Map<String, String> properties) {
        System.getProperties().putAll(properties);
    }
}

myapp --sourceDatabaseType=MySQL -Dpicocli.defaults.myapp.path=.\myapp.options

myapp --sourceDatabaseType=MySQL -@.\myapp.options

class MyApp { 
    @Spec CommandSpec spec; // injected by picocli

    @Option(names = "-@")
    void setDefaultProviderPath(File path) {
        // you could do some validation here:
        if (!path.canRead()) {
            String msg = String.format("ERROR: file not found: %s", path);
            throw new ParameterException(spec.commandLine(), msg);
        }
        // only set the system property if the file exists
        System.setProperty("picocli.defaults.myapp.path", path.toString());
    }
}

import picocli.CommandLine.PropertiesDefaultProvider;

@Command(name = "myapp", defaultValueProvider = PropertiesDefaultProvider.class)
class MyApp { }

class MyApp { 
    @Option(names = "-D")
    void setSystemProperty(Map<String, String> properties) {
        System.getProperties().putAll(properties);
    }
}

myapp --sourceDatabaseType=MySQL -Dpicocli.defaults.myapp.path=.\myapp.options

myapp --sourceDatabaseType=MySQL -@.\myapp.options

class MyApp { 
    @Spec CommandSpec spec; // injected by picocli

    @Option(names = "-@")
    void setDefaultProviderPath(File path) {
        // you could do some validation here:
        if (!path.canRead()) {
            String msg = String.format("ERROR: file not found: %s", path);
            throw new ParameterException(spec.commandLine(), msg);
        }
        // only set the system property if the file exists
        System.setProperty("picocli.defaults.myapp.path", path.toString());
    }
}

import picocli.CommandLine.PropertiesDefaultProvider;

@Command(name = "myapp", defaultValueProvider = PropertiesDefaultProvider.class)
class MyApp { }

class MyApp { 
    @Option(names = "-D")
    void setSystemProperty(Map<String, String> properties) {
        System.getProperties().putAll(properties);
    }
}

myapp --sourceDatabaseType=MySQL -Dpicocli.defaults.myapp.path=.\myapp.options

myapp --sourceDatabaseType=MySQL -@.\myapp.options

class MyApp { 
    @Spec CommandSpec spec; // injected by picocli

    @Option(names = "-@")
    void setDefaultProviderPath(File path) {
        // you could do some validation here:
        if (!path.canRead()) {
            String msg = String.format("ERROR: file not found: %s", path);
            throw new ParameterException(spec.commandLine(), msg);
        }
        // only set the system property if the file exists
        System.setProperty("picocli.defaults.myapp.path", path.toString());
    }
}

import picocli.CommandLine.PropertiesDefaultProvider;

@Command(name = "myapp", defaultValueProvider = PropertiesDefaultProvider.class)
class MyApp { }

class MyApp { 
    @Option(names = "-D")
    void setSystemProperty(Map<String, String> properties) {
        System.getProperties().putAll(properties);
    }
}

myapp --sourceDatabaseType=MySQL -Dpicocli.defaults.myapp.path=.\myapp.options

myapp --sourceDatabaseType=MySQL -@.\myapp.options

class MyApp { 
    @Spec CommandSpec spec; // injected by picocli

    @Option(names = "-@")
    void setDefaultProviderPath(File path) {
        // you could do some validation here:
        if (!path.canRead()) {
            String msg = String.format("ERROR: file not found: %s", path);
            throw new ParameterException(spec.commandLine(), msg);
        }
        // only set the system property if the file exists
        System.setProperty("picocli.defaults.myapp.path", path.toString());
    }
}

import picocli.CommandLine.PropertiesDefaultProvider;

@Command(name = "myapp", defaultValueProvider = PropertiesDefaultProvider.class)
class MyApp { }

class MyApp { 
    @Option(names = "-D")
    void setSystemProperty(Map<String, String> properties) {
        System.getProperties().putAll(properties);
    }
}

myapp --sourceDatabaseType=MySQL -Dpicocli.defaults.myapp.path=.\myapp.options

myapp --sourceDatabaseType=MySQL -@.\myapp.options

class MyApp { 
    @Spec CommandSpec spec; // injected by picocli

    @Option(names = "-@")
    void setDefaultProviderPath(File path) {
        // you could do some validation here:
        if (!path.canRead()) {
            String msg = String.format("ERROR: file not found: %s", path);
            throw new ParameterException(spec.commandLine(), msg);
        }
        // only set the system property if the file exists
        System.setProperty("picocli.defaults.myapp.path", path.toString());
    }
}

@Command(subcommands = {Sub1.class, Sub2.class, Sub3.class})
class MyApp implements Runnable {

    Channel channel; // initialized in executionStrategy method

    // A reference to this method can be used as a custom execution strategy
    // that first calls the init() method,
    // and then delegates to the default execution strategy.
    private int executionStrategy(ParseResult parseResult) {

        // custom initialization to be done before executing any command or subcommand
        try (this.channel = _establishChannel(generalConfiguration)) {

            // default execution strategy
            return new CommandLine.RunLast().execute(parseResult); 
        }
    }

    public static void main(String[] args) {
        MyApp app = new MyApp();
        new CommandLine(app)
                // wire in the custom execution strategy
                .setExecutionStrategy(app::executionStrategy) // Java 8 method reference syntax
                .execute(args);
    }

    // ...
}

@Command(name = "country", description = "Resolve ISO country code (ISO-3166-1, Alpha-2 code)")
static class Subcommand1 implements Runnable {

    @ParentCommand
    private MyApp parent; // picocli injects reference to parent command

    @Parameters(arity = "1..*", paramLabel = "<country code>", description = "country code(s) to be resolved")
    private String[] countryCodes;

    @Override
    public void run() {
        Channel channel = parent.channel;
        doSomethingWith(channel);
        // ...
    }
}

@Command(subcommands = {Sub1.class, Sub2.class, Sub3.class})
class MyApp implements Runnable {

    Channel channel; // initialized in executionStrategy method

    // A reference to this method can be used as a custom execution strategy
    // that first calls the init() method,
    // and then delegates to the default execution strategy.
    private int executionStrategy(ParseResult parseResult) {

        // custom initialization to be done before executing any command or subcommand
        try (this.channel = _establishChannel(generalConfiguration)) {

            // default execution strategy
            return new CommandLine.RunLast().execute(parseResult); 
        }
    }

    public static void main(String[] args) {
        MyApp app = new MyApp();
        new CommandLine(app)
                // wire in the custom execution strategy
                .setExecutionStrategy(app::executionStrategy) // Java 8 method reference syntax
                .execute(args);
    }

    // ...
}

@Command(name = "country", description = "Resolve ISO country code (ISO-3166-1, Alpha-2 code)")
static class Subcommand1 implements Runnable {

    @ParentCommand
    private MyApp parent; // picocli injects reference to parent command

    @Parameters(arity = "1..*", paramLabel = "<country code>", description = "country code(s) to be resolved")
    private String[] countryCodes;

    @Override
    public void run() {
        Channel channel = parent.channel;
        doSomethingWith(channel);
        // ...
    }
}

FROM registry.access.redhat.com/ubi8/ubi-minimal:8.3

ARG JAVA_PACKAGE=java-11-openjdk-headless
ARG RUN_JAVA_VERSION=1.3.8
ENV LANG='en_US.UTF-8' LANGUAGE='en_US:en'
# Install java and the run-java script
# Also set up permissions for user `1001`
RUN microdnf install curl ca-certificates ${JAVA_PACKAGE} \
    && microdnf update \
    && microdnf clean all \
    && mkdir /deployments \
    && chown 1001 /deployments \
    && chmod "g+rwX" /deployments \
    && chown 1001:root /deployments \
    && curl https://repo1.maven.org/maven2/io/fabric8/run-java-sh/${RUN_JAVA_VERSION}/run-java-sh-${RUN_JAVA_VERSION}-sh.sh -o /deployments/run-java.sh \
    && chown 1001 /deployments/run-java.sh \
    && chmod 540 /deployments/run-java.sh \
    && echo "securerandom.source=file:/dev/urandom" >> /etc/alternatives/jre/lib/security/java.security

# Configure the JAVA_OPTIONS, you can add -XshowSettings:vm to also display the heap size.
ENV JAVA_OPTIONS="-Dquarkus.http.host=0.0.0.0 -Djava.util.logging.manager=org.jboss.logmanager.LogManager"
# We make four distinct layers so if there are application changes the library layers can be re-used
COPY --chown=1001 target/quarkus-app/lib/ /deployments/lib/
COPY --chown=1001 target/quarkus-app/*.jar /deployments/
COPY --chown=1001 target/quarkus-app/app/ /deployments/app/
COPY --chown=1001 target/quarkus-app/quarkus/ /deployments/quarkus/

EXPOSE 8080
USER 1001

# [== BEFORE ==]
# ENTRYPOINT [ "/deployments/run-java.sh" ]
# [== AFTER ==]
ENTRYPOINT "/deployments/run-java.sh" $CLI_ARGUMENTS

class getArrayElements extends SourceSentences {

    public static void main(String[] args) throws ParserConfigurationException, IOException, SAXException {
        SourceSentences.translate();
        System.out.println(SourceSentences.sourceArray);
    }
}

public interface DBInitializer {
    public void startDbConnection();
    public void closeDbConnection();
}

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class MySQLInitializer implements DBInitializer {
    private EntityManagerFactory emf;
    private EntityManager entityManager;
    private final Logger logger = LogManager.getLogger(MySQLInitializer.class);

    @Override
    public void startDbConnection() {
        try {
            emf = Persistence.createEntityManagerFactory("name");
            entityManager = emf.createEntityManager();
            // other stuff
        } catch (Exception e) {
            logger.log(Level.ERROR, "MySQL Exception", e);
        }
    }
    
    @Override
    public void closeDbConnection() {
        if (emf != null) {
            entityManager.close();
            emf.close();
        }
    }
}

import com.mongodb.MongoClient;
import com.mongodb.ServerAddress;

public class MongoInitializer implements DBInitializer {
    
    private MongoClient client;
    private final Logger logger = LogManager.getLogger(MongoInitializer.class);
    
    @Override
    public void startDbConnection() {
        try {
            client = new MongoClient(new ServerAddress("localhost", 27017));
            // other stuff
        } catch (Exception e) {
            logger.log(Level.ERROR, "Mongo Exception", e);
        }
    }

    @Override
    public void closeDbConnection() {
        client.close();
    }
}

import java.awt.EventQueue;
import java.util.concurrent.Callable;

import DBInitializer;
import MongoInitializer;
import MySQLInitializer;
import View;

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

@Command(mixinStandardHelpOptions = true)
public class App implements Callable<Void> {

    private static final Logger LOGGER = LogManager.getLogger(App.class);

    @Option(names = { "--database" }, description = "Either 'mongo' or 'mysql'")
    private String databaseType = "mysql";

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

    DBInitializer dBInitializer;

    @Override
    public Void call() throws Exception {
        EventQueue.invokeLater(() -> {
            try {
                switch (databaseType) {
                case "mysql":
                    dBInitializer = new MySQLInitializer();
                    break;
                case "mongo":
                    dBInitializer = new MongoInitializer();
                    break;
                default:
                    LOGGER.log(Level.ERROR, "--database must be either 'mysql' or 'mongo'");
                    System.exit(1);
                }
                dBInitializer.startDbConnection();
                // other stuff
                View view = new View();
                view.setVisible(true);
                
            } catch (Exception e) {
                LOGGER.log(Level.ERROR, "Exception", e);
            }
        });

        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                dBInitializer.closeDbConnection();
            }
        });
        return null;
    }
}

public interface DBInitializer {
    public void startDbConnection();
    public void closeDbConnection();
}

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class MySQLInitializer implements DBInitializer {
    private EntityManagerFactory emf;
    private EntityManager entityManager;
    private final Logger logger = LogManager.getLogger(MySQLInitializer.class);

    @Override
    public void startDbConnection() {
        try {
            emf = Persistence.createEntityManagerFactory("name");
            entityManager = emf.createEntityManager();
            // other stuff
        } catch (Exception e) {
            logger.log(Level.ERROR, "MySQL Exception", e);
        }
    }
    
    @Override
    public void closeDbConnection() {
        if (emf != null) {
            entityManager.close();
            emf.close();
        }
    }
}

import com.mongodb.MongoClient;
import com.mongodb.ServerAddress;

public class MongoInitializer implements DBInitializer {
    
    private MongoClient client;
    private final Logger logger = LogManager.getLogger(MongoInitializer.class);
    
    @Override
    public void startDbConnection() {
        try {
            client = new MongoClient(new ServerAddress("localhost", 27017));
            // other stuff
        } catch (Exception e) {
            logger.log(Level.ERROR, "Mongo Exception", e);
        }
    }

    @Override
    public void closeDbConnection() {
        client.close();
    }
}

import java.awt.EventQueue;
import java.util.concurrent.Callable;

import DBInitializer;
import MongoInitializer;
import MySQLInitializer;
import View;

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

@Command(mixinStandardHelpOptions = true)
public class App implements Callable<Void> {

    private static final Logger LOGGER = LogManager.getLogger(App.class);

    @Option(names = { "--database" }, description = "Either 'mongo' or 'mysql'")
    private String databaseType = "mysql";

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

    DBInitializer dBInitializer;

    @Override
    public Void call() throws Exception {
        EventQueue.invokeLater(() -> {
            try {
                switch (databaseType) {
                case "mysql":
                    dBInitializer = new MySQLInitializer();
                    break;
                case "mongo":
                    dBInitializer = new MongoInitializer();
                    break;
                default:
                    LOGGER.log(Level.ERROR, "--database must be either 'mysql' or 'mongo'");
                    System.exit(1);
                }
                dBInitializer.startDbConnection();
                // other stuff
                View view = new View();
                view.setVisible(true);
                
            } catch (Exception e) {
                LOGGER.log(Level.ERROR, "Exception", e);
            }
        });

        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                dBInitializer.closeDbConnection();
            }
        });
        return null;
    }
}

public interface DBInitializer {
    public void startDbConnection();
    public void closeDbConnection();
}

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class MySQLInitializer implements DBInitializer {
    private EntityManagerFactory emf;
    private EntityManager entityManager;
    private final Logger logger = LogManager.getLogger(MySQLInitializer.class);

    @Override
    public void startDbConnection() {
        try {
            emf = Persistence.createEntityManagerFactory("name");
            entityManager = emf.createEntityManager();
            // other stuff
        } catch (Exception e) {
            logger.log(Level.ERROR, "MySQL Exception", e);
        }
    }
    
    @Override
    public void closeDbConnection() {
        if (emf != null) {
            entityManager.close();
            emf.close();
        }
    }
}

import com.mongodb.MongoClient;
import com.mongodb.ServerAddress;

public class MongoInitializer implements DBInitializer {
    
    private MongoClient client;
    private final Logger logger = LogManager.getLogger(MongoInitializer.class);
    
    @Override
    public void startDbConnection() {
        try {
            client = new MongoClient(new ServerAddress("localhost", 27017));
            // other stuff
        } catch (Exception e) {
            logger.log(Level.ERROR, "Mongo Exception", e);
        }
    }

    @Override
    public void closeDbConnection() {
        client.close();
    }
}

import java.awt.EventQueue;
import java.util.concurrent.Callable;

import DBInitializer;
import MongoInitializer;
import MySQLInitializer;
import View;

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

@Command(mixinStandardHelpOptions = true)
public class App implements Callable<Void> {

    private static final Logger LOGGER = LogManager.getLogger(App.class);

    @Option(names = { "--database" }, description = "Either 'mongo' or 'mysql'")
    private String databaseType = "mysql";

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

    DBInitializer dBInitializer;

    @Override
    public Void call() throws Exception {
        EventQueue.invokeLater(() -> {
            try {
                switch (databaseType) {
                case "mysql":
                    dBInitializer = new MySQLInitializer();
                    break;
                case "mongo":
                    dBInitializer = new MongoInitializer();
                    break;
                default:
                    LOGGER.log(Level.ERROR, "--database must be either 'mysql' or 'mongo'");
                    System.exit(1);
                }
                dBInitializer.startDbConnection();
                // other stuff
                View view = new View();
                view.setVisible(true);
                
            } catch (Exception e) {
                LOGGER.log(Level.ERROR, "Exception", e);
            }
        });

        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                dBInitializer.closeDbConnection();
            }
        });
        return null;
    }
}

public interface DBInitializer {
    public void startDbConnection();
    public void closeDbConnection();
}

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class MySQLInitializer implements DBInitializer {
    private EntityManagerFactory emf;
    private EntityManager entityManager;
    private final Logger logger = LogManager.getLogger(MySQLInitializer.class);

    @Override
    public void startDbConnection() {
        try {
            emf = Persistence.createEntityManagerFactory("name");
            entityManager = emf.createEntityManager();
            // other stuff
        } catch (Exception e) {
            logger.log(Level.ERROR, "MySQL Exception", e);
        }
    }
    
    @Override
    public void closeDbConnection() {
        if (emf != null) {
            entityManager.close();
            emf.close();
        }
    }
}

import com.mongodb.MongoClient;
import com.mongodb.ServerAddress;

public class MongoInitializer implements DBInitializer {
    
    private MongoClient client;
    private final Logger logger = LogManager.getLogger(MongoInitializer.class);
    
    @Override
    public void startDbConnection() {
        try {
            client = new MongoClient(new ServerAddress("localhost", 27017));
            // other stuff
        } catch (Exception e) {
            logger.log(Level.ERROR, "Mongo Exception", e);
        }
    }

    @Override
    public void closeDbConnection() {
        client.close();
    }
}

import java.awt.EventQueue;
import java.util.concurrent.Callable;

import DBInitializer;
import MongoInitializer;
import MySQLInitializer;
import View;

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

@Command(mixinStandardHelpOptions = true)
public class App implements Callable<Void> {

    private static final Logger LOGGER = LogManager.getLogger(App.class);

    @Option(names = { "--database" }, description = "Either 'mongo' or 'mysql'")
    private String databaseType = "mysql";

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

    DBInitializer dBInitializer;

    @Override
    public Void call() throws Exception {
        EventQueue.invokeLater(() -> {
            try {
                switch (databaseType) {
                case "mysql":
                    dBInitializer = new MySQLInitializer();
                    break;
                case "mongo":
                    dBInitializer = new MongoInitializer();
                    break;
                default:
                    LOGGER.log(Level.ERROR, "--database must be either 'mysql' or 'mongo'");
                    System.exit(1);
                }
                dBInitializer.startDbConnection();
                // other stuff
                View view = new View();
                view.setVisible(true);
                
            } catch (Exception e) {
                LOGGER.log(Level.ERROR, "Exception", e);
            }
        });

        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                dBInitializer.closeDbConnection();
            }
        });
        return null;
    }
}

-Dgroovy.attach.runtime.groovydoc=true

public class HeaderConverter implements CommandLine.ITypeConverter<List<Header>> {

    @Override
    public List<Header> convert(String s) throws Exception {
        List<Header> headers = new ArrayList<>();
        var params = s.split(",");
        Arrays.stream(params).forEach(x -> headers.add(Header.valueOf(x.trim())));
        return headers;
    }
}