@JPA annotation in entity

JPA  In the agreement  Entity  Relevant provisions

Let's take a look first  JPA  What are the provisions about entities in the agreement .（ Here is a recommended view  JPA  The official address of the agreement ：

https://download.oracle.com/otn-pub/jcp/persistence-2_2-mrel-spec/JavaPersistence.pdf

）

• Entities are domain objects that directly perform database persistence operations （ That is, a simple  POJO, It can be divided according to business areas ）, Must pass  @Entity  Mark with notes .

• An entity must have a  public  perhaps  protected  The nonparametric construction method of .

• The annotation of persistent mapping can be marked in  Entity  Field of  field  On , As shown below ：

@Column(length = 20, nullable = false)

private String userName;


besides , Persistent annotations can also be applied to  Entity  Inside  get/set  On the way , Usually we put  get  In the method , As shown below ：

@Column(length = 20, nullable = false)

public String getUserName(){

 return userName;

}


Sum up , Namely  Entity  There are only two ways for the annotations inside to take effect ： Write comments on fields or methods （JPA  Inside scale  Property）.

however

It should be noted that , In the same  Entity  There can only be one way to take effect

, in other words , The notes are either all written in  field  above , Or write it all in  Property  above , Because I often see some colleagues annotate the two methods and then say ：“ Oh dear , Why didn't my annotation take effect ！” Therefore, this point needs special attention .

• As long as it's in the  @Entity  The fields annotated in the entity of , Will be mapped to the database , Besides using  @Transient  Outside the field of the annotation .

• There must be a primary key in the entity , The field marked by the primary key can be a single field , It can also be a composite primary key field .

Above, I only selected the most critical ones for introduction , If you are interested, you can read  Java Persistence API  agreement , So we're doing  JPA  It will be easy to develop , You can understand a lot  Hibernate  Inside the implementation method .

This also provides you with a way to solve difficult and miscellaneous diseases , That is, when we encounter problems that cannot be solved , Just look at the agreement 、 Read the official documents , Dig deeper , Maybe you'll find the answer . Then let's take a look at the common annotations in the examples .

What are the detailed notes ？

Let's look at the source code first  JPA  What are the supported annotations .

First , We make use of  IEDA  Tools , open  @Entity  The bag where it is , You can see that  JPA  What are the supported annotations . As shown below ：

We can see , stay  jakarta.persistence-api  There are probably more than 100 comments under the package path of , You can go here one by one when you are free , You can also go to  JPA  Check the document against the agreement .

I will only mention some of the most common , Include  @Entity、@Table、@Access、@Id、@GeneratedValue、@Enumerated、@Basic、@Column、@Transient、@Lob、@Temporal  etc. .

• @Entity
    The object used to define will become  JPA  Managed entities , Required , Map the field to the specified database table , It's simple to use , It can be directly used on entity classes , The syntax expressed through the source code is as follows ：

@Target(TYPE) // Indicates that this annotation can only be used in class above

public @interface Entity {

 // Optional , The default is the name of the entity class , The whole application is globally unique .

 String name() default "";

}


• @Table
    Used to specify the table name of the database , Represents the table name in the database corresponding to this entity , Not required , Default table name and  entity  Name the same .

@Target(TYPE) // The same can only be used on classes

public @interface Table {

 // Name of table , Optional . If not , The system considers the names of good entities as table names .

 String name() default "";

 // This table is located in schema, Optional

 String schema() default "";

 // Uniqueness constraint , Useful when creating tables , After the table is created, it is unnecessary .

 UniqueConstraint[] uniqueConstraints() default { };

 // Indexes , Use... When creating tables , After the table is created, it is unnecessary .

 Index[] indexes() default {};

}


• @Access
    Is used to specify the  entity  The annotation inside is written on the field , still  get/set  The method works above , Not required . If it is not filled in by default , When the first annotation in the entity appears on the field or  get/set  On the way , Take the first appearance as the standard ; in other words , Annotations in an entity are useful both in  field  above , Useful in  properties  When it's up , Look at the code below and you will understand .

@Id

private Long id;

@Column(length = 20, nullable = false)

public String getUserName(){

 return userName;

}


So because of  @Id  It is the first annotation in the entity , And act on fields , So all written in  get/set  The annotation above the method will be invalid . and  @Access  Default values can be overridden , The designation is in  fileds  The above takes effect in  properties  Effective above . Let's look at the syntax through the source code ：

@Target( { TYPE, METHOD, FIELD })// Indicates that this annotation can be applied to class On ( At this time, you can specify the default annotation effective policy of this entity ), It can also be used in methods or fields ( Indicates that the effective policy of a field or method can be set independently );

@Retention(RUNTIME)

public @interface Access {

// Specify whether fields or methods are effective

 AccessType value();

}

public enum AccessType {

 FIELD,

 PROPERTY

}


• @Id
    Define the attribute as the primary key of the database , An entity must have a primary key , But not necessarily this annotation , You can talk to  @GeneratedValue  Used together or in pairs .

• @GeneratedValue
    Primary key generation policy , As shown below ：

public @interface GeneratedValue {

 //Id Generation strategy for

 GenerationType strategy() default AUTO;

 // adopt Sequences Generate Id, Common is Orcale database ID Generate rules , At this time, we need to cooperate @SequenceGenerator Use

 String generator() default "";

}


among ,GenerationType  There are four values ：

public enum GenerationType {

 // Generate primary key through table , The framework generates the primary key from the table simulation sequence , Using this strategy can make the application easier to migrate .

 TABLE,

 // Generate primary key through sequence , adopt  @SequenceGenerator  The annotation specifies the sequence name , MySql  Not in favor of this way ;

 SEQUENCE,

 // Use database ID Self growth ,  Commonly used in mysql database

