In this post I will show you how to validate date ranges with JAVA annotation.

XHTML page:

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://xmlns.jcp.org/jsf/html"
	  xmlns:f="http://xmlns.jcp.org/jsf/core">
    <h:head>
        <title>Facelet Title</title>
    </h:head>
    <h:body>
		<h1>Simple Date Range Validation with Annotation</h1>
		<h:form>
			<h:messages style="color: red" />
			<h:outputText value="First Date" /><br />
			<h:inputText value="#{simpleDateRangeController.dto.startDate}" >
				<f:convertDateTime pattern="yyyy-MM-dd" />
			</h:inputText><br />
			<h:outputText value="Second Date" /><br />
			<h:inputText value="#{simpleDateRangeController.dto.endDate}" >
				<f:convertDateTime pattern="yyyy-MM-dd" />
			</h:inputText><br />
			<h:commandButton value="submit" action="#{simpleDateRangeController.action()}" />
			<br />
			<h:commandLink value="next" action="multipledaterange" immediate="true"/>
		</h:form>
    </h:body>
</html>

This is a simple JSF page with two date inputs and a submit button. When we press the button a the validation process will start via the backing bean that call a super class method.

Backing Bean:

@Named
@RequestScoped
public class SimpleDateRangeController extends AbstractController {

	private SimpleDateRangeDto dto;

	@PostConstruct
	public void init() {
		dto = new SimpleDateRangeDto();
	}

	public SimpleDateRangeController() {
	}

	public void action() {
		super.validate(dto);
	}

	// getters and setters

}
</pre> 

Note that in line 3 we have the super class named: AbstractController. In line 16, in the action method, we call a validate method and we pass as a parameter the dto wich has the data itself.

Abstract Controller

public class AbstractController implements Serializable {

	protected <T extends DateRangeValidation> void validate(T dto) {
		dto.validate();
	}
}

In this abstract class we simple call the validate() method in the received DTO.

Data Transfer Object(DTO):

@ValidDateRange(endDesc = "end date", startDesc = "start date")
public class SimpleDateRangeDto extends DateRangeValidation {

	private Date startDate;
	private Date endDate;

	// getters and setters

}

Here is the point where we annotate at the class-level with our special annotation. We simple use the annotation with 2 parameters. This parameters are optional and it’s purpose is only to personalize the error message. In case that your date fields are different from those in this example you must provide the annotation with more parameters, as you will see in the next class.

Annotation:

@Documented
@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE})
@Retention(RUNTIME)
@Constraint(validatedBy = {DateIntervalValidator.class})
public @interface ValidDateRange {

	@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE})
	@Retention(RUNTIME)
	@Documented
	public @interface List {
		ValidDateRange[] value();
	}

	String message() default "{endDesc} must be after {startDesc}.";
	String start() default "startDate";
	String end() default "endDate";
	String startDesc() default "start date";
	String endDesc() default "end date";
	Class<?>[] groups() default {};
	Class<? extends Payload>[] payload() default {};

	class DateIntervalValidator implements ConstraintValidator<ValidDateRange, Object> {

		private static final String GET = "get";

		private String startDate;
		private String endDate;

		@Override
		public void initialize(ValidDateRange constraintAnnotation) {
			startDate = constraintAnnotation.start();
			endDate = constraintAnnotation.end();
		}

		@Override
		public boolean isValid(Object value, ConstraintValidatorContext context) {
			Class<?> clazz = value.getClass();

			try {
				Method m1 = clazz.getMethod(getMethodByField(startDate), (Class<?>[]) null);
				Method m2 = clazz.getMethod(getMethodByField(endDate), (Class<?>[]) null);

				final Date d1 = (Date) m1.invoke(value, (Object[]) null);
				final Date d2 = (Date) m2.invoke(value, (Object[]) null);

				if (d2 == null) {
					return true;
				}
				if (d1 != null && d1.after(d2)) {
					return false;
				}

			} catch (Exception e) {
			}
			return true;
		}

		private String getMethodByField(String field) {
			StringBuilder sb = new StringBuilder(GET)
					.append(field.substring(0, 1).toUpperCase())
					.append(field.substring(1));
			return sb.toString();
		}
	}
}

