Bean Validation , which comes from Java Specification Request (JSR 303), was
introduced in Java EE 6. The Bean Validation specification provides a set of
annotations we can use to validate our data. The NetBeans JPA generation wizard
takes full advantage of Bean Validation, adding Bean Validation annotations to
any appropriate fields, based on the column definitions of the tables we are using
to generate our entities.
In our Customer entity, we see some Bean Validation annotations. The
customerId field is decorated with the @NotNull annotation, which—as
its name implies—prevents the field from accepting a null value.
Several fields in the Customer entity are decorated with the @Size annotation. This
annotation specifies the maximum number of characters a bean's property may
accept. Again, the NetBeans wizard obtains this information from the tables used
to generate our entity.
Another Bean Validation annotation we can use is the @Pattern annotation. This
annotation is meant to make sure that the value of the decorated field matches a
given regular expression.
Notice that right above the email property of the Customer annotation, the wizard
added the @Pattern annotation and commented it out. The reason for this is that
the wizard noticed that the name of the table column was EMAIL and suspected
(but couldn't verify) that this table is meant to store e-mail addresses. Therefore,
the wizard added the annotation with a regular expression used to match e-mail
addresses. However, since it couldn't be sure that this table is indeed meant
to store e-mail addresses, it commented out this line of code. This property is
indeed meant to store e-mail addresses, therefore we should uncomment this
There are several annotations we can use in JPA entities to define relationships
between them. In the Customer entity we discussed, we can see that the wizard
detected several one-to-many relationships in the CUSTOMER table and automatically
added the @OneToMany annotation to define these relationships in our entity. Notice
that each field annotated with the @OneToMany annotation is of the type java.util.
Collection . The Customer entity is one side of the relationship, since a customer
can have many orders, many addresses (street, e-mail, and so on), or many telephone
numbers (home, work, cell, and so on). Notice that the wizard uses generics to
specify the type of objects we can add to each collection. Objects in these collections
are the JPA entities mapping to the corresponding tables in our database schema.