Java EE6 Core Features: Bean Validation parsing __java

A core feature of the Bean Validation (JSR 303)--java EE 6, which defines a metadata model and API for entity validation. Its default metadata source is annotations, but developers can extend it through an XML descriptor. The Validation API does not rely on a particular application layer or programming model, so that the same set of validations can be shared by all tiers of the application. It also provides the mechanism for increasing the customized validation constraints by extending the validation API and the means to query constraints on the metadata warehouse.

Before the advent of JEE6 bean validation, developers had to write validation rules in the presentation-layer framework, business layer, and persistence layer to keep these rules synchronized, but this was a waste of time and error-prone.  Bean validation are implemented through constraints, which appear as annotations, which can be placed on the properties, methods, or classes of JavaBean (such as backing beans). Constraints can be either built-in annotations (located under the Javax.validation.constraints package) or user-defined. Some of the commonly used built-in annotations are listed below:
Min: The element that is annotated by @min must be a number whose value is greater than or equal to the given minimum value. Max: The element that is annotated by @max must be a number whose value is less than or equal to the given maximum value. Size: @Size indicates that the annotated element must be between the given minimum and maximum values. The data types that support size validation are string, Collection (size of the collection), map, and array. Notnull: @NotNull Ensure that the element being annotated cannot be null. Null: @Null ensure that the element being annotated must be null. Pattern: @Pattern Ensure that the annotated element (String) is bound to match the given Java regular expression.

The following example code declares some constraints through the bean validation Annotation: Java code public   class  Address {      & nbsp;    @NotNull   @Size (max=)            Private  String addressline1;              @Size ( max=           private  String addressline2;              public  string getaddressline1 ()  {              return  addressline1;          }              public   void  setaddressline1 (string addressline1)  {              this .addressline1 = addressline1;          }  }  

public class address {@NotNull @Size (max=30) private String addressline1;

       @Size (max=30) private String addressline2;
       Public String GetAddressline1 () {return addressline1;
       } public void SetAddressline1 (String addressline1) {this.addressline1 = addressline1; }
}

The

@NotNull Specifies that the annotated element addressline1 cannot be null; @Size specifies that the annotated element addressline1 and Addressline2 cannot exceed the given maximum value, which is 30 characters.

When the address object is validated, the value of the addressline1 is passed to the validation class for the @notnull constraint and to the validation class for the @size constraint, while the Addressline2 value is passed to the validation class for the @size constraint. Validated by the relevant validation class.

The following code customizes a constraint named ZipCode: Java code @Size (min= 5,  max= 5)       @ Constraintvalidator (Zipcodevalidator. Class)        @Documented         @Target ({Annotation_type, method, field})        @Retention (RUNTIME)       public   @interface  ZipCode {           string message ()  default   "Wrong zipcode";           string[] groups ()  default  {};  }  

 @Size (min=5, max=5) @ConstraintValidator (zipcodevalidator.class) @Documented @Target ({annotatio N_type, method, FIELD}) @Retention (RUNTIME) public @interface ZipCode {String message () default wrong Zipco
       De ";
String[] Groups () default {}; }

The

can use @zipcode on a class, property, or method, just like any other constraint. Java code public   class  Address {           @ZipCode           private  String zipCode;              public  string getzipcode ()  {              return  zipCode;           }             public   void   Setzipcode (string zipcode)  {              This .zipcode = zipcode;          }  }   

public class Address {
       @ZipCode
       private String ZipCode;

       Public String Getzipcode () {return
          zipCode;
       }

       public void Setzipcode (String zipCode) {
          this.zipcode = ZipCode;
       }
}

Validation API

Developers can programmatically validate JavaBean with the help of the validation API. The default package for the Bean Validation API is javax.validation. Some of the classes in the package are described below:

Constraintvalidator: This is an interface, and the specific constraint validation class needs to implement the interface. The interface defines the relevant logic to validate constraints in a given object type.

Validator: the Validahttp://java. Sun.com/javaee/6/docs/api/index.html?javax/validation/validator.htmltor interface holds the contract of an object validation diagram. The implementation of this interface must be thread-safe.

constraintviolation: The Constraintviolation interface represents a constraint validation failure on a given bean that exposes a constraint violation context and information that describes the violation.

validationexception: If some unrecoverable errors occur during the validation process, Validationexception exceptions are thrown. In some cases, the exception can be specified, such as an illegal grouping (group) definition, an illegal constraint definition, and an illegal constraint declaration, and so on.

constraint metadata Request API

The Bean validation specification provides a means of querying constraints on warehouses. This API is used primarily for tool support and integration with other frameworks, libraries, and JSR. The Bean validation specification is designed to provide a validation engine and a metadata warehouse for object constraints. Frameworks that require constraint definitions, validation, and metadata (Java EE or Java SE) can use the Bean Validation specification to accomplish these functions, from an application or infrastructure standpoint, to avoid unnecessary duplication of effort.

The Bean validation has been integrated into JSF 2.0 and JPA 2.0. In JSF, you can bind a form input field to the properties of a domain object. JSF 2 and bean validation can determine which property is bound and perform the validation associated with it, and display the constraint violation information to the user.

The Hibernate Validator 4 is a reference implementation framework for the Bean Validation specification, and its latest edition adds new features such as group validation, natural integration with JPA 2 and JSF 2, and extended annotation sets, among others.

Turn from: http://www.javaeye.com/news/15265