Refining Uncle Bob’s Clean Code（四）

最新推荐文章于 2026-01-02 07:32:34 发布

转载最新推荐文章于 2026-01-02 07:32:34 发布 · 1k 阅读

文章标签：

#string #integer #null #class #list

编程技巧专栏收录该内容

11 篇文章

订阅专栏

本文详细介绍了Java中参数解析的实现方式，并通过ArgumentPopulator类展示了如何便捷地将当前参数传递给各类ArgumentMarshaler实例。通过具体代码示例，深入探讨了参数类型检查、参数获取与设置等关键步骤。

And another one …

01
import java.util.regex.Pattern;

02
import com.mgi.util.args.ArgsException.ErrorCode;

03
 
04
public class IntegerArgumentMarshaler extends AbstractArgumentMarshaler
 {

05
 
06
    private static final Pattern
 ARGUMENT_ID_PATTERN = Pattern.compile( "[a-z]" );

07
    private static final String
 ARGUMENT_TYPE_POSTFIX = "#";

08
 
09
    private int intValue
 = 0;

10
 
11
    private IntegerArgumentMarshaler(
 String argumentId ){

12
        super(
 argumentId );

13
    }

14
 
15
    protected IntegerArgumentMarshaler(){

16
        this( null );

17
    }

18
 
19
    @Override

20
    public ArgumentMarshaler
 newInstance(String argumentId) {

21
        return new IntegerArgumentMarshaler(
 argumentId );

22
    }

23
 
24
    @Override

25
    public String
 getArgumentTypePostfix() {

26
        return ARGUMENT_TYPE_POSTFIX;

27
    }

28
 
29
    @Override

30
    public Pattern
 getArgumentIdPattern() {

31
        return ARGUMENT_ID_PATTERN;

32
    }

33
 
34
    @Override

35
    public int getNumberOfArgs()
 {

36
        return 1;

37
    }

38
 
39
    public void set(String...
 arguments) throws ArgsException
 {

40
 
41
        if(
 arguments.length == 0 ||
 arguments[0]
 == null ){

42
            throw new ArgsException(
 ErrorCode.MISSING_INTEGER, getArgumentId(), null );

43
        }

44
 
45
        try {

46
            intValue
 = Integer.parseInt(arguments[0]);

47
        }

48
        catch (NumberFormatException
 e) {

49
            throw new ArgsException(
 ErrorCode.INVALID_INTEGER, getArgumentId(), arguments[0]
 );

50
        }

51
    }

52
 
53
    public Object
 get() {

54
      return intValue;

55
    }

56
  }

I think you can see that implementing a new ArgumentMarshaler is not more complicated as before. Just answer some more questions about it’s context – the main part remains quite the same.

Give it to me, Baby …

Now that we know how a single Marshaler works and how we can retrieve them from our Marshalers collection, it’s very easy to pass the current arguments to them. As said before, we just shifted that task into a class of its own – ArgumentPopulator:

01
import java.util.Iterator;

02
import java.util.List;

03
 
04
public class ArgumentPopulator
 {

05
 
06
    private List<String>
 argsList = null;

07
 
08
    public static ArgumentPopulator
 distribute( List<String> argsList ){

09
        return new ArgumentPopulator(
 argsList );

10
    }

11
 
12
    private ArgumentPopulator(
 List<String> argsList ){

13
        this.argsList
 = argsList;

14
    }

15
 
16
    public void to(
 Marshalers marshalers ) throws ArgsException{

17
 
18
        for (
 Iterator<String> arguments = argsList.iterator(); arguments.hasNext(); ) {

19
 
20
            String
 argument = arguments.next();

21
 
22
            if (
 representsArgumentId( argument ) ){

23
 
24
                String
 argumentId = extractArgumentIdFrom( argument );

25
 
26
                if(
 ! marshalers.isMarshalerAvailabeFor( argumentId ) ){

27
                    throw new ArgsException(
 ArgsException.ErrorCode.UNEXPECTED_ARGUMENT, argumentId, null);

28
                }

29
 
30
                ArgumentMarshaler
 marshaler = marshallers.getMarshalerFor( argumentId );                           

31
 
32
                marshaler.set(
 getArgumentsAhead( marshaller.getNumberOfArgs(), arguments ) );

33
            }

34
        }

35
    }

36
 
37
    private String
 extractArgumentIdFrom(String argument) {

38
        return argument.substring( 1,
 argument.length() );

39
    }

40
 
41
    private boolean representsArgumentId(String
 argument) {

42
        return argument.startsWith( "-" );

43
    }

44
 
45
    private String[]
 getArgumentsAhead( int numberOfArgs,
 Iterator<String> arguments ) {

46
          String[] args
 = new String[numberOfArgs];

47
 
48
          for( int i=0;
 i < numberOfArgs; i++ ){

49
              args[i]
 = arguments.hasNext() ? arguments.next() : null;

50
          }

51
          return args;

52
      }

53
}

As you can see, ArgumentPopulator accepts a List of current arguments (by using the provided Factory method distribute()) and tries to push the found arguments to any collection of passed Marshalers (using the to() method).