Designing validation classes

Question

This is a follow-up of this question. I decided to implement what the accepted answer suggests, however, I realized I also needed individual public methods for each member the entity to be validated has, so it is not only validated as a whole, but also its members as separate units:

This is what was suggested:

public interface Validable {
 public void setValidator(Validator validator);
 public void validate() throws ValidationException;
 public List<String> getMessages();
}
public interface Validator<T> {
 public boolean validate(T e);
 public List<String> getValidationMessages();
}
public class EventValidator implements Validator<Event> {
 public boolean validate(Event e) {
 // validate each member here, as well as the entity as a whole
 return isValid;
 }
 // etc...
}

But now I need public methods for each member of the Event. The reason is to use each of these methods in the Event setters and methods with a similar purpose, like adding items to a list or a dictionary, initializing data, modifying data, etc.

So I would need something like:

public class EventValidator implements Validator<Event> {
 // Validates the whole object
 public boolean validate(Event e) {
 // ...
 }
 public boolean validatePlayers() {
 // ...
 }
 public boolean validateCourts() {
 // ...
 }
 public boolean validateMatches() {
 // ...
 }
}

This first thing I can see I need is to turn that Event e parameter in the "main" validate(Event e) method into a member variable so the rest of the methods can access them. But this violates the whole point of this design, which was decoupling the entity from the validator.

What would be the most fitting design to cover my needs? I wouldn't care if I had to start from scratch and totally forget about the current design.

• Ixrec: What's stopping you from passing e to the other validateStuff() methods?
• Laiv: Why you don't parametrize with Event all the other methods? Then all of them can be invoked from controller or from main validate method. I guess main validate method results is the sum off all others alltogether. Is'n it?
• Laiv: Ok I see why you don't stack validation calls. But interface doesn't need to have 1 method per validation. Only its implementation has them all. Anyways if you are thinking in to have a single class with all the validations possibles, the coupling is going to be hard to avoid
• Robert Harvey: Given your choice of method names (validateCourts, validateMatches, etc.), it seems as if your individual objects should be validating themselves. What prevents you from saying something like public class Player implements Validator<Event>?
• Robert Harvey: Isn't that why you're passing an Event context?

Answer 1

I think it might help to realize that Validable and Validator are interfaces that relate to the validation of a single entity, and that you are now trying to force the validation of a composite of entities into this design. Your Validator should only validate the event, do not try to use it to validate the rules for creating the event. Make a distinction between the event and the rules for creating the event.

Once you gain this insight you have many options going forward.

It seems you are modeling a tennis match. In that case, an event should probably be created by some kind of match-maker. (It might suit you to use the builder pattern?) What you are actually wanting to validate is not the event, but the steps in the process of building an event. The design you have will do a really great job at validating individual entities, but now you need to validate the rules for composing those entities into an event.

Answer 2

This is an alternative design where multiple "step" validations can be called separatelly:

==> IValidable.java <==

import java.util.List;
public interface IValidable {
 public void setValidator(IValidator<Event> validator_);
 public void validate(String stepTag) throws ValidationException, UnknownStepTagException;
 public String getLastValidationMessage();
}

==> IValidator.java <==

import java.util.List;
public interface IValidator<T> {
 public boolean validate(T e, String stepTag) throws UnknownStepTagException;
 public String getLastValidationMessage();
 public String getLastStepTag();
}

==> Event.java <==

import java.util.List;
public class Event implements IValidable {
 public static final String VALIDABLE_STEP_PLAYERS="PLAYERS";
 public static final String VALIDABLE_STEP_COURTS="COURTS";
 public static final String VALIDABLE_STEP_MATCHES="MATCHES";
 private IValidator<Event> validator;
 private String lastValidationMessage;
 @Override
 public void setValidator(IValidator<Event> validator_) {
 this.validator = validator_;
 }
 @Override
 public void validate(String stepTag) throws ValidationException, UnknownStepTagException {
 if (!this.validator.validate(this,stepTag)){
 throw new ValidationException("WTF!");
 }
 }
 @Override
 public String getLastValidationMessage() {
 return this.lastValidationMessage;
 }
}

==> SimpleEventValidator.java <==

public class SimpleEventValidator implements IValidator<Event> {
 private String lastValidationMessage ="";
 private String lastStepTag="";
 @Override
 public boolean validate(Event e, String stepTag) throws UnknownStepTagException {
 // based on the stepTag executed appropiate privateMethod
 // this example always returns false 
 this.lastStepTag=stepTag;
 return false;
 }
 @Override
 public String getLastValidationMessage() {
 return this.lastValidationMessage;
 }
 @Override
 public String getLastStepTag() {
 return this.lastStepTag;
 }
 private boolean validateThis(){
 return false;
 }
 private boolean validateThat(){
 return false;
 } 
}

==> UnknownStepTagException.java <==

public class UnknownStepTagException extends Exception {
}

==> ValidationException.java <==

public class ValidationException extends Exception {
 public ValidationException(String message) {
 super(message);
 }
 private static final long serialVersionUID = 1L;
}

==> Test.java <==

import java.util.ArrayList;
import java.util.List;
public class Test {
 public static void main (String args[]){
 Event e = new Event();
 IValidator<Event> v = new SimpleEventValidator();
 e.setValidator(v);
 List<String> messages = new ArrayList<String>();
 // set other thins to e like
 // e.setPlayers(player1,player2,player3)
 // e.setNumberOfMatches(3);
 // etc
 try {
 e.validate(Event.VALIDABLE_STEP_COURTS);
 messages.add(e.getLastValidationMessage());
 e.validate(Event.VALIDABLE_STEP_MATCHES);
 messages.add(e.getLastValidationMessage());
 e.validate(Event.VALIDABLE_STEP_PLAYERS);
 messages.add(e.getLastValidationMessage());
 } catch (ValidationException e1) {
 messages.add(e.getLastValidationMessage());
 System.out.println("Your event doesn't comply with the fedaration regulations for the following reasons: ");
 for (String s:messages){
 System.out.println(s);
 }
 } catch (UnknownStepTagException e2) {
 System.out.println("Unknown validation step "+v.getLastStepTag());
 }
 }
}

===============