 IDENTITY,

//JPA  Automatically choose the right strategy , Is the default option ;

 AUTO

}


• @Enumerated
    This annotation is easy to use , Because it's good for  enum  Subscripts and  name  Two ways , Usage is directly mapped to  enum  Enumeration type field . Please see the source code below .

@Target({METHOD, FIELD}) // Act on methods and fields

public @interface Enumerated {

// Enumerate the types of mappings , The default is ORDINAL（ That is, the subscript of the enumeration field ）.

 EnumType value() default ORDINAL;

}

public enum EnumType {

 // Map the subscript of the enumeration field

 ORDINAL,

 // Mapping enumerations Name

 STRING

}


Let's see another one  User  There are examples of gender enumeration , You will know  @Enumerated  It's useless here , As shown below ：

// There is an enumeration class , Gender of user

public enum Gender {

 MAIL(" men "), FMAIL(" women ");

 private String value;

 private Gender(String value) {

 this.value = value;

 }

}

// Entity class @Enumerated Let's write it as follows

@Entity

@Table(name = "tb_user")

public class User implements Serializable {

 @Enumerated(EnumType.STRING)

 @Column(name = "user_gender")

 private Gender gender;

 .......................

}


At this time, insert two pieces of data , The value in the database will become  MAIL/FMAIL, instead of “ men ” /  women .

Experience sharing ：

   If we use  @Enumerated（EnumType.ORDINAL）, At this time, the value in the database is  0、1. But in practice , Numerical subscripts are not recommended , Because the attribute values in the enumeration will continue to be added , If you add a new one , If the position changes, it will be miserable . also  0、1、2  This kind of subscript looks very painful in the database , After a long time, you will not understand at all .

• @Basic
    Indicates that the attribute is a mapping to the field of the database table . If there is no annotation on the field of the entity , Default is  @Basic. That is to say, by default, all fields must be mapped to the database , And the default is  Eager  type .

public @interface Basic {

 // Optional ,EAGER（ Default ）： Immediately load ;LAZY： Delay loading .（LAZY It is mainly applied to large fields ）

 FetchType fetch() default EAGER;

 // Optional . Whether this field can be null, The default is true.

 boolean optional() default true;

}


• @Transient
    Indicates that the property is not a field mapping to a database table , Represents a non persistent property .JPA  Ignore it when mapping the database , And  @Basic  Has the opposite effect . That is, above each field  @Transient  and  @Basic  You have to choose between , If nothing is specified , The default is  @Basic.

• @Column
    Define the column name in the database corresponding to this attribute .

public @interface Column {

 // Column names of tables in the database ; Optional , If it is not filled in, it is considered that the field name is the same as the entity attribute name .

 String name() default "";

 // Is it unique? . Default flase, Optional .

 boolean unique() default false;

 // Whether the data field can be null . Optional , Default true.

 boolean nullable() default true;

 // perform insert Whether this field is included in the operation , Default ,true, Optional .

 boolean insertable() default true;

 // perform update Whether this field is included in the , Default ,true, Optional .

 boolean updatable() default true;

 // Represents the actual type of the field in the database .

 String columnDefinition() default "";

 // The length of the database field , Optional , Default 255

 int length() default 255;

}


• @Temporal
    Used to set  Date  The attribute of type is mapped to the field of corresponding precision , There are three situations ：

• @Temporal(TemporalType.DATE) Map to date  // date （
  Only the date
  ）

• @Temporal(TemporalType.TIME) Map to date  // time （
  Only time
  ）

• @Temporal(TemporalType.TIMESTAMP) Map to date  // date time （
  date + Time
  ）

Let's look at a complete example , Feel the full usage of the annotations mentioned above , as follows ：

package com.example.jpa.example1;

import lombok.Data;

import javax.persistence.*;

import java.util.Date;

@Entity

@Table(name = "user_topic")

@Access(AccessType.FIELD)

@Data

public class UserTopic {

 @Id

 @Column(name = "id", nullable = false)

 @GeneratedValue(strategy = GenerationType.IDENTITY)

 private Integer id;

 @Column(name = "title", nullable = true, length = 200)

 private String title;

 @Basic

 @Column(name = "create_user_id", nullable = true)

 private Integer createUserId;

 @Basic(fetch = FetchType.LAZY)

 @Column(name = "content", nullable = true, length = -1)

 @Lob

 private String content;

 @Basic(fetch = FetchType.LAZY)

 @Column(name = "image", nullable = true)

 @Lob

 private byte[] image;

 @Basic

 @Column(name = "create_time", nullable = true)

 @Temporal(TemporalType.TIMESTAMP)

 private Date createTime;

 @Basic

 @Column(name = "create_date", nullable = true)

 @Temporal(TemporalType.DATE)

 private Date createDate;

 @Enumerated(EnumType.STRING)

 @Column(name = "topic_type")

 private Type type;

 @Transient

 private String transientSimple;

 // Non database mapped fields , Field of business type

 public String getTransientSimple() {

 return title + "auto:jack" + type;

 }

 // There is an enumeration class , The type of topic

 public enum Type {

 EN(" english "), CN(" chinese ");

 private final String des;

 Type(String des) {

 this.des = des;

 }

 }

}


Careful students will find that , We were at the beginning of  demo  There are not so many annotations in it , In fact, many notes in this can be omitted , Just use the default . Such as  @Basic、@Column  Names have certain mapping strategies （ We are the first  17  Class will talk about  DataSource  The mapping strategy will be explained in detail when ）, So you can omit .

Besides ,@Access  You can omit it , We just need to keep consistent in these classes . Maybe you'll have questions , Do so many annotations have to be manually configured one by one ？ The teacher introduced a simple way —— Use tools to generate  Entity  class , It will save a lot of time .