There are quite a few approaches to validating whether or not a given value already exists in a data store or not. In this article, I will show my solution to this problem by using Hibernate Validator in combination with Spring Framework.\u00a0As you will see, the latter is solely used for injecting a dependency into my custom validator, so using the validator without Spring Framework should not be too much work.<\/p>\n
Most other solutions that I have found\u00a0use one of the following approaches to implement a unique constraint validator:<\/p>\n
Personally, I do not fancy using an EntityManager<\/span> or SessionFactory<\/span> directly within a validator, because it violates the architecture of my application (MVC + service layer + repository layer); I want all of my business logic to reside within services, hence why checking whether or not a given value exists in my data store should be done within a service. The same applies for using a repository or DAO (Data Access Object) directly within a validator, as this approach also bypasses the service layer. This may not be a problem for you depending on your application’s architecture, but unless you are dealing with a legacy system that is difficult or time consuming to change the architecture of, then you should strongly consider implementing a service layer.<\/p>\n It is also common to inject a specific service instance into a custom validator. This is actually a good solution, but in my case I wanted a solution that was more generic such that I would not have to implement a new validator for each and every time I wanted to validate the uniqueness of a value. Solutions that do not use bean validation (JSR 303<\/span>) did also not seem feasible because I want to be able to validate a bean with the @Valid<\/span> annotation before a parameter in a Spring MVC controller action.<\/p>\n To overcome these shortcomings, I set out to implement a different approach. Truth be told, my approach has a few shortcomings as well, but I will get back to that. First,\u00a0let me briefly explain how my solution works.<\/p>\n The core concept of my solution is to inject a service into a custom validator. Where it differs from other solutions that I have seen is that the injected service is dynamic such that the validator can be reused in different contexts (for different fields). This is done by requiring the service to be of type FieldValueExists<\/span>, which is just a custom interface that I created. You could name this interface anything you want.<\/p>\n I will explain the semantics of this interface later, after seeing how it is used within the custom Hibernate validator. But first we need an annotation that we can use within classes to apply the unique constraint.<\/p>\n If you are not familiar with the above, then I suggest that you read this part of the Hibernate documentation<\/a>. The target can be either a method, a field or an annotation, where the latter allows this annotation to be grouped with other constraints in a new annotation. With the @Constraint<\/span> annotation, we define which class that implements the constraint – in this case I decided to name the class UniqueValidator<\/span>. We define a required service<\/span> attribute, which is any class that implements our FieldValueExists<\/span> interface. Furthermore, we require a fieldName<\/span> attribute to be passed, which is simply the name of the field for which we want to check if a given value exists. I will explain why this attribute is needed in a moment, as well as the serviceQualifier<\/span> attribute. Please note that the message<\/span> attribute (which is the error message if the constraint’s isValid<\/span> method returns false<\/span>) is a message key, because we have a string enclosed within curly brackets. Therefore you must either define this key within your message source (see here for details<\/a>), or remove the brackets and provide an error message directly within the annotation. The latter of course means that you then cannot translate the message.<\/p>\n Now, let us have a look at the custom constraint implementation.<\/p>\n So the validator has three fields; the application context, the service that is to be used for the validation, and the name of the field. First the initialize<\/span> method is invoked with the annotation as an argument, from which we can get its attribute values. First we get the service<\/span> argument, which is the type of the class that we will use for the validation, such as UserService<\/span>. This class is used to fetch a bean of that type from the application context that we have let Spring Framework autowire into our custom validator. If there are more than one classes of the type, then one can use the optional serviceQualifier<\/span> argument, which is the qualifier for the bean that we want to fetch. This could be the case, for instance, if the type is UserService<\/span> (interface), and we have the following implementations of this interface: UserServiceOneImpl<\/span> and UserServiceTwoImpl<\/span>.<\/p>\n Now that our service bean has been fetched from the application context, we can use it from within the isValid<\/span> method. Because our service is declared with the static type of an interface, we do not need to know the dynamic type of the bean within our validator class. This is essentially what makes this solution dynamic, as it can therefore be used in various contexts.<\/p>\n Dependencies can be injected into the custom Hibernate validator because by default, the LocalValidatorFactoryBean<\/span> configures a SpringConstraintValidatorFactory<\/span> that uses Spring to create ConstraintValidator<\/span> instances. This allows custom ConstraintValidators<\/span> to benefit from dependency injection like any other Spring bean. This is documentered here<\/a> (go to section 5.7.2.2 Configuring Custom Constraints).<\/p>\n To use the validator, we first add the attribute in a class like below.<\/p>\n Note that the validator can of course be used in combination with other Hibernate validators, regardless of whether they are standard or custom. Next, we must implement the fieldValueExists<\/span> method of our FieldValueExists<\/span> interface within the UserService<\/span> class. Note that in this case, UserService<\/span> is an interface and the implementation is actually named UserServiceImpl<\/span>, because the dependency is resolved by Spring Framework.<\/p>\n Since the above interface extends the FieldValueExists<\/span> interface, we do not need to add the fieldValueExists<\/span> method to our service interface. However, we can of course add more methods if we so desire.<\/p>\n The logic within the above method can be adapted entirely and freely to fit your needs. In my case, I only wanted to support validating a single field (email<\/span>), hence why an UnsupportedOperationException<\/span> exception is thrown if validation is attempted for other fields. The code invokes a method on a repository to check whether or not the value exists within a database. This repository is a Spring Data JPA repository that is injected into the service by Spring Framework, but you could implement this exactly how you wish. The reason why we must perform one or more checks on the field name is explained below.<\/p>\n Now, I am by no means saying that this solution is flawless, because it is not. Below I will discuss the shortcomings of my solution.<\/p>\n As previously discussed, I have currently not been able to make this validator work without disabling the validation that Hibernate performs by default when persisting entities. As a result, I have had to disable this behavior. There are several ways of accomplishing this, so I will just show you how I did it by configuring an EntityManagerFactory<\/span> using annotation-based configuration. If you cannot do like this in your particular application, then I kindly ask you to perform a Google search.<\/p>\n Please note that validating uniqueness like this does not guarantee that a value is unique, as it is possible for phantom reads<\/a> to occur. Basically this means that just because your validator “claims” that a value does not exist for a given field (supposedly by looking it up in a database), it is not guaranteed that the value does not exist when an entity is being persisted. That is why one must also apply a unique constraint to the column within the database to ensure that uniqueness is enforced. This is always good practice, but the chances of facing problems by not doing this are higher for highly concurrent systems.<\/p>\n As discussed above, my solution has a few shortcomings, but I still personally prefer it over other solutions that I have found. That being said, please let me know if you know how to overcome these problems, as I would be very interested to learn how to improve this solution.<\/p>\n I hope this article helped anyone solve this problem. Happy coding and thank you for reading!<\/p>\n","protected":false},"excerpt":{"rendered":"My Solution<\/h2>\n
public interface FieldValueExists {\r\n \/**\r\n * Checks whether or not a given value exists for a given field\r\n * \r\n * @param value The value to check for\r\n * @param fieldName The name of the field for which to check if the value exists\r\n * @return True if the value exists for the field; false otherwise\r\n * @throws UnsupportedOperationException\r\n *\/\r\n boolean fieldValueExists(Object value, String fieldName) throws UnsupportedOperationException;\r\n}<\/code><\/pre>\n@Target({ METHOD, FIELD, ANNOTATION_TYPE })\r\n@Retention(RUNTIME)\r\n@Constraint(validatedBy = UniqueValidator.class)\r\n@Documented\r\npublic @interface Unique {\r\n String message() default \"{unique.value.violation}\";\r\n Class<?>[] groups() default {};\r\n Class<? extends Payload>[] payload() default {};\r\n Class<? extends FieldValueExists> service();\r\n String serviceQualifier() default \"\";\r\n String fieldName();\r\n}<\/code><\/pre>\npublic class UniqueValidator implements ConstraintValidator<Unique, Object> {\r\n @Autowired\r\n private ApplicationContext applicationContext;\r\n\r\n private FieldValueExists service;\r\n private String fieldName;\r\n\r\n @Override\r\n public void initialize(Unique unique) {\r\n Class<? extends FieldValueExists> clazz = unique.service();\r\n this.fieldName = unique.fieldName();\r\n String serviceQualifier = unique.serviceQualifier();\r\n\r\n if (!serviceQualifier.equals(\"\")) {\r\n this.service = this.applicationContext.getBean(serviceQualifier, clazz);\r\n } else {\r\n this.service = this.applicationContext.getBean(clazz);\r\n }\r\n }\r\n\r\n @Override\r\n public boolean isValid(Object o, ConstraintValidatorContext constraintValidatorContext) {\r\n return !this.service.fieldValueExists(o, this.fieldName);\r\n }\r\n}<\/code><\/pre>\nUsage<\/h2>\n
public class User {\r\n @Unique(service = UserService.class, fieldName = \"email\", message = \"{email.unique.violation}\")\r\n private String email;\r\n \r\n \/\/ Other fields + getters & setters\r\n}<\/code><\/pre>\npublic interface UserService extends FieldValueExists { }<\/code><\/pre>\n@Service\r\npublic class UserServiceImpl implements UserService {\r\n @Autowired\r\n private UserRepository userRepository;\r\n\r\n @Override\r\n public boolean fieldValueExists(Object value, String fieldName) throws UnsupportedOperationException {\r\n Assert.notNull(fieldName);\r\n\r\n if (!fieldName.equals("email")) {\r\n throw new UnsupportedOperationException("Field name not supported");\r\n }\r\n\r\n if (value == null) {\r\n return false;\r\n }\r\n\r\n return this.userRepository.existsByEmail(value.toString());\r\n }\r\n}<\/code><\/pre>\nSolution Shortcomings<\/h2>\n
\n
Disabling Hibernate Validation When Persisting Entities<\/h2>\n
@Configuration\r\npublic class PersistenceConfig {\r\n @Bean\r\n public EntityManagerFactory entityManagerFactory() throws SQLException {\r\n HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();\r\n vendorAdapter.setGenerateDdl(false);\r\n vendorAdapter.setDatabase(Database.POSTGRESQL);\r\n vendorAdapter.setShowSql(true);\r\n\r\n LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();\r\n factory.setJpaVendorAdapter(vendorAdapter);\r\n String[] packagesToScan = new String[] { ... };\r\n factory.setPackagesToScan(packagesToScan);\r\n factory.setDataSource(this.dataSource());\r\n factory.setValidationMode(ValidationMode.NONE); \/\/ <--------\r\n factory.afterPropertiesSet();\r\n\r\n return factory.getObject();\r\n }\r\n}<\/code><\/pre>\nFinal Words<\/h2>\n