Shulou(Shulou.com)06/02 Report--

This article focuses on "what are the commonly used annotations in Spring Data JPA entity classes". Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Next let the editor to take you to learn what are the common annotations in the Spring Data JPA entity class!

Javax.persistence introduction

Spring Data JPA adopts the idea that convention is greater than configuration, and defaults to a lot of things.

JPA is the source of entities that store business entity associations. It shows how to define a common Java object (POJO) as an entity and how to provide a set of standards for managing relational entities.

Javax.persistence is in the hibernate-jpa-**.jar package.

The jpa class hierarchy:

Display unit of the JPA class hierarchy:

The unit describes EntityManagerFactory an EntityManager factory class, creates and manages multiple EntityManager instances EntityManager one interface, manages persistent operation objects, factory principles similar to factory query instances Entity entities are persistent objects, are records stored in the database EntityTransaction and EntityManager are one-to-one relationship, for each EntityManager operation is maintained by the EntityTransaction class Persistence this class contains static methods to obtain the EntityManagerFactory instance Query this interface is implemented by each JPA vendor Be able to obtain basic annotations of relational objects that meet the standard

@ Entity

The @ Entity definition object will become an entity managed by JPA and will be mapped to the specified database table

Public @ interface Entity {String name () default "";}

@ Table

@ Table specifies the table name of the database

Public @ interface Table {/ / the name of the table, optional. The default entity class name is the name of the table (hump naming rules) String name () default ""; / / the catlog of this table, String catalog () default ""; / / the schema of this table, String schema () default "" / / uniqueness constraint, which is only useful when creating a table. By default, UniqueConstraint [] uniqueConstraints () default {}; / / index is not required, only when creating a table, and Index [] indexes () default {};} is not required by default.

@ Id

Define the property as the primary key in the database, and an entity must have one

@ IdClass

@ IdClass leverages the federated primary key of the external class

