validation हाइबरनेट वैलिडेटर(जेएसआर 303) के साथ क्रॉस फील्ड सत्यापन




hibernate-validator bean-validation (12)

क्या हाइबरनेट वैलिडेटर 4.x में क्रॉस फील्ड सत्यापन के लिए (या तृतीय पक्ष कार्यान्वयन) का कार्यान्वयन है? यदि नहीं, तो क्रॉस फ़ील्ड सत्यापनकर्ता को कार्यान्वित करने का सबसे साफ तरीका क्या है?

उदाहरण के तौर पर, आप दो बीन गुणों को मान्य करने के लिए API का उपयोग कैसे कर सकते हैं (जैसे पासवर्ड फ़ील्ड को सत्यापित करना पासवर्ड सत्यापित फ़ील्ड से मेल खाता है)।

एनोटेशन में, मुझे कुछ उम्मीद होगी:

public class MyBean {
  @Size(min=6, max=50)
  private String pass;

  @Equals(property="pass")
  private String passVerify;
}

ओवल का प्रयास क्यों न करें: http://oval.sourceforge.net/

ऐसा लगता है कि यह ओजीएनएल का समर्थन करता है ताकि आप इसे अधिक प्राकृतिक रूप से कर सकें

@Assert(expr = "_value ==_this.pass").

क्रॉस फ़ील्ड सत्यापन कस्टम बाधाओं को बनाकर किया जा सकता है।

उदाहरण: - उपयोगकर्ता उदाहरण के पासवर्ड और पुष्टि पासवर्ड फ़ील्ड की तुलना करें।

CompareStrings

@Target({TYPE})
@Retention(RUNTIME)
@Constraint(validatedBy=CompareStringsValidator.class)
@Documented
public @interface CompareStrings {
    String[] propertyNames();
    StringComparisonMode matchMode() default EQUAL;
    boolean allowNull() default false;
    String message() default "";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

StringComparisonMode

public enum StringComparisonMode {
    EQUAL, EQUAL_IGNORE_CASE, NOT_EQUAL, NOT_EQUAL_IGNORE_CASE
}

CompareStringsValidator

public class CompareStringsValidator implements ConstraintValidator<CompareStrings, Object> {

    private String[] propertyNames;
    private StringComparisonMode comparisonMode;
    private boolean allowNull;

    @Override
    public void initialize(CompareStrings constraintAnnotation) {
        this.propertyNames = constraintAnnotation.propertyNames();
        this.comparisonMode = constraintAnnotation.matchMode();
        this.allowNull = constraintAnnotation.allowNull();
    }

    @Override
    public boolean isValid(Object target, ConstraintValidatorContext context) {
        boolean isValid = true;
        List<String> propertyValues = new ArrayList<String> (propertyNames.length);
        for(int i=0; i<propertyNames.length; i++) {
            String propertyValue = ConstraintValidatorHelper.getPropertyValue(String.class, propertyNames[i], target);
            if(propertyValue == null) {
                if(!allowNull) {
                    isValid = false;
                    break;
                }
            } else {
                propertyValues.add(propertyValue);
            }
        }

        if(isValid) {
            isValid = ConstraintValidatorHelper.isValid(propertyValues, comparisonMode);
        }

        if (!isValid) {
          /*
           * if custom message was provided, don't touch it, otherwise build the
           * default message
           */
          String message = context.getDefaultConstraintMessageTemplate();
          message = (message.isEmpty()) ?  ConstraintValidatorHelper.resolveMessage(propertyNames, comparisonMode) : message;

          context.disableDefaultConstraintViolation();
          ConstraintViolationBuilder violationBuilder = context.buildConstraintViolationWithTemplate(message);
          for (String propertyName : propertyNames) {
            NodeBuilderDefinedContext nbdc = violationBuilder.addNode(propertyName);
            nbdc.addConstraintViolation();
          }
        }    

        return isValid;
    }
}

ConstraintValidatorHelper

public abstract class ConstraintValidatorHelper {

public static <T> T getPropertyValue(Class<T> requiredType, String propertyName, Object instance) {
        if(requiredType == null) {
            throw new IllegalArgumentException("Invalid argument. requiredType must NOT be null!");
        }
        if(propertyName == null) {
            throw new IllegalArgumentException("Invalid argument. PropertyName must NOT be null!");
        }
        if(instance == null) {
            throw new IllegalArgumentException("Invalid argument. Object instance must NOT be null!");
        }
        T returnValue = null;
        try {
            PropertyDescriptor descriptor = new PropertyDescriptor(propertyName, instance.getClass());
            Method readMethod = descriptor.getReadMethod();
            if(readMethod == null) {
                throw new IllegalStateException("Property '" + propertyName + "' of " + instance.getClass().getName() + " is NOT readable!");
            }
            if(requiredType.isAssignableFrom(readMethod.getReturnType())) {
                try {
                    Object propertyValue = readMethod.invoke(instance);
                    returnValue = requiredType.cast(propertyValue);
                } catch (Exception e) {
                    e.printStackTrace(); // unable to invoke readMethod
                }
            }
        } catch (IntrospectionException e) {
            throw new IllegalArgumentException("Property '" + propertyName + "' is NOT defined in " + instance.getClass().getName() + "!", e);
        }
        return returnValue; 
    }

