如何将简易命令解析Maven项目转换为Dropwizard项目？

Hey there! I’ve helped folks convert command-line apps to Dropwizard plenty of times—let’s break this down step by step so you can get your project up and running smoothly.

First, update your pom.xml to include Dropwizard’s core dependencies (use the latest stable version for best compatibility):

<dependencies>
    <dependency>
        <groupId>io.dropwizard</groupId>
        <artifactId>dropwizard-core</artifactId>
        <version>2.1.9</version>
    </dependency>
</dependencies>

Dropwizard expects a standard structure, but your existing code can mostly stay put—you’ll just add a few new classes for configuration and bootstrapping.

Dropwizard relies on configuration files, but you can still keep your familiar command-line flags by binding them to a configuration class. This lets you use either a config file or command-line arguments (or a mix of both) to set values.

Create an AppConfiguration class like this:

import io.dropwizard.Configuration;
import jakarta.validation.constraints.NotEmpty;

public class AppConfiguration extends Configuration {
    @NotEmpty
    private String username;

    @NotEmpty
    private String password;

    @NotEmpty
    private String database;

    @NotEmpty
    private String hostname;

    @NotEmpty
    private String fileOrDirectory;

    private boolean recursive;

    // Use @JsonProperty to match your existing flag names
    @JsonProperty("u")
    public String getUsername() { return username; }

    @JsonProperty("u")
    public void setUsername(String username) { this.username = username; }

    @JsonProperty("p")
    public String getPassword() { return password; }

    @JsonProperty("p")
    public void setPassword(String password) { this.password = password; }

    // Add getters/setters for -d, -h, -f, and -rec following the same pattern
    @JsonProperty("d")
    public String getDatabase() { return database; }
    @JsonProperty("d")
    public void setDatabase(String database) { this.database = database; }

    @JsonProperty("h")
    public String getHostname() { return hostname; }
    @JsonProperty("h")
    public void setHostname(String hostname) { this.hostname = hostname; }

    @JsonProperty("f")
    public String getFileOrDirectory() { return fileOrDirectory; }
    @JsonProperty("f")
    public void setFileOrDirectory(String fileOrDirectory) { this.fileOrDirectory = fileOrDirectory; }

    @JsonProperty("rec")
    public boolean isRecursive() { return recursive; }
    @JsonProperty("rec")
    public void setRecursive(boolean recursive) { this.recursive = recursive; }
}

This is the entry point for your app. It’ll bootstrap Dropwizard and run your existing business logic with the parsed parameters.

import io.dropwizard.Application;
import io.dropwizard.setup.Bootstrap;
import io.dropwizard.setup.Environment;

public class MyApp extends Application<AppConfiguration> {
    public static void main(String[] args) throws Exception {
        new MyApp().run(args);
    }

    @Override
    public void initialize(Bootstrap<AppConfiguration> bootstrap) {
        // Leave this empty for now—we can add custom commands later if needed
    }

    @Override
    public void run(AppConfiguration config, Environment environment) {
        // Initialize your existing file/database processing logic here
        // Pass the parsed config values directly to your service class
        FileProcessingService service = new FileProcessingService(
            config.getUsername(),
            config.getPassword(),
            config.getDatabase(),
            config.getHostname(),
            config.getFileOrDirectory(),
            config.isRecursive()
        );

        // Execute your core logic just like you did before
        service.processFiles();
    }
}

First, create a basic config.yml file (this gives you a fallback for default values):

u: default-user
p: default-pass
d: default-db
h: localhost
f: ./default-path
rec: false

Then run your app using a command almost identical to your original one—just add server config.yml before your flags:

java -jar target/myJar.jar server config.yml -u my-username -p my-password -d my-db -h my-host -f ./my-files -rec

If you don’t want to start a Dropwizard HTTP server (since your original app was command-line only), you can create a custom command to mimic your exact old workflow:

import io.dropwizard.cli.Command;
import io.dropwizard.setup.Bootstrap;
import net.sourceforge.argparse4j.inf.Namespace;
import net.sourceforge.argparse4j.inf.Subparser;

public class ProcessCommand extends Command {
    public ProcessCommand() {
        super("process", "Process files with your familiar command-line flags");
    }

    @Override
    public void configure(Subparser subparser) {
        // Recreate your original flag setup
        subparser.addArgument("-u", "--username").required(true).help("Database username");
        subparser.addArgument("-p", "--password").required(true).help("Database password");
        subparser.addArgument("-d", "--database").required(true).help("Target database");
        subparser.addArgument("-h", "--hostname").required(true).help("Database hostname");
        subparser.addArgument("-f", "--file").required(true).help("File or directory path");
        subparser.addArgument("-rec", "--recursive").action(Boolean.TRUE).help("Process files recursively");
    }

    @Override
    public void run(Bootstrap<?> bootstrap, Namespace namespace) throws Exception {
        // Pull values directly from the command line
        String username = namespace.getString("username");
        String password = namespace.getString("password");
        String database = namespace.getString("database");
        String hostname = namespace.getString("hostname");
        String fileOrDir = namespace.getString("file");
        boolean recursive = namespace.getBoolean("recursive");

        // Run your core logic
        FileProcessingService service = new FileProcessingService(username, password, database, hostname, fileOrDir, recursive);
        service.processFiles();
    }
}

Then register this command in your MyApp’s initialize method:

@Override
public void initialize(Bootstrap<AppConfiguration> bootstrap) {
    bootstrap.addCommand(new ProcessCommand());
}

Now you can run your app exactly like before:

java -jar target/myJar.jar process -u username -p password -d database -h hostname -f file_or_directory -rec

This setup keeps your existing functionality intact while opening the door to Dropwizard’s features like HTTP endpoints, health checks, and metrics whenever you’re ready to expand.

内容的提问来源于stack exchange，提问作者mupierrix