What is the best way to Validate one field in Java based on another field using hibernate-validator?

Question

I have a class that consists of many fields and these fields have the hibernate-validator Annotations so if the invalid data enters then it can throw the respective message.

Some of the fields are interdependent meaning the field has to be Non-null if another field has a certain value. Is there a way this can be achieved using the hibernate-validator directly or do we need to write the custom validations for it?

@Data
@ToString
public class Source implements Serializable {

    @NotNull(message = "Type cannot be Null for source")
    private String type;

    //If type has any value apart from "MANUAL" then this should not be NULL @NotNull(message = "groundValue cannot be Null")
    private String groundValue;

    //If type value is "MANUAL" then this should not be NULL @NotNull(message = "manualType value cannot be Null")
    private String manualType;

    //If type value is "MANUAL" then this should not be NULL @NotNull(message = "manualURI value cannot be Null")
    private String manualURI;
}

As mentioned in the above code snipped if the conditions for groundValue , manualType and manualURI is based on the value provided to the type .

Is it possible to achieve something similar directly using the Javax valdidation ? Following is the Maven dependency that I am using in my project:

<!-- For adding the validation annotations -->
<dependency>
  <groupId>io.quarkus</groupId>
  <artifactId>quarkus-hibernate-validator</artifactId>
</dependency>

Answer 1

Yes you can create your own validator.

package spike;

public interface ISource {
    String getType();

    String getGroundValue();

    String getManualType();

    String getManualURI();
}

package spike;

import java.io.Serializable;

import javax.validation.constraints.NotNull;

@SourceType
public class Source implements Serializable, ISource {

    @NotNull(message = "Type cannot be Null for source")
    private String type;

    //If type has any value apart from "MANUAL" then this should not be NULL @NotNull(message = "groundValue cannot be Null")
    private String groundValue;

    //If type value is "MANUAL" then this should not be NULL @NotNull(message = "manualType value cannot be Null")
    private String manualType;

    //If type value is "MANUAL" then this should not be NULL @NotNull(message = "manualURI value cannot be Null")
    private String manualURI;

    @Override
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Override
    public String getGroundValue() {
        return groundValue;
    }

    public void setGroundValue(String groundValue) {
        this.groundValue = groundValue;
    }

    @Override
    public String getManualType() {
        return manualType;
    }

    public void setManualType(String manualType) {
        this.manualType = manualType;
    }

    @Override
    public String getManualURI() {
        return manualURI;
    }

    public void setManualURI(String manualURI) {
        this.manualURI = manualURI;
    }

    @Override
    public String toString() {
        return "Source{" +
                "type='" + type + '\'' +
                ", groundValue='" + groundValue + '\'' +
                ", manualType='" + manualType + '\'' +
                ", manualURI='" + manualURI + '\'' +
                '}';
    }
}

package spike;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import javax.validation.Constraint;
import javax.validation.Payload;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = SourceTypeValidator.class)
public @interface SourceType {
    String message() default "{SourceTypeError}";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
}

package spike;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

public class SourceTypeValidator implements ConstraintValidator<SourceType, ISource> {

    private String message;

    @Override
    public void initialize(SourceType constraintAnnotation) {
        message = constraintAnnotation.message();
    }

    @Override
    public boolean isValid(ISource value, ConstraintValidatorContext context) {
        if (value == null) {
            return true;
        }
        if ("MANUAL".equals(value.getType())) {
            return true;
        }
        boolean valid = true;
        if (value.getGroundValue() == null) {
            addConstraintViolation(context, "groundValue");
            valid = false;
        }
        if (value.getManualType() == null) {
            addConstraintViolation(context, "manualType");
            valid = false;
        }
        if (value.getManualURI() == null) {
            addConstraintViolation(context, "manualURI");
            valid = false;
        }
        return valid;
    }

    private void addConstraintViolation(ConstraintValidatorContext context, String p) {
        context.buildConstraintViolationWithTemplate(p + " cannot be Null")
                .addPropertyNode(p)
                .addConstraintViolation();
    }

}