    public static boolean isValid(Collection<String> propertyValues, StringComparisonMode comparisonMode) {
        boolean ignoreCase = false;
        switch (comparisonMode) {
        case EQUAL_IGNORE_CASE:
        case NOT_EQUAL_IGNORE_CASE:
            ignoreCase = true;
        }

        List<String> values = new ArrayList<String> (propertyValues.size());
        for(String propertyValue : propertyValues) {
            if(ignoreCase) {
                values.add(propertyValue.toLowerCase());
            } else {
                values.add(propertyValue);
            }
        }

        switch (comparisonMode) {
        case EQUAL:
        case EQUAL_IGNORE_CASE:
            Set<String> uniqueValues = new HashSet<String> (values);
            return uniqueValues.size() == 1 ? true : false;
        case NOT_EQUAL:
        case NOT_EQUAL_IGNORE_CASE:
            Set<String> allValues = new HashSet<String> (values);
            return allValues.size() == values.size() ? true : false;
        }

        return true;
    }

    public static String resolveMessage(String[] propertyNames, StringComparisonMode comparisonMode) {
        StringBuffer buffer = concatPropertyNames(propertyNames);
        buffer.append(" must");
        switch(comparisonMode) {
        case EQUAL:
        case EQUAL_IGNORE_CASE:
            buffer.append(" be equal");
            break;
        case NOT_EQUAL:
        case NOT_EQUAL_IGNORE_CASE:
            buffer.append(" not be equal");
            break;
        }
        buffer.append('.');
        return buffer.toString();
    }

    private static StringBuffer concatPropertyNames(String[] propertyNames) {
        //TODO improve concating algorithm
        StringBuffer buffer = new StringBuffer();
        buffer.append('[');
        for(String propertyName : propertyNames) {
            char firstChar = Character.toUpperCase(propertyName.charAt(0));
            buffer.append(firstChar);
            buffer.append(propertyName.substring(1));
            buffer.append(", ");
        }
        buffer.delete(buffer.length()-2, buffer.length());
        buffer.append("]");
        return buffer;
    }
}

उपयोगकर्ता

@CompareStrings(propertyNames={"password", "confirmPassword"})
public class User {
    private String password;
    private String confirmPassword;

    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
    public String getConfirmPassword() { return confirmPassword; }
    public void setConfirmPassword(String confirmPassword) { this.confirmPassword =  confirmPassword; }
}

परीक्षा

    public void test() {
        User user = new User();
        user.setPassword("password");
        user.setConfirmPassword("paSSword");
        Set<ConstraintViolation<User>> violations = beanValidator.validate(user);
        for(ConstraintViolation<User> violation : violations) {
            logger.debug("Message:- " + violation.getMessage());
        }
        Assert.assertEquals(violations.size(), 1);
    }

आउटपुट Message:- [Password, ConfirmPassword] must be equal.

तुलनात्मकरण सत्यापन बाधा का उपयोग करके, हम दो से अधिक गुणों की तुलना भी कर सकते हैं और हम चार स्ट्रिंग तुलना विधियों में से किसी एक को मिश्रित कर सकते हैं।

ColorChoice

@CompareStrings(propertyNames={"color1", "color2", "color3"}, matchMode=StringComparisonMode.NOT_EQUAL, message="Please choose three different colors.")
public class ColorChoice {

