Question

Suppose a MailConfiguration class specifying settings for sending mails :

public class MailConfiguration {

  private AddressesPart addressesPart;

  private String subject;

  private FilesAttachments filesAttachments;

  private String bodyPart;

  public MailConfiguration(AddressesPart addressesPart, String subject, FilesAttachments filesAttachements,
    String bodyPart) {
    Validate.notNull(addressesPart, "addressesPart must not be null");
    Validate.notNull(subject, "subject must not be null");
    Validate.notNull(filesAttachments, "filesAttachments must not be null");
    Validate.notNull(bodyPart, "bodyPart must not be null");
    this.addressesPart = addressesPart;
    this.subject = subject;
    this.filesAttachements = filesAttachements;
    this.bodyPart = bodyPart;
  }
  // ...  some useful getters ......

}

So, I’m using two values objects : AddressesPart and FilesAttachment.

Theses two values objects have similar structures so I’m only going to expose here AddressesPart :

public class AddressesPart {

  private final String senderAddress;

  private final Set recipientToMailAddresses;

  private final Set recipientCCMailAdresses;

  public AddressesPart(String senderAddress, Set recipientToMailAddresses, Set recipientCCMailAdresses) {
    validate(senderAddress, recipientToMailAddresses, recipientCCMailAdresses);
    this.senderAddress = senderAddress;
    this.recipientToMailAddresses = recipientToMailAddresses;
    this.recipientCCMailAdresses = recipientCCMailAdresses;
  }

  private void validate(String senderAddress, Set recipientToMailAddresses, Set recipientCCMailAdresses) {
    AddressValidator addressValidator = new AddressValidator();
    addressValidator.validate(senderAddress);
    addressValidator.validate(recipientToMailAddresses);
    addressValidator.validate(recipientCCMailAdresses);
  }

  public String getSenderAddress() {
    return senderAddress;
  }

  public Set getRecipientToMailAddresses() {
    return recipientToMailAddresses;
  }

  public Set getRecipientCCMailAdresses() {
    return recipientCCMailAdresses;
  }

}

And the associated validator : AddressValidator

public class AddressValidator {

  private static final String EMAIL_PATTERN
    = "^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";

  public void validate(String address) {
    validate(Collections.singleton(address));
  }

  public void validate(Set addresses) {
    Validate.notNull(addresses, "List of mail addresses must not be null");
    for (Iterator it = addresses.iterator(); it.hasNext(); ) {
      String address = (String) it.next();
      Validate.isTrue(address != null && isAddressWellFormed(address), "Invalid Mail address " + address);
    }
  }

  private boolean isAddressWellFormed(String address) {
    Pattern emailPattern = Pattern.compile(EMAIL_PATTERN);
    Matcher matcher = emailPattern.matcher(address);
    return matcher.matches();
  }
}

Thus, I have two questions :

1) If for some reasons, later, we want to validate differently an address mail (for instance to include/exclude some aliases matching to existing mailingList), should I expose a kind of IValidator as a constructor parameter ? like the following rather than bringing concrete dependence (like I made):

public AddressValidator(IValidator myValidator) {
   this.validator = myValidator;
}

Indeed, this will respect the D principle of SOLID principle : Dependency injection.

However, if we follow this logical, would a majority of Values Objects own an abstract validator or it’s just an overkill the most of time (thinking to YAGNI ?) ?

2) I’ve read in some articles than in respect of DDD, all validations must be present and only present in Aggregate Root, means in this case : MailConfiguration.

Am I right if I consider that immutable objects should never be in an uncohesive state ? Thus, would validation in constructor as I made be preferred in the concerned entity (and so avoiding aggregate to worry about validation of it’s “children” ?

Answer 1

I’m not quite sure if I follow you 100%, but one way to handle ensuring immutable objects are only allowed to be created if they are valid is to use the Essence Pattern.

In a nutshell, the idea is that the parent class contains a static factory that creates immutable instances of itself based on instances of an inner “essence” class. The inner essence is mutable and allows objects to be built up, so you can put the pieces together as you go, and can be validated along the way as well.

The SOLID principals and good DDD is abided by since the parent immutable class is still doing only one thing, but allows others to build it up through it’s “essence”.

For an example of this, check out the Ldap extension to the Spring Security library.