args4j-Option Syntax

Java-Forum Java-Grundlagen
1

Hallo,
ich versuche gerade eine Anwendung mit Kommandozeilen-Argument zu schreiben. Dafür muss ich args4j verwenden.

Die Argumenteneingabe ist wie folgend aufgebaut ‘-Argument:ID’.

Habe es wie folgt probiert:

public class ArgumentOptions {
    
public enum Param{Argumente,...};
       
@Option(name="-Argument",usage="...")
    public void setServer(){
        this.param=Param.Argument;
    }
...
@Option(name="-Argument",metaVar = "<id>",usage="....")
    private void setCustomerIDCreate(String id){
        this.CustomerID=id;
    }

Nichts von dem hat funktioniert. Sieht jemand meinen Verständnisfehler?

2

warum MUSST du denn unbedingt args4j nutzen ? reicht es denn nicht ganz normal das String-array von main() zu parsen ?

3

wie kommt es zu den ** im Quellcode? habe ich sonst noch nirgendwo gesehen, ist für Java-Code wohl nicht üblich,
edit: ok, von Moderator

der Code dürfe auch sonst mit
public enum Param{Argumente,...};
nicht vollständig sein

schließlich, soweit ich args4j noch nie gehört habe, wage ich noch einen fachlichen Punkt:
bist du dir mit @Option an set-Methoden sicher?
soweit ich bisher wenige Beispiele überhaupt im gesamten Universum gefunden habe, noch weniger mit Enum, sehen die alle anders aus
https://searchcode.com/codesearch/view/20768928/

das @Option kommt an ein Attribut, keine set-Methode?
ist natürlich oft beides interessant, vielleicht geht das, aber im Zweifel erstmal nach Tutorials?

funktioniert eigentlich schon anderes, simpler String statt Enum?
gibt es Fehlermeldungen? ( -> schon wieder so ein Punkt der gleich in das erste Posting gehört…)

4

Sorry, das war ich. Habe Java-Tags reingesetzt und habe dabei das bestehende Markup übersehen. Ist jetzt hoffentlich richtig…

5

Ich würde dir ja gerne helfen, aber dein Ausschnitt enthält leider nicht alle relevanten Dinge. Evtl. schreibst du mal einen kompletten beispielhaften Aufruf deines Programmes und welche Variable anschließend welchen Wert haben soll.

Ggf. hilft dir auch schon folgendes Kleines Beispiel:


import org.kohsuke.args4j.CmdLineException;
import org.kohsuke.args4j.CmdLineParser;
import org.kohsuke.args4j.Option;

public class ByteWelt12566 {

    public static class ArgumentOptions {
        public static enum Param {
            Foo, Bar
        }
        
        @Option(name = "-Argument:Param")
        public Param param;
        
        @Option(name = "-Argument:ID")
        public Integer customerId;
    }
    
    public static void main(String[] args) throws CmdLineException {
        System.out.println(Arrays.toString(args));
        final ArgumentOptions options = new ArgumentOptions();
        new CmdLineParser(options).parseArgument(args);
        System.out.println("options.param=" + options.param);
        System.out.println("options.customerId=" + options.customerId);
    }
    
}```
6

Probiere es mal so (Skizze/Schema/Pseudo…):

  Pattern p = Pattern.compile("^-?(richtiger):(Ausdruck\\Regex)$");
 ArrayList aloa = new ArrayList(args.length);
  for(String s : args) {
    Matcher m = p.matcher(s);
    if (m.find()) {
      aloa.add...
    } else {
      sout("Not m.find() :-( : " + m.group(0));
    }
  }
  // do what with mea, aloa
} // EOF of main```
7

Hat er die diamonds raus genommen? Dort sollte eigentlich stehen:

ArrayList{Object[]} aloa = new ArrayList{}(args.length);

{ sind spitze Klammern

und:
aloa.add new Objekt[]{ parse m.group(1) , m.group(2) }

8

So, bitte, hier noch-mal:

 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package pkg23args;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author CB
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String... args) {
        // TODO code application logic here
        int len = 16;
        while (len < 2 * args.length) {
            len <<= 1;
        }
        Pattern p = Pattern.compile("^-?(\\d+):(.+)$");
        List<Object[]> aloa = new ArrayList<Object[]>(len);
        for (String string : args) {
            Matcher m = p.matcher(string);
            if (m.find()) {
                aloa.add(new Object[]{Integer.parseInt(m.group(1)), m.group(2)});
            } else {
                System.out.println("Not m.find() : " + string);
            }
        }
        Random r = new Random();
        while (!aloa.isEmpty()) {
            Object[] oa = aloa.remove(r.nextInt(aloa.size()));
            if (r.nextBoolean()) {
                System.out.println(Arrays.toString(oa));
            } else {
                System.out.println(new StringBuilder(Arrays.toString(oa)).reverse().toString());
            }
        }
    }
}```

(Umgang mit Strings/Zeichenketten)

Zeile 24 bis 27 und 38 bis 46 nicht wichtig. In 33 könnte eine NFE auftreten, wenn string/lin zu lang ist.

Grüße