Returning the same rule instance

Because validation is dynamic, in other words, the validation code is executed per each request, you should avoid creating new rule objects inside your validation code. Check the code below:

The code above is perfectly correct and legal, but we are creating too many new objects on each request without a real need for it. A rule is thread-safe by design and you should re-use the same instance across different requests. A possible fix for this problem is illustrated in the code below:

public class MyAction implements Validatable {

private static final Rule requiredRule = new RequiredRule();
    private static final Rule stringRule1 = new StringRule(6, 30);
    private static final Rule integerRule1 = new IntegerRule(18, 50);
    private static final Rule stringRule2 = new StringRule(4, 20);
    private static final Rule equalRule1 = new EqualRule("password", "passconf");
    
    public String execute() {
        
        // your action stuff here...
        
    }
    
    public void prepareValidator(Validator val, String innerAction) {
        
            val.add("username", requiredRule, "required_error");
            val.add("username", stringRule1, "invalid_username");
        
            val.add("age", requiredRule, "required_error");
            val.add("age", integerRule1, "invalid_age");
        
            val.add("password", requiredRule, "required_error");
            val.add("password", stringRule2, "invalid_password_length");
            val.add("password", equalRule1, "password_does_not_match");
        
            val.add("passconf", requiredRule, "required_error");
            
    }
}

However note that it is not very easy to read the validation code when the rules are defined outside the prepareValidator() method. A better approach is to make the rule constructor private and create a static getInstance() method that will return instances of the rule and it will be smart enough to return the same instance when the same object is requested. Check below how we would accomplish this with the NegativeRule introduced in the previous chapter.

import java.util.HashMap;
import java.util.Map;

public class NegativeRule extends BasicRule {
    
    private final int min;
    private final Map<String, String> tokens = new HashMap<String, String>();
    
    private static final Map<Integer, Rule> cache = new HashMap<Integer, Rule>();
    private static final Rule RULE = new NegativeRule();
	
	private NegativeRule() { 
        this.min = Integer.MIN_VALUE;
        this.tokens.put("min", String.valueOf(min));
    }
    
    private NegativeRule(int min) {
        this.min = min;
        this.tokens.put("min", String.valueOf(min));
    }
    
    public static Rule getInstance() {
        return RULE;
    }
    
    public synchronized static Rule getInstance(int min) {
        Rule rule = cache.get(min);
        
        if (rule == null) {
            rule = new NegativeRule(min);
            cache.put(min, rule);
        }
        
        return rule;
    }
	
	public boolean check(String value) {
		
		try {
			
			int x = Integer.parseInt(value);
            
            return x < 0 && x >= min;
			
		} catch(Exception e) {
			
			return false;
		}
	}
    
	public Map<String, String> getTokens() {
		return tokens;
	}
}

Check how we are using a cache to return the same instance for each "min" parameter passed to the getInstance() method. This will avoid creating unnecessary duplicates of the same object.

Most of the provided rules inside the org.mentawai.rule package implement the getInstance() method. So when using them you should make use of this method to obtain instances of the rule. Check the example below:

When coding your own rules, you should provide a getInstance() method whenever possible. But this is not really a necessity. It is just a good practice that it is worth mentioning for the competent programmer.