为 java bean 设置字段的更好方法

Question

I want to set different field value everytime when I create a bean. But there are a lot of field to set. I can set those by using constructor. But if there is a better approach to do this?

The code just like below, there are five errors, and every time using the bean need to specify different five errors. I am specifing those errors by constructor, this can work. But I know this is not an elegant way.

Can I do this in better way ?

public class WildcardNumberValidator extends BaseValidator<String> {

    private ErrorInfo wildcardCountError;
    private ErrorInfo regionWildcardError;
    private ErrorInfo festivalWildcardError;
    private ErrorInfo backwardWildcardError;
    private ErrorInfo keyWildcardError;
    private ErrorInfo totalWildcardError;

    public WildcardNumberValidator(ErrorInfo wildcardCountError,
                                   ErrorInfo regionWildcardError,
                                   ErrorInfo festivalWildcardError,
                                   ErrorInfo backwardWildcardError,
                                   ErrorInfo keyWildcardError,
                                   ErrorInfo totalWildcardError) {
        this.wildcardCountError = wildcardCountError;
        this.regionWildcardError = regionWildcardError;
        this.festivalWildcardError = festivalWildcardError;
        this.backwardWildcardError = backwardWildcardError;
        this.keyWildcardError = keyWildcardError;
        this.totalWildcardError = totalWildcardError;
    }


    @Override
    public boolean validate(ValidatorContext context, String str) {

        int totalNum = regionNum + festivalNum + keyNum + regionNum;
        if (maxRegionNum != null && regionNum > maxRegionNum) {
            context.addError(regionWildcardError);
            return false;
        }
        if (maxFestivalNum != null && festivalNum > maxFestivalNum) {
            context.addError(festivalWildcardError);
            return false;
        }
        if (maxBackwardNum != null && backwardNum > maxBackwardNum) {
            context.addError(backwardWildcardError);
            return false;
        }
        if (maxKeyNum != null && keyNum > maxKeyNum) {
            context.addError(keyWildcardError);
            return false;
        }
        if (maxTotalNum != null && totalNum > maxTotalNum) {
            context.addError(totalWildcardError);
            return false;
        }
        return true;
    }
}

Answer 1

You can try accepting various ErrorInfo as collection. Let's say Map of errorInfoType and actual ErrorInfo object. errorInfoType can be of Enum type ie Map<ErrorInfoEnum, ErrorInfo> errorInfoMap .

You can modify your code something like below and try:

public class WildcardNumberValidator extends BaseValidator<String> {

    private Map<ErrorInfoEnum, ErrorInfo> errorInfoMap = new HashMap<>();

    public WildcardNumberValidator(Map<ErrorInfoEnum, ErrorInfo> errorInfoMap) {
        this.errorInfoMap = errorInfoMap;
    }


    @Override
    public boolean validate(ValidatorContext context, String str) {

        int totalNum = regionNum + festivalNum + keyNum + regionNum;
        if (maxRegionNum != null && regionNum > maxRegionNum) {
            context.addError(errorInfoMap.get(ErrorInfoEnum.REGION_WILD_CARD_ERROR));
            return false;
        }
        if (maxFestivalNum != null && festivalNum > maxFestivalNum) {
            context.addError(errorInfoMap.get(ErrorInfoEnum.FESTIVAL_WILD_CARD_ERROR));
            return false;
        }
        if (maxBackwardNum != null && backwardNum > maxBackwardNum) {
            context.addError(errorInfoMap.get(ErrorInfoEnum.BACKWARD_WILD_CARD_ERROR));
            return false;
        }
        if (maxKeyNum != null && keyNum > maxKeyNum) {
            context.addError(errorInfoMap.get(ErrorInfoEnum.KEY_WILD_CARD_ERROR));
            return false;
        }
        if (maxTotalNum != null && totalNum > maxTotalNum) {
            context.addError(errorInfoMap.get(ErrorInfoEnum.TOTAL_WILD_CARD_ERROR));
            return false;
        }
        return true;
    }
}

ErrorInfoEnum :

enum ErrorInfoEnum {
    WILD_CARD_COUNT_ERROR,
    REGION_WILD_CARD_ERROR,
    FESTIVAL_WILD_CARD_ERROR,
    BACKWARD_WILD_CARD_ERROR,
    KEY_WILD_CARD_ERROR,
    TOTAL_WILD_CARD_ERROR
}

Answer 2

Better yet, if ErrorInfo instances are immutable, you can make ErrorInfo itself an enum :

public class WildcardNumberValidator extends BaseValidator<String> {
    enum ErrorInfo {
        COUNT_ERROR(1, "count ..."),
        REGION_ERROR(2, "foo"),
        FESTIVAL_ERROR(129, "bar"),
        BACKWARD_ERROR(76, "fred"),
        KEY_ERROR(99, "baz"),
        TOTAL_ERROR(101, "xyzzy");
        
        // whatever your ErrorInfo does
        private int code;
        private String message;

        WildcardErrorInfo(int code, String message) {
            this.code = code;
            this.message = message;
        }
    }


    // default constructor
    public WildcardNumberValidator() {

    }


    @Override
    public boolean validate(ValidatorContext context, String str) {

        int totalNum = regionNum + festivalNum + keyNum + regionNum;
        if (maxRegionNum != null && regionNum > maxRegionNum) {
            context.addError(ErrorInfo.REGION_ERROR);
            return false;
        }
        ...
        return true;
    }
}

Answer 3

You can try to inverse the responsibility, instead of WildcardNumberValidator trying to validate your input, you can make ErrorInfo do that.

public class WildcardNumberValidator extends BaseValidator<String> {

    private List<ErrorInfo> errors;

    public WildcardNumberValidator(List<ErrorInfo> errors) {
        this.errors=errors;
    }


    @Override
    public boolean validate(ValidatorContext context, String str) {

    List<ErrorInfo> faildChecks= errors.stream()
        .filter(error->error.check(str))
        .collect(Collectors.toList());

    if(faildChecks.empty()){
        return true;
    }

    faildChecks.forEach(error->context.addError(error));
    return false;
    }
}

where ErrorInfo will like this:

class ErrorInfo {
    private Predicate<String> predicate; 
    void setPredicate(Predicate<String> predicate){
        this.predicate=predicate;
    }
    boolean check(String input){
        return predicate.test(input);
    }   
}

How to use:

void test(){
    //... do other stuff
    int totalNum = regionNum + festivalNum + keyNum + regionNum;
    ErrorInfo wildcardCountError= // init your ErrorInfo;
    wildcardCountError.setPredicate(input-> maxRegionNum != null && regionNum > maxRegionNum)
    // the same for other ErrorInfo,
    WildcardNumberValidator validator = new WildcardNumberValidator(List.of(wildcardCountError,...other errors);

}

Answer 4

A couple of suggested ways to do this are to use static factory methods or builder pattern.

Factory method can give you freedom to name your methods. Builder can help you build objects in steps. There are other advantages as well. This is one of the first guidelines suggested in the Effective Java book. I will recommended the book highly. Table of Contents

A library you can take a look at is lombok . You can declare a class as data class/ builder , etc and it will save of even writing those boilerplate lines of code.