    private String color1;
    private String color2;
    private String color3;
        ......
}

परीक्षा

ColorChoice colorChoice = new ColorChoice();
        colorChoice.setColor1("black");
        colorChoice.setColor2("white");
        colorChoice.setColor3("white");
        Set<ConstraintViolation<ColorChoice>> colorChoiceviolations = beanValidator.validate(colorChoice);
        for(ConstraintViolation<ColorChoice> violation : colorChoiceviolations) {
            logger.debug("Message:- " + violation.getMessage());
        }

आउटपुट Message:- Please choose three different colors.

इसी प्रकार, हम तुलना नंबर्स, तुलनाडेट्स, आदि क्रॉस-फ़ील्ड सत्यापन बाधाएं प्राप्त कर सकते हैं।

पीएस मैंने उत्पादन कोड के तहत इस कोड का परीक्षण नहीं किया है (हालांकि मैंने इसे देव पर्यावरण के तहत परीक्षण किया है), इसलिए इस कोड को मीलस्टोन रिलीज के रूप में देखें। अगर आपको कोई बग मिलती है, तो कृपया एक अच्छी टिप्पणी लिखें। :)


तुम लड़के गजब हो। वास्तव में अद्भुत विचार। मुझे अल्बर्थोवेन और मैकजिन का सबसे अधिक पसंद है, इसलिए मैंने दोनों विचारों को गठबंधन करने का फैसला किया। और सभी मामलों को पूरा करने के लिए कुछ सामान्य समाधान विकसित करें। मेरा प्रस्तावित समाधान यहां है।

