1 4 Annotating Persistence

8/6/2019 1 4 Annotating Persistence

http://slidepdf.com/reader/full/1-4-annotating-persistence 1/53

Annotating Persistence

Applications

Struts University Series

ApplicationsIn this session, we learn how to use

annotations to describe object

relationships and associations that theJPA cannot deduce on its own.

In the lab, we extend the User object to

include other properties, including a listof subscriptions.

ApplicationsWhat are annotations?

How do we declare properties?

How do we declare relationships?

How do we declare inheritance?

What are annotations?

Advanced mechanisms often need

different concerns to work together

Dynamic proxy may need a paired interfaceand implementation (Web Services)

JavaBeans may need a way to override

getter/setter conventions (BeanInfo)

Serialization may not need to serialize

everything (transient)

We may need to indicate that a member is

being retired (@deprecated)

Message Resources (*_es.properties)

Deployment descriptors (web.xml)

Workflow configuration (struts.xml)

Object validation (object-validator.xml)

Annotations are a Java 5 mechanism for

attaching metadata (gluecode) to a

member @Annotation(name=value) member

Available to Java as XDoclet for years

Available in C# for even longer JPA is annotation-enabled XML descriptor can override annotations

What are the JPA Annotations?

Entity

Locking

Identity

Composition

Database Schema

Attributes

Direct Mappings

Relationship

Mappings

Queries

Entity Manager

Inheritance

Lifecycle CallBack

Events

http://www.oracle.com/technology/products/ias/toplink/jpa/resources/toplink-jpa-annotations.html

Entity / Locking

@Entity @Version

Identity

@IdClass

@EmbeddedId@GeneratedValue

@SequenceGenerator

@TableGenerator

Database Schema Attributes

@Table

@SecondaryTable

@SecondaryTables@Column

@JoinColumn

@JoinColumns

@PrimaryKeyJoinColumn

@PrimaryKeyJoinColumns

@JoinTable

@UniqueConstraint

Direct Mappings

@Basic

@Enumerated

@Temporal@Lob

@Transient

Relationship Mappings

@OneToOne

@OneToMany

@ManyToOne@ManyToMany

@MapKey

@OrderBy

Queries

@NamedQuery

@NamedQueries

@NamedNativeQuery@NamedNativeQueries

@QueryHint

@ColumnResult

@EntityResult

@FieldResult

@SqlResultSetMapping

@SqlResultSetMappings

Composition

@Embeddable

@Embedded

@AttributeOverride@AttributeOverrides

@AssociationOverride

@AssociationOverrides

Inheritance

@Inheritance

@DiscriminatorColumn

@DiscriminatorValue@MappedSuperclass

@AssociationOverride

@AssociationOverrides

@AttributeOverride

@AttributeOverrides

Lifecycle Callback Events

@PrePersist

@PostPersist

@PreRemove@PostRemove

@PreUpdate

@PostUpdate

@PostLoad

@EntityListeners@ExcludeDefaultListeners

@ExcludeSuperclassListeners

Entity Manager

@PersistenceUnit

@PersistenceUnits

@PersistenceContext@PersistenceContexts

@PersistenceProperty

Entity

Column

GeneratedValue

Version

Transient

Entity

