If `` `value``` fails the check due to an incorrect value entered, false is returned.

message() This message is a warning (?) When an incorrect input is made. Contains the wording to be defined in the message properties (such as Hibernate's ValidationMessages.properties). Also, the key is written with a fully qualified class name.

For example, I think it will look like this.

ValidationMessages_jp.properties

validation.CustomSize.message = {0}Please enter so that it does not exceed

groups() It is a setting that can be customized for a specific validation group. Must be initialized with an empty Class <?> Type.

Grouping is for ordering constraints.

@GroupSequence({CheckA.class, CheckB.class}) //After checking A B
public interface GroupedChecks {
}

payload() It is a declaration only to give some meta information to the object to be checked. In fact, I think the contents of the javax.validation.Payload interface are empty and are for markers or categorization.

For example

CustomSize.java

@Target({FIELD})
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = {CustomSizeValidator.class})
public @interface CustomSize {

  String message() default "{validation.CustomSize.message}";
  Class<?>[] groups() default {};
  class Text implements Payload{} // Add Payload
  // omit
}

SampleModel.java

public class SampleModel {
  @CustomSizeValidator(max = 20, payload = {CustomSizeValidator.Text.class})
  private String memo;
  // omit
}

It's not correct, but you can give meaning to the `memo``` field so that it can be identified as a categorization such as `Text```.

Leave empty unless otherwise noted.

max() This time, I set the name max because it is a validation that constrains the "maximum length".

 @CustomSizeValidator(max = 20) //Name to enter here
 private String memo;

List { A[] value() } Define the checkable target (s) depending on the implementation of ConstraintValidator.

@interface List {
  CustomSizeValidator value();
  AnotherValidator aaa();
}

Unless you have a specific reason, one element may be sufficient.

use

Same as other input checks, but add @Valid to the upper model passed as a controller parameter and define BindingResult by arranging it right next to it.

SampleController.java

  @RequestMapping(value = "/sample", method = RequestMethod.POST)
  public String samplePost(@ModelAttribute @Valid BigModel model, BindingResult result) {
    // omit
   }

For nested models, add @Valid to the upper model as well.

BigModel.java

public class BigModel {
  @Valid
  private SmallModel smallModel;
  // omit
}

This custom annotation is @Target ({ElementType.FIELD}), so it targets the field. Attach it to the field to be actually checked.

SmallModel.java

public class SmallModel {
  @CustomSize(max = 20)
  private String input;
  // omit
}

test

• Test to run the app and try it directly (error is stored in `` `BindingResult```)

• Test with test code (give some values and it really calculates exactly)

Since it is a character count with a fixed limit, I tested it with boundary value analysis. I'm testing the annotation constraint implementation class ```isValid () `` `.

CustomTest.groovy

   // omit
   when:
      def result = validator.isValid("", null)
    then:
      assert result == excepted
    where:
      testCase                | maxLen | doubleLen || excepted
      "Boundary value, small" | 5      | 4.5       || true
      "Boundary value, same"  | 5      | 5         || true
      "Boundary value, big"   | 5      | 5.5       || false

The end

It was easy to do something like this. I intended to finish it in about After all, it was very interesting to know the contents, and it was a very good opportunity to study.

reference

Hibernate Community Documentation

that's all