@Documented
@Constraint(validatedBy = NotFalseValidator.class)
@Target({ElementType.METHOD, ElementType.FIELD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface NotFalse {


    String message() default "NotFalse";
    String[] messages();
    String[] properties();
    String[] verifiers();

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

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

}
public class NotFalseValidator implements ConstraintValidator<NotFalse, Object> {
    private String[] properties;
    private String[] messages;
    private String[] verifiers;
    @Override
    public void initialize(NotFalse flag) {
        properties = flag.properties();
        messages = flag.messages();
        verifiers = flag.verifiers();
    }

    @Override
    public boolean isValid(Object bean, ConstraintValidatorContext cxt) {
        if(bean == null) {
            return true;
        }

        boolean valid = true;
        BeanWrapper beanWrapper = PropertyAccessorFactory.forBeanPropertyAccess(bean);

        for(int i = 0; i< properties.length; i++) {
           Boolean verified = (Boolean) beanWrapper.getPropertyValue(verifiers[i]);
           valid &= isValidProperty(verified,messages[i],properties[i],cxt);
        }

        return valid;
    }

    boolean isValidProperty(Boolean flag,String message, String property, ConstraintValidatorContext cxt) {
        if(flag == null || flag) {
            return true;
        } else {
            cxt.disableDefaultConstraintViolation();
            cxt.buildConstraintViolationWithTemplate(message)
                    .addPropertyNode(property)
                    .addConstraintViolation();
            return false;
        }

    }



}
@NotFalse(
        messages = {"End Date Before Start Date" , "Start Date Before End Date" } ,
        properties={"endDateTime" , "startDateTime"},
        verifiers = {"validDateRange" , "validDateRange"})
public class SyncSessionDTO implements ControllableNode {
    @NotEmpty @NotPastDate
    private Date startDateTime;

    @NotEmpty
    private Date endDateTime;



    public Date getStartDateTime() {
        return startDateTime;
    }

    public void setStartDateTime(Date startDateTime) {
        this.startDateTime = startDateTime;
    }

    public Date getEndDateTime() {
        return endDateTime;
    }

    public void setEndDateTime(Date endDateTime) {
        this.endDateTime = endDateTime;
    }


    public Boolean getValidDateRange(){
        if(startDateTime != null && endDateTime != null) {
            return startDateTime.getTime() <= endDateTime.getTime();
        }

        return null;
    }

}

यदि आप स्प्रिंग फ्रेमवर्क का उपयोग कर रहे हैं तो आप इसके लिए स्प्रिंग एक्सप्रेशन भाषा (एसपीईएल) का उपयोग कर सकते हैं। मैंने एक छोटी पुस्तकालय लिखी है जो जेएसआर -303 सत्यापनकर्ता को स्पेल पर आधारित प्रदान करता है - यह क्रॉस-फील्ड सत्यापन को हवा बनाता है! https://github.com/jirutka/validator-spring पर एक नज़र डालें।

यह पासवर्ड फ़ील्ड की लंबाई और समानता को मान्य करेगा।

@SpELAssert(value = "pass.equals(passVerify)",
            message = "{validator.passwords_not_same}")
public class MyBean {

    @Size(min = 6, max = 50)
    private String pass;

    private String passVerify;
}

आप केवल खाली फ़ील्ड को सत्यापित करने के लिए पासवर्ड फ़ील्ड को सत्यापित करने के लिए इसे आसानी से संशोधित भी कर सकते हैं।

@SpELAssert(value = "pass.equals(passVerify)",
            applyIf = "pass || passVerify",
            message = "{validator.passwords_not_same}")
public class MyBean {

    @Size(min = 6, max = 50)
    private String pass;

    private String passVerify;
}

मैंने अल्बर्थोवेन के उदाहरण (हाइबरनेट-वैलिडेटर 4.0.2.जीए) की कोशिश की है और मुझे एक सत्यापन प्राप्त होता है: "एनोटेटेड विधियों को जावाबीन नामकरण सम्मेलन का पालन करना होगा। मैच () नहीं करता है। "भी। "मैच" से "isValid" तक विधि का नाम बदलने के बाद यह काम करता है।

public class Password {

    private String password;

    private String retypedPassword;

    public Password(String password, String retypedPassword) {
        super();
        this.password = password;
        this.retypedPassword = retypedPassword;
    }

    @AssertTrue(message="password should match retyped password")
    private boolean isValid(){
        if (password == null) {
            return retypedPassword == null;
        } else {
            return password.equals(retypedPassword);
        }
    }

    public String getPassword() {
        return password;
    }

    public String getRetypedPassword() {
        return retypedPassword;
    }

}

मेरे पास पहले जवाब पर टिप्पणी करने की प्रतिष्ठा नहीं है लेकिन यह जोड़ना चाहता था कि मैंने विजेता उत्तर के लिए यूनिट परीक्षण जोड़े हैं और निम्नलिखित अवलोकन हैं:

  • यदि आपको पहले या फ़ील्ड नाम गलत होते हैं तो आपको सत्यापन त्रुटि मिलती है जैसे मान मेल नहीं खाते हैं। वर्तनी की गलतियों से गुजरना मत उदा

@FieldMatch (पहला = " अवैध फ़ील्डनाम 1", दूसरा = "validFieldName2")

  • वैधकर्ता बराबर डेटा प्रकार स्वीकार करेगा यानी ये सभी फील्डमैच के साथ पास होंगे:

निजी स्ट्रिंग स्ट्रिंगफिल्ड = "1";

निजी इंटीजर पूर्णांक फ़ील्ड = नया इंटीजर (1)

निजी int intField = 1;

  • यदि फ़ील्ड किसी ऑब्जेक्ट प्रकार के हैं जो बराबर लागू नहीं करता है, तो सत्यापन विफल हो जाएगा।

प्रत्येक फ़ील्ड बाधा को एक विशिष्ट सत्यापनकर्ता एनोटेशन द्वारा संभाला जाना चाहिए, या दूसरे शब्दों में यह अन्य क्षेत्रों के खिलाफ एक फ़ील्ड की सत्यापन एनोटेशन जांच करने के लिए अभ्यास का सुझाव नहीं दिया जाता है; वर्ग स्तर पर पार-क्षेत्र सत्यापन किया जाना चाहिए। इसके अतिरिक्त, जेएसआर -303 सेक्शन 2.2 उसी प्रकार के कई सत्यापनों को व्यक्त करने का पसंदीदा तरीका एनोटेशन की सूची के माध्यम से है। यह प्रति संदेश त्रुटि संदेश निर्दिष्ट करने की अनुमति देता है।

उदाहरण के लिए, एक सामान्य रूप को मान्य करना:

@FieldMatch.List({
        @FieldMatch(first = "password", second = "confirmPassword", message = "The password fields must match"),
        @FieldMatch(first = "email", second = "confirmEmail", message = "The email fields must match")
})
public class UserRegistrationForm  {
    @NotNull
    @Size(min=8, max=25)
    private String password;

    @NotNull
    @Size(min=8, max=25)
    private String confirmPassword;

    @NotNull
    @Email
    private String email;

    @NotNull
    @Email
    private String confirmEmail;
}

एनोटेशन:

package constraints;

import constraints.impl.FieldMatchValidator;

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.Documented;
import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.TYPE;
import java.lang.annotation.Retention;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Target;

/**
 * Validation annotation to validate that 2 fields have the same value.
 * An array of fields and their matching confirmation fields can be supplied.
 *
 * Example, compare 1 pair of fields:
 * @FieldMatch(first = "password", second = "confirmPassword", message = "The password fields must match")
 * 
 * Example, compare more than 1 pair of fields:
 * @FieldMatch.List({
 *   @FieldMatch(first = "password", second = "confirmPassword", message = "The password fields must match"),
 *   @FieldMatch(first = "email", second = "confirmEmail", message = "The email fields must match")})
 */
@Target({TYPE, ANNOTATION_TYPE})
@Retention(RUNTIME)
@Constraint(validatedBy = FieldMatchValidator.class)
@Documented
public @interface FieldMatch
{
    String message() default "{constraints.fieldmatch}";

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

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

    /**
     * @return The first field
     */
    String first();

    /**
     * @return The second field
     */
    String second();

    /**
     * Defines several <code>@FieldMatch</code> annotations on the same element
     *
     * @see FieldMatch
     */
    @Target({TYPE, ANNOTATION_TYPE})
    @Retention(RUNTIME)
    @Documented
            @interface List
    {
        FieldMatch[] value();
    }
}

वैलिडेटर:

package constraints.impl;

import constraints.FieldMatch;
import org.apache.commons.beanutils.BeanUtils;

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

public class FieldMatchValidator implements ConstraintValidator<FieldMatch, Object>
{
    private String firstFieldName;
    private String secondFieldName;

    @Override
    public void initialize(final FieldMatch constraintAnnotation)
    {
        firstFieldName = constraintAnnotation.first();
        secondFieldName = constraintAnnotation.second();
    }

    @Override
    public boolean isValid(final Object value, final ConstraintValidatorContext context)
    {
        try
        {
            final Object firstObj = BeanUtils.getProperty(value, firstFieldName);
            final Object secondObj = BeanUtils.getProperty(value, secondFieldName);

            return firstObj == null && secondObj == null || firstObj != null && firstObj.equals(secondObj);
        }
        catch (final Exception ignore)
        {
            // ignore
        }
        return true;
    }
}

हाइबरनेट वैलिडेटर 4.1.0 के साथ। अंतिम मैं @ScriptAssert का उपयोग करने की सलाह देता हूं :

@ScriptAssert(lang = "javascript", script = "_this.passVerify.equals(_this.pass)")
public class MyBean {
  @Size(min=6, max=50)
  private String pass;

  private String passVerify;
}

एक कस्टम क्लास स्तर सत्यापनकर्ता @Matchches समाधान के साथ कुछ भी गलत नहीं है।


प्रश्न के साथ हल समाधान: एनोटेशन संपत्ति में वर्णित एक फ़ील्ड का उपयोग कैसे करें

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Match {

    String field();

    String message() default "";
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = MatchValidator.class)
@Documented
public @interface EnableMatchConstraint {

    String message() default "Fields must match!";

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

    Class<? extends Payload>[] payload() default {};
}
public class MatchValidator implements  ConstraintValidator<EnableMatchConstraint, Object> {

    @Override
    public void initialize(final EnableMatchConstraint constraint) {}

    @Override
    public boolean isValid(final Object o, final ConstraintValidatorContext context) {
        boolean result = true;
        try {
            String mainField, secondField, message;
            Object firstObj, secondObj;

            final Class<?> clazz = o.getClass();
            final Field[] fields = clazz.getDeclaredFields();

            for (Field field : fields) {
                if (field.isAnnotationPresent(Match.class)) {
                    mainField = field.getName();
                    secondField = field.getAnnotation(Match.class).field();
                    message = field.getAnnotation(Match.class).message();

                    if (message == null || "".equals(message))
                        message = "Fields " + mainField + " and " + secondField + " must match!";

                    firstObj = BeanUtils.getProperty(o, mainField);
                    secondObj = BeanUtils.getProperty(o, secondField);

                    result = firstObj == null && secondObj == null || firstObj != null && firstObj.equals(secondObj);
                    if (!result) {
                        context.disableDefaultConstraintViolation();
                        context.buildConstraintViolationWithTemplate(message).addPropertyNode(mainField).addConstraintViolation();
                        break;
                    }
                }
            }
        } catch (final Exception e) {
            // ignore
            //e.printStackTrace();
        }
        return result;
    }
}

और इसका उपयोग कैसे करें ...? इस कदर:

@Entity
@EnableMatchConstraint
public class User {

    @NotBlank
    private String password;

    @Match(field = "password")
    private String passwordConfirmation;
}

मुझे जैकब जिरुत्का से स्प्रिंग एक्सप्रेशन भाषा का उपयोग करने के विचार पसंद हैं। यदि आप एक और लाइब्रेरी / निर्भरता (यह मानते हुए कि आप पहले से ही वसंत का उपयोग नहीं करना चाहते हैं) जोड़ना नहीं चाहते हैं, तो यहां उनके विचार का एक सरल कार्यान्वयन है।

बाधा:

@Constraint(validatedBy=ExpressionAssertValidator.class)
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ExpressionAssert {
    String message() default "expression must evaluate to true";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
    String value();
}

वैधकर्ता:

public class ExpressionAssertValidator implements ConstraintValidator<ExpressionAssert, Object> {
    private Expression exp;

    public void initialize(ExpressionAssert annotation) {
        ExpressionParser parser = new SpelExpressionParser();
        exp = parser.parseExpression(annotation.value());
    }

    public boolean isValid(Object value, ConstraintValidatorContext context) {
        return exp.getValue(value, Boolean.class);
    }
}

इस तरह लागू करें:

@ExpressionAssert(value="pass == passVerify", message="passwords must be same")
public class MyBean {
    @Size(min=6, max=50)
    private String pass;
    private String passVerify;
}

आपको इसे स्पष्ट रूप से कॉल करने की आवश्यकता है। ऊपर दिए गए उदाहरण में, ब्रैडहाउस ने आपको कस्टम बाधा लिखने के लिए सभी कदम दिए हैं।

इस कोड को अपने कॉलर क्लास में जोड़ें।

ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
validator = factory.getValidator();

Set<ConstraintViolation<yourObjectClass>> constraintViolations = validator.validate(yourObject);

उपरोक्त मामले में यह होगा

Set<ConstraintViolation<AccountCreateForm>> constraintViolations = validator.validate(objAccountCreateForm);

मैं आपको एक और संभावित समाधान का सुझाव देता हूं। शायद कम सुरुचिपूर्ण, लेकिन आसान!

public class MyBean {
  @Size(min=6, max=50)
  private String pass;

  private String passVerify;

  @AssertTrue(message="passVerify field should be equal than pass field")
  private boolean isValid() {
    return this.pass.equals(this.passVerify);
  }
}

isValid () विधि स्वचालित रूप से सत्यापनकर्ता द्वारा बुलाया जाता है।





bean-validation