@Entity public class User implements Serializable {

@Entity is requiredMust be persisted by EntityManager

Serializable is recommended

Entity

@Entity(name=”USER”) public class UserImpl extends UuidEntity

implements User, Serializable {

Name attribute is used by queries (SELECT u FROM USER)Defaults to class name

Entity

@Entity public class User implements Serializable { @Id // field access private String id ; public String getId() { return id ; } public void setId(String value) { id = value; }}

Primary key (@Id) is required

Entity

@Entity public class User implements Serializable { private String id ; @Id // property access public String getId() { return id ; } public void setId(String value) { id = value; }}

Either fields or getters may be annotated But not both in the same class hierarchy!

@Entity(name="USER")@Table(name="APP_USER")

public class UserImpl extends UuidEntity implements Serializable, User {

name, catalog, schema, uniqueConstantsWorks well with Entity to isolate per database settings

Column

name, unique, nullable, insertable, updatable,columnDefinition, table, length, precision, scale

// ... public class User implements Serializable { @Column(length = 64) private String from_address;public String getFromAddress()

{return from_address;} // ...}

public class Message { @Id private Long id ;}

Use @Column to specify a different namePrimitive or wrapper type, String, Date (sql or util)

GeneratedValue

public class Message { @Id @GeneratedValue private Long id ;

// ...}

public class Message { @Id @GeneratedValue(GenerationType.SEQUENCE) private Long id ;

// ...

Used with @Id

.AUTO, IDENTITY, .SEQUENCE

Version

public class UuidEntity implements Serializable {

@Version private Timestamp last_update;

// ...}

int, Integer, short, Short, long, Long,Timestamp

Default annotation for unannotated fields or propertiesfetch, optional

FetchType = (EAGER, LAZY)

// ...@Basic(fetch=FetchType.LAZY )

private List<Subscription> subscriptions;// ...

Java primitive types, wrappers of the primitive types,String, BigInteger, BigDecimal, util.Date,

Calendar, sql.Date, Time, Timestamp, byte[],

Byte[], char[], Character[], enums, and any

other type that implements Serializable.

// ...@Basic(fetch=FetchType.LAZY )

private List<Subscription> subscriptions;// ...

Transient

@Entity public class User { @Transient private String password1 = null;// ...}

@Entity public class User implements Serializable {

private transient String password1 = null;// ...}

Transient members are not persisted

@OneToOne

@OneToMany

@ManyToOne

@NamedQuery

@NamedQueries

OneToOne

cascade, fetch, mappedBy, optional, targetEntity,

@Entity@Table(name = "APP_MESSAGE")

public class Message implements Serializable { @Id @GeneratedValue

private Long id; @OneToOne(cascade = CascadeType.ALL) private Message message;

// ...

OneToMany

cascade, fetch, mappedBy, targetEntity

// ... public class User implements Serializable {

@OneToMany(cascade = CascadeType.ALL)

private List<Subscription> subscriptions;

// ... public class UserImpl extends UuidEntity implements

@OneToMany(cascade = CascadeType.ALL, mappedBy=”user”, targetEntity=SubscriptionImpl.class) private List<Subscription> subscriptions;

OneToMany

public class UserImpl extends UuidEntity implements

Inverse side of the relationship

What's an “owner” or “inverse”

side of a relationship?Owner “persists” the relationship To change which instances are related,

which side (table) do we change? Terminology may seem counter-intuitive

What's an “owner” or “inverse”

side of a relationship?In 1:M or M:1, Many is always the owner. Change the key on the many side, change

the relationship, (Can't change the One, because the the One

side is usually a primary key!)

Important because application must keep

relationships synchronized with anychanges

OneToMany

Inverse side of the relationship

ManyToOne

// ... public class SubscriptionImpl extends UuidEntity

@JoinColumn(nullable = false) @ManyToOne(targetEntity = UserImpl.class) private User user;

Owner side of the relationship

NamedQuery

Name, query, queryHint[]

@Entity@NamedQuery(name = "User.COUNT",

query = "SELECT COUNT(*) FROM USER") public class User implements Serializable {

NamedQuery

Hints are provider-specific options or settings

cacheable, timeout, readOnly, comment

@Entity@NamedQuery(

name="findAllEmployees",query="SELECT * FROM EMPLOYEE WHERE MGR=1"

hints={@QueryHint(name=TopLinkQueryHints.REFRESH, value=HintValues.TRUE)

NamedQueries

@NamedQueries( {@NamedQuery(name = User.FIND_ALL,

query = UserImpl.FIND_ALL_QUERY ),@NamedQuery(name = User.FIND_BY_NAME ,

query = UserImpl.FIND_BY_NAME_QUERY ),@NamedQuery(name = User.COUNT ,

query = UserImpl.COUNT_QUERY )})

Resources

Toplink JPA Annotation Reference http://www.oracle.com/technology/products/ias/toplink/jpa/resources/toplink-jpa-annotations.html

/docs/jpa-docs/toplink-jpa-annotations.pdf

JPA Specification, Chapters 8 and 9 http://jcp.org/en/jsr/detail?id=220

/docs/jpa-docs/ejb3_0-fr-spec-persistence.pdf

The Java Persistence APIA Simpler Programming Model for Entity Persistence

http://java.sun.com/developer/technicalArticles/J2EE/jpa/

/docs/jpa-docs/j2ee-jpa.pdf

Struts University Series

1 4 Annotating Persistence

Documents

Annotating Search Results

Guidance Note for Annotating Commercial Agriculture and ......Guidance Note for Annotating Commercial Agriculture and Forestry Contracts February 2014 4 page numbers, so that page

Annotating Online Misogyny

Annotating Music and Lyrics

ANNOTATING MATERIAL. WHAT IS ANNOTATING? Annotating a text is a way to augment your understanding. It is a fairly pliable skill and therefore difficult

Annotating news paper and wesite

Annotating Digital Documents

Annotating and deconstructing contents page

-Annotating Full Document

Annotating 3D Content · Agenda 1. Motivation 2. Image-based Labeing of 3D Content 3. Enhanced Visibility Analysis 4. Smooth Transitions 5. Conclusions Annotating 3D Content in Interactive,

Annotating 2 Products

Annotating Posters

Annotating Population Pyramids

S3 Persistence Management User Guide · 2020. 12. 9. · Persistence Management 4 Using the Screens | S3 Persistence Management User Guide The persistence screens allow users to do

Annotating Java Bytecode

Annotating Doug Fisher Text to Deepen IV/How to Annotate.pdf · Annotating Text to Deepen Understanding ... “Reading with a pencil.” People have been annotating texts since there

Annotating Abstract Syntax Tree

Annotating Research Datasets

Active reading and annotating

Annotating the WordNet Glosses Ben Haskell. 2004/10/08 Annotating the Glosses Annotating open-class words with their WordNet sense tag (a.k.a. sense-tagging)