Java Best Practices : Building Safe Domain Objects

Domain objects are the core building blocks of any application. These are the fine grained objects which carries the information about the problem domain model.
Generally domain objects will be created as dumb data carriers with setters/geters without having any logic. But this will cause huge problem in long run.
If you build the domain objects with dumb setters and getters we will end up in writing null checks all over the places.

I bet many of us have seen the code snippets like:

User user = ....;
if(user!=null)
{
 String email = user.getEmail();
 if(email != null && StringUtils.trimToNull(email) != null)
 {
  emailService.sendEmail(....);
 }
 else
 {
  throw new Exception("Email should not be null/blank");
 }

}

Here email address of User object should not be null at all(It could be a not null property in database).

But with dumb domain objects with only setters/getters we will end up writing code to check for nulls as mentioned above.

We can get rid of this null checks in all over the places we can use Builder pattern.

Assume we need to write a domain Object User with properties id, firstname, lastname, email, dob, phone.
Among them id, firstname, lastname, email properties are mandatory and should not be null or blank.

In this case we can write the User class using Builder pattern as follows:

package com.sivalabs.core.model;

import java.util.Date;

/**
 * @author Siva
 *
 */
public class User 
{
 private Integer id;
 private String firstname;
 private String lastname;
 private String email;
 private Date dob;
 private String phone;
 
 private User()
 {
 }
 
 private User(Integer id, String firstname, String lastname, String email) 
 {
  this.id = id;
  this.firstname = firstname;
  this.lastname = lastname;
  this.email = email;
 }

 public static final User build(Integer id, String firstname, String lastname, String email)
 {
  if(id == null || id < 0){
   throw new IllegalArgumentException("Id should not be null or negetive.");
  }
  if(firstname == null || firstname.trim().length()==0){
   throw new IllegalArgumentException("firstname should not be null or blank.");
  }
  if(lastname == null || lastname.trim().length()==0){
   throw new IllegalArgumentException("lastname should not be null or blank.");
  }
  if(email == null || email.trim().length()==0){
   throw new IllegalArgumentException("email should not be null or blank.");
  }
  if(!email.contains("@")){
   throw new IllegalArgumentException("Invalid email address.");
  }
  return new User(id,firstname, lastname, email);
 }
 
 public Integer getId() {
  return id;
 } 
 public String getFirstname() {
  return firstname;
 }
 
 public String getLastname() {
  return lastname;
 }
 
 public String getEmail() {
  return email;
 }
 
 public Date getDob() {
  return new Date(dob.getTime());
 }
 
 public User dob(Date dob) {
  this.dob = new Date(dob.getTime());
  return this;
 }
 public String getPhone() {
  return phone;
 }
 public User phone(String phone) {
  this.phone = phone;
  return this;
 } 
 
}

Following are the steps to build safe domain objects:

1. Make default constructor as private preventing others creating empty instances.  
2. Create a private parametrized constructor with mandatory arguments only.  
3. Provide a public static build() method taking mandatory arguments, validate them and then build the object using parametrized constructor.  
4. Create setter methods (I have used Method chaining here) for optional properties. 
 
With this procedure I need not check for nulls for the mandatory arguments becuase if I have a non-null user object means it contains valid values for mandatory properties.