All Hibernate Annotations: Mapping Annotations
If you make use of Hibernate, then this exhaustive reference of hibernate annotations will come in handy.
Join the DZone community and get the full member experience.
Join For FreeThis article provides a quick overview of all Hibernate mapping annotations. These Hibernate mapping annotations are from the Hibernate official user guide.
Also, check out JPA Mapping Annotations
Check out Hibernate Developer Guide and Spring Hibernate Tutorials to develop J2EE enterprise applications.
Hibernate Mapping Annotations
I list all the Hibernate mapping annotations for your quick reference :
@AccessType
@Any
@AnyMetaDef
@AnyMetaDefs
@AttributeAccessor
@BatchSize
@Cache
@Cascade
@Check
@CollectionId
@CollectionType
@ColumnDefault
@Columns
@ColumnTransformer
@ColumnTransformers
@CreationTimestamp
@DiscriminatorFormula
@DiscriminatorOptions
@DynamicInsert
@DynamicUpdate
@Entity @Fetch
@FetchProfile
@FetchProfile.FetchOverride
@FetchProfiles
@Filter
@FilterDef
@FilterDefs
@FilterJoinTable
@FilterJoinTables
@Filters
@ForeignKey
@Formula
@Generated
@GeneratorType
@GenericGenerator
@GenericGenerators
@Immutable
@Index
@IndexColumn
@JoinColumnOrFormula
@JoinColumnsOrFormulas
@JoinFormula
@LazyCollection
@LazyGroup
@LazyToOne
@ListIndexBase
@Loader
@ManyToAny
@MapKeyType
@MetaValue
@NamedNativeQueries
@NamedQueries
@NamedQuery
@Nationalized
@NaturalId
@NaturalIdCache
@NotFound
@OnDelete
@OptimisticLock
@OptimisticLocking
@OrderBy
@ParamDef
@Parameter
@Parent
@Persister
@Polymorphism
@Proxy
@RowId
@SelectBeforeUpdate
@Sort
@SortComparator
@SortNatural
@Source
@SQLDelete
@SQLDeleteAll
@SqlFragmentAlias
@SQLInsert
@SQLUpdate
@Subselect
@Synchronize
@Table
@Tables
@Target
@Tuplizer
@Tuplizers
@Type
@TypeDef
@TypeDefs
@UpdateTimestamp
@ValueGenerationType
@Where
@WhereJoinTable
@AccessType
The @AccessType annotation is deprecated. You should use either the JPA @Access or the Hibernate native @AttributeAccessor annotation.
@Any
The @Any annotation is used to define the any-to-one association, which can point to one of several entity types.
Read more about this annotation at @Any mapping official documentation.
@AnyMetaDef
The @AnyMetaDef annotation is used to provide metadata about an @Any or @ManyToAny mapping.
Read more about this annotation at @Any mapping official documentation.
@AnyMetaDefs
The @AnyMetaDefs annotation is used to group multiple @AnyMetaDef annotations.
@AttributeAccessor
The @AttributeAccessor annotation is used to specify a custom PropertyAccessStrategy. This should only be used to name a custom PropertyAccessStrategy. For property/field access type, the JPA@Access annotation should be preferred.
@BatchSize
The @BatchSize annotation is used to specify the size for batch loading the entries of a lazy collection.
Read more about this annotation at the Batch fetching official documentation.
@Cache
The @Cache annotation is used to specify the CacheConcurrencyStrategy of a root entity or a collection.
Read more about this annotation at Cachingofficial documentation.
@Cascade
The @Cascade annotation is used to apply the Hibernate specific CascadeType strategies (e.g. CascadeType.LOCK, CascadeType.SAVE_UPDATE, CascadeType.REPLICATE) on a given association.
For JPA cascading, I prefer using the javax.persistence.CascadeType instead. When combining both JPA and Hibernate CascadeType strategies, Hibernate will merge both sets of cascades.
Read more about this annotation at Cascading official documentation.
@Check
The @Check annotation is used to specify an arbitrary SQL CHECK constraint which can be defined at the class level.
Read more about this annotation at Database-level checks official documentation.
@CollectionId
The @CollectionId annotation is used to specify an identifier column for an idbag collection.
You might want to use the JPA@OrderColumn instead.
@CollectionType
The @CollectionType annotation is used to specify a custom collection type.
The collection can also name a @Type, which defines the Hibernate Type of the collection elements.
Read more about this annotation at Custom collection types official documentation.
@ColumnDefault
The @ColumnDefault annotation is used to specify the DEFAULT DDL value to apply when using the automated schema generator.
The same behavior can be achieved using the definition attribute of the JPA @Column annotation.
Read more about this annotation at Default value for a database column official documentation.
@Columns
The @Columns annotation is used to group multiple JPA @Column annotations.
Read more about this annotation at @Columns mapping official documentation.
@ColumnTransformer
The @ColumnTransformer annotation is used to customize how a given column value is read from or write into the database.
Read more about this annotation at @ColumnTransformer mapping official documentation.
@ColumnTransformers
The @ColumnTransformers annotation is used to group multiple @ColumnTransformer annotations.
@CreationTimestamp
The @CreationTimestamp annotation is used to specify that the currently annotated temporal type must be initialized with the current JVM timestamp value.
Read more about this annotation at @CreationTimestamp mapping official documentation.
@DiscriminatorFormula
The @DiscriminatorFormula annotation is used to specify a Hibernate @Formula to resolve the inheritance discriminator value.
Read more about this annotation at @DiscriminatorFormula official documentation.
@DiscriminatorOptions
The @DiscriminatorOptions annotation is used to provide the force and insert Discriminator properties.
Read more about this annotation at Discriminator official documentation.
@DynamicInsert
The @DynamicInsert annotation is used to specify that the INSERT SQL statement should be generated whenever an entity is to be persisted.
By default, Hibernate uses a cached INSERT statement that sets all table columns. When the entity is annotated with the @DynamicInsert annotation, the PreparedStatement is going to include only the non-null columns.
Read more about this annotation at @CreationTimestamp mapping official documentation.
@DynamicUpdate
The @DynamicUpdate annotation is used to specify that the UPDATE SQL statement should be generated whenever an entity is modified.
By default, Hibernate uses a cached UPDATE statement that sets all table columns. When the entity is annotated with the @DynamicUpdate annotation, the PreparedStatement is going to include only the columns whose values have been changed.
Read more about this annotation at @DynamicUpdate official documentation.
@Entity
The @Entity annotation is deprecated. Use the JPA @Entity annotation instead.
@Fetch
The @Fetch annotation is used to specify the Hibernate specific FetchMode (e.g. JOIN, SELECT, SUBSELECT) used for the currently annotated association:
Read more about this annotation at @Fetch mapping official documentation.
@FetchProfile
The @FetchProfile annotation is used to specify a custom fetching profile, similar to a JPA Entity Graph.
Read more about this annotation at Fetch mapping official documentation.
@FetchProfile.FetchOverride
The @FetchProfile.FetchOverride annotation is used in conjunction with the @FetchProfile annotation, and it's used for overriding the fetching strategy of a particular entity association.
Read more about this annotation at Fetch profile official documentation.
@FetchProfiles
The @FetchProfiles annotation is used to group multiple @FetchProfile annotations.
@Filter
The @Filter annotation is used to add filters to an entity or the target entity of a collection.
Read more about this annotation at Filter mapping official documentation.
@FilterDef
The @FilterDef annotation is used to specify a @Filter definition (name, default condition and parameter types, if any).
Read more about this annotation at Filter mapping official documentation.
@FilterDefs
The @FilterDefs annotation is used to group multiple @FilterDef annotations.
@FilterJoinTable
The @FilterJoinTable annotation is used to add @Filter capabilities to a join table collection.
Read more about this annotation at FilterJoinTable mapping official documentation.
@FilterJoinTables
The @FilterJoinTables annotation is used to group multiple @FilterJoinTable annotations.
@Filters
The @Filters annotation is used to group multiple @Filter annotations.
@ForeignKey
The @ForeignKey annotation is deprecated. Use the JPA 2.1 @ForeignKey annotation instead.
@Formula
The @Formula annotation is used to specify an SQL fragment that is executed in order to populate a given entity attribute.
Read more about this annotation at @Formula mapping official documentation.
@Generated
The @Generated annotation is used to specify that the currently annotated entity attribute is generated by the database.
Read more about this annotation at @Generated mapping official documentation.
@GeneratorType
The @GeneratorType annotation is used to provide a ValueGenerator and a GenerationTime for the currently annotated generated attribute.
Read more about this annotation at @GeneratorType mapping official documentation.
@GenericGenerator
The @GenericGenerator annotation can be used to configure any Hibernate identifier generator.
Read more about this annotation at @GenericGenerator mapping official documentation.
@GenericGenerators
The @GenericGenerators annotation is used to group multiple @GenericGenerator annotations.
@Immutable
The@Immutable annotation is used to specify that the annotated entity, attribute, or collection is immutable.
Read more about this annotation at @Immutable mapping official documentation.
@Index
The @Index annotation is deprecated. Use the JPA @Index annotation instead.
@IndexColumn
The @IndexColumn annotation is deprecated. Use the JPA @OrderColumn annotation instead.
@JoinColumnOrFormula
The @JoinColumnOrFormula annotation is used to specify that the entity association is resolved either through a FOREIGN KEY join (e.g. @JoinColumn) or using the result of a given SQL formula (e.g. @JoinFormula).
Read more about this annotation at @JoinColumnOrFormula mapping section for more info.
@JoinColumnsOrFormulas
The @JoinColumnsOrFormulas annotation is used to group multiple @JoinColumnOrFormula annotations.
@JoinFormula
The @JoinFormula annotation is used as a replacement for @JoinColumn when the association does not have a dedicated FOREIGN KEY column.
Read more about this annotation at @JoinFormula mapping official documentation.
@LazyCollection
The @LazyCollection annotation is used to specify the lazy fetching behavior of a given collection.
The TRUE and FALSE values are deprecated since you should be using the JPA FetchType attribute of the @ElementCollection, @OneToMany, or @ManyToMany collection.
Read more about this annotation at @LazyCollection mapping official documentation.
@LazyGroup
The @LazyGroup annotation is used to specify that an entity attribute should be fetched along with all the other attributes belonging to the same group.
To load entity attributes lazily, bytecode enhancement is needed. By default, all non-collection attributes are loaded in one group named "DEFAULT."
This annotation allows defining different groups of attributes to be initialized together when access one attribute in the group.
Read more about this annotation at @LazyGroup mapping official documentation.
@LazyToOne
The @LazyToOne annotation is used to specify the laziness options, represented by LazyToOneOption, available for a @OneToOne or @ManyToOne association.
Read more about this annotation at @LazyToOne mapping example section for more info.
@ListIndexBase
The @ListIndexBase annotation is used to specify the start value for a list index, as stored in the database.
By default, List indexes are stored starting at zero. This is generally used in conjunction with @OrderColumn.
Read more about this annotation at @ListIndexBase mapping official documentation.
@Loader
The @Loader annotation is used to override the default SELECT query used for loading an entity loading.
Read more about this annotation at Custom CRUD mapping official documentation.
@ManyToAny
The @ManyToAny annotation is used to specify a many-to-one association when the target type is dynamically resolved.
Read more about this annotation at @ManyToAny mapping official documentation.
@MapKeyType
The @MapKeyType annotation is used to specify the map key type.
Read more about this annotation at @MapKeyType mapping section for more info.
@MetaValue
The @MetaValue annotation is used by the @AnyMetaDef annotation to specify the association between a given discriminator value and an entity type.
Read more about this annotation at @Any mapping official documentation.
@NamedNativeQueries
The @NamedNativeQuery annotation extends the JPA @NamedNativeQuery with Hibernate specific features.
Read more about this annotation at Hibernate @NamedNativeQuery section for more info.
@NamedQueries
The @NamedQueries annotation is used to group multiple @NamedQuery annotations.
@NamedQuery
The @NamedQuery annotation extends the JPA @NamedQuery with Hibernate specific features.
Read more about this annotation at @NamedQuery official documentation.
@Nationalized
The @Nationalized annotation is used to specify that the currently annotated attribute is a character type (e.g. String, Character, Clob) that is stored in a nationalized column type (NVARCHAR, NCHAR, NCLOB).
Read more about this annotation at @Nationalized mapping official documentation.
@NaturalId
The @NaturalId annotation is used to specify that the currently annotated attribute is part of the natural id of the entity.
Read more about this annotation at Natural Ids official documentation.
@NaturalIdCache
The @NaturalIdCache annotation is used to specify that the natural id values associated with the annotated entity should be stored in the second-level cache.
Read more about this annotation at @NaturalIdCache mapping official documentation.
@NotFound
The @NotFound annotation is used to specify the NotFoundAction strategy for when an element is not found in a given association.
Read more about this annotation at @NotFound mapping official documentation.
@OnDelete
The @OnDelete annotation is used to specify the delete strategy employed by the currently annotated collection, array, or joined subclasses. This annotation is used by the automated schema generation tool to generate the appropriate FOREIGN KEY DDL cascade directive.
Read more about this annotation at @OnDelete cascade official documentation.
@OptimisticLock
The @OptimisticLock annotation is used to specify if the currently annotated attribute will trigger an entity version increment upon being modified.
Read more about this annotation at Excluding attributes official documentation.
@OptimisticLocking
The @OptimisticLocking annotation is used to specify the currently annotated an entity optimistic locking strategy.
Read more about this annotation at Versionless optimistic locking official documentation.
@OrderBy
The @OrderBy annotation is used to specify a SQL ordering directive for sorting the currently annotated collection.
It differs from the JPA @OrderBy annotation because the JPA annotation expects a JPQL order-by fragment, not an SQL directive.
Read more about this annotation at @OrderBy mapping official documentation.
@ParamDef
The @ParamDef annotation is used in conjunction with @FilterDef so that the Hibernate Filter can be customized with runtime-provided parameter values.
Read more about this annotation at Filter mapping official documentation.
@Parameter
The @Parameter annotation is a generic parameter (basically a key/value combination) used to parametrize other annotations, like @CollectionType, @GenericGenerator, @Type, and @TypeDef.
@Parent
The @Parent annotation is used to specify that the currently annotated embeddable attribute references back the owning entity.
Read more about this annotation at @Parent mapping official documentation.
@Persister
The @Persister annotation is used to specify a custom entity or collection persister.
For entities, the custom persister must implement the EntityPersister interface.
For collections, the custom persister must implement the CollectionPersister interface.
Read more about this annotation at @Persister mapping official documentation.
@Polymorphism
The @Polymorphism annotation is used to define the PolymorphismType Hibernate will apply to entity hierarchies.
Read more about this annotation at @Polymorphism.
@Proxy
The @Proxy annotation is used to specify a custom proxy implementation for the currently annotated entity.
Read more about this annotation at @Proxy mappingofficial documentation.
@RowId
The @RowId annotation is used to specify the database column used as a ROWID pseudocolumn. For instance, Oracle defines the ROWID pseudocolumn as something that provides the address of every table row.
Read more about this annotation at @RowId mapping official documentation.
@SelectBeforeUpdate
The @SelectBeforeUpdate annotation is used to specify that the currently annotated entity state be selected from the database when determining whether to perform an update when the detached entity is reattached.
See the OptimisticLockType.DIRTY mapping official documentation
@Sort
The @Sort annotation is deprecated. Use the Hibernate specific @SortComparator or @SortNatural annotations instead.
@SortComparator
The @SortComparator annotation is used to specify a Comparator for sorting the Set/Map in-memory.
Read more about this annotation at @SortComparator mapping official documentation
@SortNatural
The @SortNatural annotation is used to specify that the Set/Map should be sorted using natural sorting.
Read more about this annotation at @SortNatural mapping official documentation
@Source
The @Source annotation is used in conjunction with a @Version timestamp entity attribute indicating the SourceType of the timestamp value.
Read more about this annotation at Database-generated version timestamp mapping official documentation
@SQLDelete
The @SQLDelete annotation is used to specify a custom SQL DELETE statement for the currently annotated entity or collection.
See the Custom CRUD mapping official documentation.
@SQLDeleteAll
The @SQLDeleteAll annotation is used to specify a custom SQL DELETE statement when removing all elements of the currently annotated collection.
Read more about this annotation at Custom CRUD mapping official documentation.
@SqlFragmentAlias
The @SqlFragmentAlias annotation is used to specify an alias for a Hibernate @Filter.
The alias (e.g. myAlias) can then be used in the @Filter condition clause using the {alias} (e.g. {myAlias}) placeholder.
Read more about this annotation at @SqlFragmentAlias mapping official documentation.
@SQLInsert
The @SQLInsert annotation is used to specify a custom SQL INSERT statement for the currently annotated entity or collection.
Read more about this annotation at Custom CRUD mapping official documentation.
@SQLUpdate
The @SQLUpdate annotation is used to specify a custom SQL UPDATE statement for the currently annotated entity or collection.
Read more about this annotation at Custom CRUD mapping official documentation.
@Subselect
The @Subselect annotation is used to specify an immutable and read-only entity using a custom SQL SELECT statement.
Read more about this annotation at Mapping the entity to a SQL query official documentation.
@Synchronize
The @Synchronize annotation is usually used in conjunction with the @Subselect annotation to specify the list of database tables used by the @Subselect SQL query.
Read more about this annotation at Mapping the entity to a SQL query official documentation.
@Table
The @Table annotation is used to specify additional information to a JPA @Table annotation, like custom INSERT, UPDATE or DELETE statements or a specific FetchMode.
Read more about this annotation at @SecondaryTable mapping official documentation.
@Tables
The @Tables annotation is used to group multiple @Table annotations.
@Target
The @Target annotation is used to specify an explicit target implementation when the currently annotated association is using an interface type.
Read more about this annotation at @Target mapping official documentation.
@Tuplizer
The @Tuplizer annotation is used to specify a custom tuplizer for the currently annotated entity or embeddable.
Read more about this annotation at @Tuplizer mapping section for more info.
@Tuplizers
The @Tuplizers annotation is used to group multiple @Tuplizer annotations.
@Type
The @Type annotation is used to specify the Hibernate @Type used by the currently annotated basic attribute.
See the @Type mapping section for more info.
@TypeDef
The @TypeDef annotation is used to specify a @Type definition, which can later be reused for multiple basic attribute mappings.
Read more about this annotation at @TypeDef mapping offiial documentation.
@TypeDefs
The @TypeDefs annotation is used to group multiple @TypeDef annotations.
@UpdateTimestamp
The @UpdateTimestamp annotation is used to specify that the currently annotated timestamp attribute should be updated with the current JVM timestamp whenever the owning entity gets modified.
See the @UpdateTimestamp mapping official documentation.
@ValueGenerationType
The @ValueGenerationType annotation is used to specify that the current annotation type should be used as a generator annotation type.
Read more about this annotation at @ValueGenerationType mapping section for more info.
@Where
The @Where annotation is used to specify a custom SQL WHERE clause used when fetching an entity or a collection.
Read more about this annotation at @Where mapping official documentation.
@WhereJoinTable
The @WhereJoinTable annotation is used to specify a custom SQL WHERE clause used when fetching a join collection table.
Further Learning
Published at DZone with permission of Ramesh Fadatare. See the original article here.
Opinions expressed by DZone contributors are their own.
Comments