Hibernate Validator Engine RELOCATION Artifact Stranger's Best Practice Guide
Hibernate Validator is a Java verification framework that is used to verify and limit the attributes of objects.Engine RELOCATION Artifact is an important concept in the framework that is used to separate the verification engine from the application and place it in an independent position.This article will introduce the best practical guidelines for Hibernate Validator Engine Relocation Artifact framework and provide some Java code examples.
1 Overview
Hibernate Validator Engine RELOCATION Artifact framework is a method to separate the Hibernate Validator verification engine from the application.By independent verification engines, better decoupling and modularization can be achieved.This allows verification logic to upgrade and maintain independent applications.
2. Build a verification engine
First, a independent project needs to be established to place the verification engine.You can use Maven or Gradle to build a new project.Add Hibernate Validator to the project's pom.xml or Build.gradle file.
Maven example:
<dependency>
<groupId>org.hibernate.validator</groupId>
<artifactId>hibernate-validator</artifactId>
<version>6.2.0.Final</version>
</dependency>
Gradle example:
groovy
implementation 'org.hibernate.validator:hibernate-validator:6.2.0.Final'
3. Configure the verification engine
In order to enable the verification engine to work normally, some necessary settings need to be configured in the project.
First, create a validationMessages.properties file to define the verification error message.This file should be placed under the class path of the project.
Then, add the following configuration class in the code of the inspection engine project:
import javax.validation.Validation;
import javax.validation.ValidationProviderResolver;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import org.hibernate.validator.HibernateValidatorConfiguration;
public class HibernateValidatorConfigurationProvider {
public ValidatorFactory getValidatorFactory() {
return Validation.byDefaultProvider()
.configure()
.messageInterpolator(new MyMessageInterpolator())
.buildValidatorFactory();
}
}
class MyMessageInterpolator extends ResourceBundleMessageInterpolator {
// Custom message interpolation, used to analyze ValidationMessages.properties file
}
Here is a HibernateValidatorconfigurationProvider class to provide ValidatorFactory instances.During the configuration process, you can set a custom message interpolation (MessageInterpolace) to analyze the verification error message.
4. Introduce verification engine
Add dependence on the verification engine project in the application POM.XML or Build.gradle file.
Maven example:
<dependency>
<cepid> com.example </Groupid> <!-The group of verification engine projects->
<ArtiFactid> Validator-Wingine </Artifactid> <!-Artifactid->
<Version> 1.0.0 </version> <!-The version number of the verification engine project->
</dependency>
Gradle example:
groovy
Implementation Project (': Validator-engine') // The module path of the inspection engine project
After completing the above steps, the application will be able to use a verification engine.
5. verification object
In the application, you can create a customized verification annotation and verification device to check the attributes of the object.The following is an example:
import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.*;
@Target({ElementType.FIELD, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = CustomValidator.class)
public @interface CustomValidation {
String message() default "Invalid value";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
class CustomValidator implements ConstraintValidator<CustomValidation, String> {
public void initialize(CustomValidation constraintAnnotation) {
// Initialize the verification device
}
public boolean isValid(String value, ConstraintValidatorContext context) {
// Customized verification logic
}
}
Use @customValidation and CustomValidator to customize annotations and verifications.Use these custom annotations to verify in the BEAN class of the application.
public class User {
@Valid
@CustomValidation
private String username;
// Getter and Setter omit
}
In other parts of the application, you can use a verification engine to verify the object.
public class Main {
public static void main(String[] args) {
ValidatorFactory validatorFactory = Validation.buildDefaultValidatorFactory();
Validator validator = validatorFactory.getValidator();
User user = new User();
user.setUsername("admin");
Set<ConstraintViolation<User>> violations = validator.validate(user);
for (ConstraintViolation<User> violation : violations) {
System.out.println("Validation error: " + violation.getMessage());
}
}
}
The above code will use the verification engine to verify the username attribute of the user object, and print the verification error message.
This is the best practical guide to Hibernate Validator Engine Relocation Artifact framework.By independent inspection engines, we can achieve better decoupling and modularization and provide flexible verification functions.Hope this article will help you!