Here is where the magic happens. I will not discuss how annotations work, but I will cover the essential part: the constraint validation. The inner class DateIntervalValidator is responsible for the validation of the date fields with the help of reflection. We get the get methods of the two date fields and then we verify if endDate is after startDate. If that condition is false, we return false, otherwise we return true.
The message is required if you want personalize your message.
The start is required if your first date field is different from startDate. It indicates the name of the first field.
The end is required if your end date field is different from endDate. It indicates the name of the second date field.
The purpose the startDesc and endDesc is to use as a placeholder in the message parameter.

Validator:

public abstract class DateRangeValidation implements Serializable {

	private static final long serialVersionUID = 7083856980011157895L;

	public void validate() {
		ValidatorFactory validatorFactory = Validation.buildDefaultValidatorFactory();
		Validator validator = validatorFactory.getValidator();
		Set<ConstraintViolation<DateRangeValidation>> result = validator.validate(this);

		if (!result.isEmpty()) {
			Iterator<ConstraintViolation<DateRangeValidation>> it = result.iterator();
			while (it.hasNext()) {
				String mesg = it.next().getMessage();
				FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, mesg, mesg));
			}
			FacesContext.getCurrentInstance().validationFailed();
		}
	}
}

This class is the trigger of all the validation process. When in the DTO we call the validate method, is this method we are calling, because this class is the superclass of the DTO. It calls the annotation and validates the fields. If there are any erros it will collect them in a set, here called as result. Then we iterate all over the set and add the error messages to faces context.

The next few files demonstrate the same logic applied to 2 or more groups of date validations.

---

XHTML:

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://xmlns.jcp.org/jsf/html"
	  xmlns:f="http://xmlns.jcp.org/jsf/core">
    <h:head>
        <title>Facelet Title</title>
    </h:head>
    <h:body>
		<h1>Multiple Date Range Validation with Annotations</h1>
		<h:form>
			<h:messages style="color: red" />
			<h:outputText value="First Date" /><br />
			<h:inputText value="#{multipleDateRangeController.dto.date1}" >
				<f:convertDateTime pattern="yyyy-MM-dd" />
			</h:inputText><br />
			<h:outputText value="Second Date" /><br />
			<h:inputText value="#{multipleDateRangeController.dto.date2}" >
				<f:convertDateTime pattern="yyyy-MM-dd" />
			</h:inputText><br />
			<h:outputText value="Third Date" /><br />
			<h:inputText value="#{multipleDateRangeController.dto.date3}" >
				<f:convertDateTime pattern="yyyy-MM-dd" />
			</h:inputText><br />
			<h:outputText value="Fourth Date" /><br />
			<h:inputText value="#{multipleDateRangeController.dto.date4}" >
				<f:convertDateTime pattern="yyyy-MM-dd" />
			</h:inputText><br />
			<h:commandButton value="submit" action="#{multipleDateRangeController.action()}" /><br />
			<h:commandLink value="back" action="simpledaterange" immediate="true" />
		</h:form>
    </h:body>
</html>

Backing Bean:

@Named
@RequestScoped
public class MultipleDateRangeController extends AbstractController {

	private MultipleDateRangeDto dto;

	@PostConstruct
	public void init() {
		dto = new MultipleDateRangeDto();
	}

	public MultipleDateRangeController() {
	}

	public void action() {
		super.validate(dto);
	}

	// getters and setters

}

DTO:

@ValidDateRange.List({
	@ValidDateRange(start = "date1", end = "date2", message = "{end} must be after {start}"),
	@ValidDateRange(start = "date3", end = "date4", message = "{end} must be after {start}")
})
public class MultipleDateRangeDto extends DateRangeValidation {

	private Date date1;
	private Date date2;
	private Date date3;
	private Date date4;

	// getters and setters

}

Plase feel free to comment or to suggest new features.
You can read more about this topic here
Download source code.
Thanks.