Skip to main content

JPA

Java Persistance API

Entity Types

  • @OneToOne
    • One Entity related to one other
  • @OneToMany
    • One entity is related to many entities (List, Set, Map, SortedSet, SortedMap)
  • @ManyToOne
    • Inverse of OneToMany
  • @ManyToMany
    • Many entities are related to many entities
    • Each has a List or Set reference to the other
    • A join table is used to define relationships
  • Unidirectional - mapping is only done one way, one side does not know about relationship
  • Bidirectional - both entities know about each other (reccommended by hibernate)

The "Owning Side" of a relationship will hold the foreign key in the database.

Fetch Type

  • Lazy Fetch Type - Data is not queried until referenced
  • Eager Fetch Type - Data is queried up front
  • Hibernate 5 supports the JPA 2.1 Fetch Type Defaults:
    • OneToMany - Lazy
    • ManyToOne - Eager
    • ManyToMany - Lazy
    • OneToOne - Eager

Cascade Types

If I delete the parent will the child be deleted as well?

  • JPA Cascade Types control how state changes are cascaded from parent objects to child objects
  • JPA Cascade Types
    • PERSIST - Save operations will cascade to related entities
    • MERGE - related entities are merged when the owning entitiy is merged
    • REFRESH - related entities are refreshed when the owning entity is refreshed
    • REMOVE - removes all related entities when the owning entity is deleted
    • DETACH - detaches all related entities if a manual detach occurs
    • ALL - Applies all the above cascade options.

By default, no operations are cascaded

Embeddable Types

  • JPA/Hibernate support emeddable types
  • These are used to define a common set of properties
  • For example, a package with a shipping and billing address

Inheritance

  • MappedSuperclass - Entities inherit from a super class. A database table IS NOT created for the super class.
  • Single Table - (Hibernate Default) - One Table is used for all subclasses
    • This can lead to a lot of unused database columns
  • Joined Table - Base class and subclasses have their own tables.
    • Fetching subclass entities require a join to the table of the superclass. (could cause preformance issues)
  • Table Per Class - Each subclass has its own table.

Create and Update Timestamps

  • For audit purposes it is often a best practice to use timestamps
  • JPA supports @Prepersist and @PreUpdate which can be used to support audit timestamps via JPA lifecycle callbacks.
  • Hibernate provides @CreationTimestamp and @UpdateTimestamp
No Comments
Back to top