4

Uhm, I have a question regarding the @Basic(optional = false) and @NotNull notation.

Usually, we would write variables in entity class as below:

Mock-up code:

@Basic(optional = false)
@NotNull
@Column(name = USERNAME)
private String userName;

The notation above describes that for the field username , it would not accept a NULL value.

Usually, the @Basic(optional = false) notation is followed by @NotNull notation , but if I would like to have a field, let's say userID , and it is an Auto-Increment type , which is also the Primary Key , should I just wrote the code as below?

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = USERID)
private Integer userID;

Or remove the @Basic(optional = false) as well?

Edited

Latest code:

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = USERID)
private Integer userID;

One more question, is that only @Basic(optional = false) will work same as @Basic(optional = false) followed-up by @NotNull ?

Code shown as below:

Code 1

@Basic(optional = false)
@NotNull
@Column(name = USERNAME)
private String userName;

Code 2

@Basic(optional = false)
@Column(name = USERNAME)
private String userName;
MMM
  • 77
  • 1
  • 7

2 Answers2

6

no. @Id replaces @Basic - either use one or the other. @GeneratedValue can only accompany @Id.

@NotNull has nothing to do with JPA and you can place it wherever you want.

more info on NotNull vs Column annotations - as explained in this question, NotNull and Column annotation properties come from different places (bean validation vs persistence) and deal with different aspects of the object's lifecycle:

@NotNull is a bean validation annotation that specifies that the property must hold some value. hibernate MAY check this before persisting your entity into the database, if hibernate-validator integration is enabled in your setup, but may also completely ignore it. various other frameworks along the way (jax-rs implementations in your API layer etc) may also check your bean to validate that @NotNull holds. hibernate may also take notice of this annotation when generating the database schema and make the column not nullable, but its in no way required to do so.

@Column is a JPA annotation and deals only with how your property is mapped to the database. nothing else. you can make a column not nullable and still pass a null value to hibernate. it will result in a runtime exception from the database when hibernate will try to insert/update your data, but hibernate will not check it in advance.

Community
  • 1
  • 1
radai
  • 23,949
  • 10
  • 71
  • 115
  • thanks, i've edited the code above, and another question has added-in. hope can get feedback from you~ – MMM Aug 05 '14 at 04:57
  • @MMM - i've expanded my answer, and linked to a more detailed one – radai Aug 05 '14 at 05:06
  • oh, so the main different between them are one is checked in advance before persisting to database while another will return exception after persisting into database if errors occured? – MMM Aug 05 '14 at 05:21
  • @MMM - more like one is meant to be checked (at various places, among them is before insertion), and the other is meant to make the database column not nullable – radai Aug 05 '14 at 06:28
2

Even though Hibernate MAY completely ignore @NotNull associated to an the Entity class' member/property, we still might need to use it because :-

  • Since our Entity class instance will serve just as any other POJO (say before associated with persistent context), as per the business logic we might be sure that a particular property can never be null. To achieve this check we will need to use @NotNull
Siva
  • 21
  • 1