Putting a SpEL(l) on the Bean Validation API

One of the new features introduced with version 3.0 of the Spring framework is the Spring Expression Language or short "SpEL". This language is tailored for the needs when working with Spring and can be used when creating XML/annotation based Spring bean definitions for instance.

So I thought it would be nice if it was possible to use SpEL together with Hibernate Validator's @ScriptAssert constraint which allows to express validation routines using script or expression languages.

Unfortunately this does not work since currently no SpEL language binding for JSR 223 ("Scripting for the Java^TM Platform") exists. As @ScriptAssert's validator uses JSR 223 for expression evaluation at least for now SpEL can't be used along with @ScriptAssert (there is an issue in Spring's JIRA addressing this problem).

But as shown in previous posts it is very simple to create new constraint annotations for the Bean Validation API. So the idea is to build a new constraint @SpelAssert which resembles HV's @ScriptAssert but works with SpEL instead of the JSR 223 API.

Defining the annotation type is straight-forward:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

@Target({ TYPE }) @Retention(RUNTIME) @Constraint(validatedBy = SpelAssertValidator.class) @Documented public @interface SpelAssert { String message() default "{de.gmorling.moapa.bvspel.SpelAssert.message}"; Class<?>[] groups() default {}; Class<? extends Payload>[] payload() default {}; String value(); }

Besides the standard attributes message(), groups() and payload() mandated by the BV specification we define one more attribute value(), which takes the SpEL expression to evaluate.

Now let's come to the validator:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

public class SpelAssertValidator implements ConstraintValidator<SpelAssert, Object> { @Inject private ExpressionParser parser; private Expression expression; @Override public void initialize(SpelAssert constraintAnnotation) { String rawExpression = constraintAnnotation.value(); if (rawExpression == null) { throw new IllegalArgumentException("The expression specified in @" + SpelAssert.class.getSimpleName() + " must not be null."); } expression = parser.parseExpression(rawExpression); } @Override public boolean isValid(Object value, ConstraintValidatorContext context) { if (value == null) { return true; } return Boolean.TRUE.equals(expression.getValue(value, Boolean.class)); } }

In initialize() we use an ExpressionParser to parse the specified SpEL expression (so this happens only once) and evaluate the given object against it in isValid().

But wait a minute, where does the ExpressionParser come from, it is not instantiated here?

Right, the cool thing is Spring comes with it's own ConstraintValidatorFactory which performs dependency injection on constraint validators. A validator relying on that feature of course is not portable, but as this validator is based on SpEL and Spring anyways this is not an issue here.

In order to have this working a parser bean must be part of the Spring application context. We just register a SpelExpressionParser:

1 2 3 4 5 6 7 8 9 10 11 12

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <bean id="parser" class="org.springframework.expression.spel.standard.SpelExpressionParser"/> <bean id="validator" class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean"/> </beans>

This context also shows how to provide a BV Validator for dependency injection leveraging Spring's LocalValidatorFactoryBean.

Now let's have a look at the @SpelAssert constraint in action. The following shows the canonical example of a class CalendarEvent where the start date shall always be earlier than the end date:

1 2 3 4 5 6 7 8 9 10

@SpelAssert("startDate < endDate") public class CalendarEvent { private Date startDate; private Date endDate; // getters, setters etc. }

Note how SpEL allows dates to be compared using the "<" operator and that no alias for the evaluated bean is required, as all unqualified attribute/method names are resolved against the annotated object.

Finally we should have a test showing that the validator works as expected by validating a valid and an invalid CalendarEvent instance:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration public class SpelAssertTest { @Inject private Validator validator; private Date startDate; private Date endDate; @Before public void setUpDates() { Calendar start = Calendar.getInstance(); start.set(2010, 13, 24); startDate = start.getTime(); Calendar end = Calendar.getInstance(); end.set(2010, 13, 26); endDate = end.getTime(); } @Test public void validEvent() { CalendarEvent event = new CalendarEvent(); event.setStartDate(startDate); event.setEndDate(endDate); assertTrue(validator.validate(event).isEmpty()); } @Test public void invalidEventYieldsConstraintViolation() { CalendarEvent event = new CalendarEvent(); event.setStartDate(endDate); event.setEndDate(startDate); Set<ConstraintViolation<CalendarEvent>> violations = validator.validate(event); assertEquals(1, violations.size()); ConstraintViolation<CalendarEvent> violation = violations.iterator().next(); assertEquals( "SpEL expression \"startDate < endDate\" didn't evaluate to true.", violation.getMessage()); } }

The complete sources for this post can be found at GitHub, so don't hesistate to give it a try or use it in your projects if you like. Any feedback or ideas for improvement are warmly welcome.