In Relation To

/**
 * Checks that the annotated character sequence is a valid
 * <a href="https://en.wikipedia.org/wiki/International_Standard_Book_Number">ISBN</a>.
 * The length of the number and the check digit are both verified.
 * <p>
 * The supported type is {@code CharSequence}. {@code null} is considered valid.
 * <p>
 * During validation all non ISBN characters are ignored. All digits and 'X' are considered
 * to be valid ISBN characters. This is useful when validating ISBN with dashes separating
 * parts of the number (ex. {@code 978-161-729-045-9}).
 *
 * @author Marko Bekhta
 * @since 6.0.6
 */
@Documented
@Constraint(validatedBy = { })
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Retention(RUNTIME)
@Repeatable(List.class)
public @interface ISBN {
    String message() default "{org.hibernate.validator.constraints.ISBN.message}";

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

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

    Type type() default Type.ISBN13;

    /**
     * Defines several {@code @ISBN} annotations on the same element.
     */
    @Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
    @Retention(RUNTIME)
    @Documented
    public @interface List {
        ISBN[] value();
    }

    /**
     * Defines the ISBN length. Valid lengths of ISBNs are {@code 10} and {@code 13}
     * which are represented as {@link Type#ISBN10} and {@link Type#ISBN13} correspondingly.
     */
    enum Type {
        ISBN10,
        ISBN13
    }
}

public class ISBNValidator implements ConstraintValidator<ISBN, CharSequence> {

    /**
     * Pattern to replace all non ISBN characters. ISBN can have digits or 'X'.
     */
    private static Pattern NON_ISBN_CHARACTERS = Pattern.compile( "[^\\dX]" );

    private int length;

    private Function<String, Boolean> checkChecksumFunction;

    @Override
    public void initialize(ISBN constraintAnnotation) {
        switch ( constraintAnnotation.type() ) {
            case ISBN10:
                length = 10;
                checkChecksumFunction = this::checkChecksumISBN10;
                break;
            case ISBN13:
                length = 13;
                checkChecksumFunction = this::checkChecksumISBN13;
                break;
        }
    }

    @Override
    public boolean isValid(CharSequence isbn, ConstraintValidatorContext context) {
        if ( isbn == null ) {
            return true;
        }

        // Replace all non-digit (or !=X) chars
        String digits = NON_ISBN_CHARACTERS.matcher( isbn ).replaceAll( "" );

        // Check if the length of resulting string matches the expecting one
        if ( digits.length() != length ) {
            return false;
        }

        return checkChecksumFunction.apply( digits );
    }
    // check algorithm details are omitted here.
}

putConstraint( tmpConstraints, ISBN.class, ISBNValidator.class );

putConstraints( tmpConstraints, ISBN.class, Arrays.asList(
        ISBNValidatorForCharacterSequence.class,
        ISBNValidatorForSomeOtherClass.class,
        ....
        ISBNValidatorForSomeAnotherClass.class
) );

org.hibernate.validator.constraints.Email.message   ...
org.hibernate.validator.constraints.ISBN.message    = invalid ISBN number
org.hibernate.validator.constraints.Length.message  ...

private ISBNValidator validator;

@BeforeMethod
public void setUp() throws Exception {
    validator = new ISBNValidator();
}

@Test
public void validISBN10() throws Exception {
    validator.initialize( initializeAnnotation( ISBN.Type.ISBN10 ) );

    assertValidISBN( null );
    assertValidISBN( "99921-58-10-7" );
    assertValidISBN( "9971-5-0210-0" );
    assertValidISBN( "960-425-059-0" );
    assertValidISBN( "0-9752298-0-X" );
    //... more positive cases
}

@Test
public void invalidISBN10() throws Exception {
    validator.initialize( initializeAnnotation( ISBN.Type.ISBN10 ) );

    // invalid check-digit
    assertInvalidISBN( "99921-58-10-8" );
    assertInvalidISBN( "9971-5-0210-1" );
    assertInvalidISBN( "960-425-059-2" );
    assertInvalidISBN( "80-902734-1-8" );
    // ... more negative cases

    // invalid length
    assertInvalidISBN( "" );
    assertInvalidISBN( "978-0-5" );
    assertInvalidISBN( "978-0-55555555555555" );
    // ... more negative cases
}

private ISBN initializeAnnotation(ISBN.Type type) {
    ConstraintAnnotationDescriptor.Builder<ISBN> descriptorBuilder = new ConstraintAnnotationDescriptor.Builder<>( ISBN.class );
    descriptorBuilder.setAttribute( "type", type );
    return descriptorBuilder.build().getAnnotation();
}

public class ISBNConstrainedTest extends AbstractConstrainedTest {

    @Test
    public void testISBN() {
        Foo foo = new Foo( "978-1-56619-909-4" );
        Set<ConstraintViolation<Foo>> violations = validator.validate( foo );
        assertNoViolations( violations );
    }

    @Test
    public void testISBNInvalid() {
        Foo foo = new Foo( "5412-3456-7890" );
        Set<ConstraintViolation<Foo>> violations = validator.validate( foo );
        assertThat( violations ).containsOnlyViolations(
                violationOf( ISBN.class ).withMessage( "invalid ISBN number" )
        );
    }

    private static class Foo {
        @ISBN
        private final String number;

        public Foo(String number) {
            this.number = number;
        }
    }
}