Public @ interface IdClass {/ / the class Class value () of federated primary keys

As a federated primary key class, the following requirements need to be met

Serializable must be implemented

There must be a default public no-parameter construction method

The equals and hashCode methods must be overridden (EntityManager uses the find method to find Entity based on equals)

Usage:

(1) assume that the federated primary key in the user_ statement table is title and create_user_id, and the federated primary key class code is as follows:

@ Datapublic class UserArticleKey implements Serializable {private String title; private Long createUserId; public UserArticleKey () {} public UserArticleKey (String title, String content, Long createUserId) {this.title = title; this.createUserId = createUserId;}}

(2) the entity classes of user_article are as follows:

@ Entity@IdClass (value = UserArticleKey.class) @ Datapublic class UserArticle {private Integer id; @ Id private String title; @ Id private Long createUserId;}

(3) the repository classes are as follows:

Public interface ArticleRepository extends JpaRepository {}

(4) the calling code is as follows:

@ Testpublic void testUnionKey () {Optional userArticle = this.articleRepository.findById (new UserArticleKey ("News", 1L)); if (userArticle.isPresent ()) {System.out.println (userArticle.get ());}}

@ GenerateValue

Primary key generation strategy

The generation strategy of public @ interface GeneratedValue {/ / Id GenerationType strategy () default GenerationType.AUTO; / / generates Id through Sequence. Common Oracle generation rules need to be used with @ SequenceGenerator to use String generator () default ";}

GenerationType

Public enum GenerationType {/ / generate primary key through table, framework generate primary key from table simulation sequence (beneficial to database migration) TABLE, / / generate primary key through sequence, specify sequence name through @ SequenceGenerator annotation, do not support MySQL SEQUENCE, / / use data ID self-growth, generally used for MySQL IDENTITY, / / JPA automatic adaptation strategy, the default option AUTO; private GenerationType () {}}

@ Basic

Attribute is a mapping to the field of the data table, and the default is @ Basic when the field on the entity class is not annotated.

Public @ interface Basic {/ / optional. Default is immediate loading (EAGER), LZAY delayed loading (applied to large fields) FetchType fetch () default FetchType.EAGER; / / optional, set whether this field can be null, default true boolean optional () default true;}

@ Transient

Indicates that the attribute is not a mapping to the field of the database table, and represents a non-persistent attribute. Contrary to the effect of @ Basic, the field of the @ Transient tag is ignored when JPA is mapped.

@ Column

Define the column name in the database corresponding to the attribute

Public @ interface Column {/ / is the column name of the table in the statement library. The default field name is the same as the attribute name. You can choose String name () default "; / / whether it is unique, default false, optional boolean unique () default false; / / allow null, default true, optional boolean nullable () default true. / / whether this field is included when performing insert operations. Default true, optional boolean insertable () default true; / / whether to include this field when performing update operations, default true, optional boolean updatable () default true; / / the actual type of this field in the database String columnDefinition () default "" / / when mapping multiple tables, the field in which table is mapped. The default is String table () default "; / / the field length is valid int length () default 255 if the field type is VARCHAR; / / precision. When the field type is double, precision represents the total numeric length int precision () default 0. / / Precision. When the field type is double, scale represents the decimal place int scale () default 0;}

@ Temporal

Used to set the attribute of the Date type to map to the corresponding precision field

@ Temporal (Temporal.DATE) maps to a date

@ Temporal (Temporal.TIME) maps to a date (time only)

@ Temporal (Temporal.TIMESTAMP) maps to date (date + time)

@ Enumerated

Map fields of menu enumerated types

Source code:

Public @ interface Enumerated {/ / Mapping the type of enumeration EnumType value () default EnumType.ORDINAL;} public enum EnumType {/ / mapping the subscript ORDINAL of the enumeration field, / / mapping the enumeration name STRING;}

If you use ORDINAL, it will store 0meme1jin2 in the database, which is an index value, which is determined by the position of the element in enum, if the position of the element in enum is changed incorrectly.

It is very likely that it does not correspond to the data in the database. It is recommended to use STRING.

Usage:

@ Entity (name = "t_user") @ Data@Tablepublic class SystemUser implements Serializable {@ Id @ GeneratedValue (strategy = GenerationType.AUTO) private Long id; @ Basic private String uname; private String email; private String address; @ Enumerated (EnumType.STRING) @ Column (name = "user_gender") private Gender sex; public enum Gender {MALE ("male"), FEMALE ("female"); private String value Gender (String value) {this.value = value;}

@ Lob

Map to large object types supported by the database

Clob (Character Large Objects) types are long string types java.sql.Clob, Character [], char [] and String will be mapped to Clob types

Blob (Binary Large Objects) type is byte type, java.sql.Blob,Byte [], byte [], and types that implement the Serializable interface will be mapped to Blob types.

Clob and Blob take up a large amount of memory space, which is generally set to delayed loading with @ Basic (fetch=FetchType.LAZY).

@ NamedNativeQueries, @ NamedNativeQuerie, @ SqlResultSetMappings, @ SqlResultSetMapping, @ ColumnResult

These annotations are generally used together, and these configurations will not be customized in practice.

NamedNativeQueries ({@ NamedNativeQuery (name = "getUsers", query = "select id,title,create_user_id,create_date from user_article order by create_date desc", resultSetMapping = "userArticleMap")}) @ SqlResultSetMappings ({@ SqlResultSetMapping (name = "userArticleMap", entities = {}) Columns = {@ ColumnResult (name = "id"), @ ColumnResult (name = "title"), @ ColumnResult (name = "createUserId"), @ ColumnResult (name = "createDate") }) @ Entity@IdClass (value = UserArticleKey.class) @ Datapublic class UserArticle {@ Column private Integer id @ Id private String title; @ Id private Long createUserId; private Date createDate;} Association Annotation

@ JoinColumn defines the field name associated with the foreign key

It is mainly used with @ OneToOne, @ ManyToOne and @ OneToMany, but it doesn't make sense to use it alone.

@ JoinColumns defines the association of multiple fields

Public @ interface JoinColumn {/ / the field name of the target table. String name () default ""; / / the field name of this entity class, which is not required, defaults to this table ID String referencedColumnName () default ""; / / whether the foreign key field is unique, and whether the optional boolean unique () default false; / / foreign key field is allowed to be blank. Optional boolean nullable () default true. / / whether to add along with it, optional boolean insertable () default true; / / whether to update with it, optional boolean updatable () default true; / / SQL fragments used when generating DDL, optional String columnDefinition () default "; / / name of the table containing columns, optional String table () default" / / Foreign key constraint category. Default constraint behavior is ForeignKey foreignKey () default @ ForeignKey (ConstraintMode.PROVIDER_DEFAULT);}

@ OneToOne one-to-one relationship

Public @ interface OneToOne {/ / Relational target entity, default is void.class, optional Class targetEntity () default void.class; / / cascade operation policy, PERSIST (cascade add), REMOVE (cascade delete), REFRESH (cascade refresh), MERGE (cascade update), ALL (select all) / / default table will not have any impact on CascadeType [] cascade () default {} / / data acquisition method: EAGER (load immediately), LAZY (delay load) FetchType fetch () default EAGER; / / whether empty boolean optional () default true is allowed The value of / / mappedBy cannot be used with @ JoinColumn or @ JoinTable. The value of / / mappedBy refers to the field of the attribute in the entity of the other party, not the database field, nor the name of the object of the entity, that is, the field name String mappedBy () default of the attribute annotated by @ JoinColumn or @ JoinTable "by the other party." / / whether to cascade deletion, which is the same as CascadeType.REMOVE effect. Boolean orphanRemoval () default false;} can take effect if you configure one of them.

Usage:

@ OneToOne// name is the current entity corresponding to the field name in the database table / / referencedColumnName is the database field name @ JoinColumn corresponding to the field marked by @ Id in the SystemUser entity (name = "create_user_id", referencedColumnName = "id") private SystemUser createUser = new SystemUser ()

Two-way association:

OneToOne (mappedBy = "createUser") private UserArticle article = new UserArticle ()

Equivalent to mappedBy:

OneToOne@JoinColumn (name = "user_article_id", referencedColumnName = "id") private UserArticle article = new UserArticle ()

@ OneToMany and @ ManyToOne one-to-many and many-to-one relationships

OneToMany and ManyToOne can exist relatively or only one side

Public @ interface OneToMany {Class targetEntity () default void.class; / / cascade operation policy CascadeType [] cascade () default {}; / / data acquisition method FetchType fetch () default LAZY; / / who maintains the String mappedBy () default "; / / whether to cascade delete boolean orphanRemoval () default false;} public @ interface ManyToOne {Class targetEntity () default void.class / / cascading operation policy CascadeType [] cascade () default {}; / / whether the data acquisition method FetchType fetch () default LAZY; / / association is optional. If set, to be false, a non-null relationship must always exist. Boolean optional () default true;}

@ ManyToOne maps an entity object

@ Entity@Datapublic class UserArticle {@ Column private Integer id; @ Id private String title; @ ManyToOne (cascade = CascadeType.ALL,fetch = FetchType.EAGER) @ JoinColumn (name = "create_user_id", referencedColumnName = "id") private SystemUser systemUser = new SystemUser (); private Date createDate;}

@ OneToMany maps a list

@ Entity (name = "t_user") @ Data@Tablepublic class SystemUser implements Serializable {@ Id @ GeneratedValue (strategy = GenerationType.AUTO) private Long id; @ Basic private String uname; private String email; private String address; @ Enumerated (EnumType.STRING) private Gender sex;@OneToMany// name the associated field of the id// create_user_id target table of the current table @ JoinColumn (name = "id", referencedColumnName = "create_user_id") private List articleList = new ArrayList () Public enum Gender {MALE ("male"), FEMALE ("female"); private String value; Gender (String value) {this.value = value;}}

@ OrderBy sorts the associated query

Use with @ OneToMany

Public @ interface OrderBy {/ * the format of the fields to be sorted is as follows: * orderby_list::= orderby_item [, orderby_item] * * orderby_item::= [property_or_field_name] [ASC | DESC] * fields can be entity attributes or data fields. The default is ASC * / String value () default ";}

Usage:

@ OneToMany@JoinColumn (name = "id", referencedColumnName = "create_user_id") @ OrderBy ("createDate DESC") / / createDate is the entity attribute private List articleList = new ArrayList () of UserArticle

@ JoinTable Association relation Table

@ JoinTable is used in conjunction with @ ManyToMany when associating tables between objects.

Public @ interface JoinTable {/ / Intermediate relational table name String name () default "; / / catalog String catalog () default"of the table; / / schema String schema () default" of the table; / / fields of the main join table JoinColumn [] joinColumns () default {}; / / fields of the joined table JoinColumn [] inverseJoinColumns () default {} " / / Primary join foreign key constraint category ForeignKey foreignKey () default @ ForeignKey (PROVIDER_DEFAULT); / / connected foreign key constraint category ForeignKey inverseForeignKey () default @ ForeignKey (PROVIDER_DEFAULT); / / unique constraint UniqueConstraint [] uniqueConstraints () default {}; / / Index Index [] indexes () default {};}

Usage:

@ Entity// primary join table blogpublic class Blog {@ ManyToMany @ JoinTable (name = "blog_tag_relation", / / relational table name joinColumns = @ JoinColumn (name = "blog_id", referencedColumnName = "id"), / / main join table configuration inverseJoinColumns = @ JoinColumn (name = "tag_id") ReferencedColumnName = "id") / / configured by the join table) / / tag is the joined table private List tags = new ArrayList () }

About two-way many-to-many:

In two-way many-to-many entities that need to establish @ JoinTable, use mappedBy= "BlogTagRelation" to configure the @ ManyToMany in the joined table.

LeftJoin and Inner Join can improve query efficiency.

When using @ ManyToMany, @ ManyToOne, @ OneToMany, @ OneToOne associations, when SQL actually executes, it consists of a master table query and N sub-table queries.

It will cause Numb1 problems.

In order to improve the query efficiency simply, the problem of 1 SQL can be solved by using EntityGraph.

@ EntityGraph

@ EntityGraph and @ NamedEntityGraph are used to improve query efficiency (solving the problem of 1 SQL). Both of them need to be used together and neither of them is indispensable.

Entity class:

@ NamedEntityGraph (name = "Blog.tags", attributeNodes = {@ NamedAttributeNode ("tags")}) @ Entity// main join table blogpublic class Blog {@ ManyToMany @ JoinTable (name = "blog_tag_relation", / / relational table name joinColumns = @ JoinColumn (name = "blog_id", referencedColumnName = "id") / / main connection table configuration inverseJoinColumns = @ JoinColumn (name = "tag_id", referencedColumnName = "id") / / connected table configuration) / / tag is the connected table private List tags = new ArrayList () }

Repository:

Public interface BlogRepository extends JpaRepository {@ Override @ EntityGraph (value = "Blog.tags") List findAll ();} some notes on relational queries

All annotations are either configured on fields or on get methods. They cannot be mixed and cannot be started.

All associations support one-way association and two-way association. The use of two-way annotations in JSON serialization will result in an endless loop, which needs to be manually converted once or using @ JsonIgnore

In all related queries, tables generally do not need a resume foreign key index, and attention should be paid to the use of @ mappedBy

Cascading deletion is dangerous. It is recommended to consider it carefully or fully grasp it.

According to the configuration of different relationships, the meaning of name,referencedColumnName in @ JoinColumn is different.

When configuring these relationships, it is recommended to put the foreign key relationship resume directly on the table, and then generate it directly with the development tool, which can reduce the debugging time.

At this point, I believe you have a deeper understanding of "what are the common annotations in the Spring Data JPA entity class?" you might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.