This annotation is used when you want to mark a class as persistent. Specified on the class .

@Entity
public class MyClass
{
    ...
}

See the documentation for Class Mapping

This annotation is used when you want to mark a class as persistent but without a table of its own and being the superclass of the class that has a table, meaning that all of its fields are persisted into the table of its subclass. Specified on the class .

@MappedSuperclass
public class MyClass
{
    ...
}

See the documentation for Inheritance

This annotation is used when you want to mark a class as knowing about persistence but not persistent itself. That is, it manipulates the fields of a persistent class directly rather than using accessors. This is a DataNucleus extension . Specified on the class .

@PersistenceAware
public class MyClass
{
    ...
}

See the documentation for Class Mapping

This annotation is used when you want to mark a class as persistent and only storable embedded in another object. Specified on the class .

@Embeddable
public class MyClass
{
    ...
}

This annotation is used when you want to mark a class so that instance of that class can be cached. Specified on the class .

@Cacheable
public class MyClass
{
    ...
}

See the documentation for L2 Cache

This annotation is used to define the inheritance persistence for this class. Specified on the class .

@Entity
@Inheritance(strategy=InheritanceType.JOINED)
public class MyClass
{
    ...
}

See the documentation for Inheritance

This annotation is used to define the table where objects of a class will be stored. Specified on the class .

@Entity
@Table(name="MYTABLE", schema="PUBLIC")
public class MyClass
{
    ...
}

This annotation is used to define a secondary table where some fields of this class are stored in another table. Specified on the class .

@Entity
@Table(name="MYTABLE", schema="PUBLIC")
@SecondaryTable(name="MYOTHERTABLE", schema="PUBLIC", columns={@PrimaryKeyJoinColumn(name="MYCLASS_ID")})
public class MyClass
{
    ...
}

See the documentation for Secondary Tables

This annotation is used to define a primary-key class for the identity of this class. Specified on the class .

@Entity
@IdClass(org.datanucleus.samples.MyIdentity.class)
public class MyClass
{
    ...
}

See the documentation for Primary Keys

This DataNucleus-extension annotation is used to define that the class uses datastore-identity. Specified on the class .

@Entity
@DatastoreIdentity(column="MY_ID")
public class MyClass
{
    ...
}

This annotation is used to define a class or classes that are listeners for events from instances of this class. Specified on the class .

@Entity
@EntityListeners(org.datanucleus.MyListener.class)
public class MyClass
{
    ...
}

See the documentation for Lifecycle Callbacks

This annotation is used to define a series of named (JPQL) queries that can be used in this persistence unit. Specified on the class .

@Entity
@NamedQueries({
     @NamedQuery(name="AllPeople", 
                 query="SELECT p FROM Person p"),
     @NamedQuery(name="PeopleCalledJones", 
                 query="SELECT p FROM Person p WHERE p.surname = 'Jones'")})
public class Person
{
    ...
}

See the documentation for Named Queries

This annotation is used to define a named (JPQL) query that can be used in this persistence unit. Specified on the class .

@Entity
@NamedQuery(name="AllPeople", query="SELECT p FROM Person p")
public class Person
{
    ...
}

See the documentation for Named Queries

This annotation is used to define a series of named native (SQL) queries that can be used in this persistence unit. Specified on the class .

@Entity
@NamedNativeQueries({
     @NamedNativeQuery(name="AllPeople", 
                       query="SELECT * FROM PERSON WHERE SURNAME = 'Smith'"),
     @NamedNativeQuery(name="PeopleCalledJones",
                       query="SELECT * FROM PERSON WHERE SURNAME = 'Jones')})
public class Person
{
    ...
}

See the documentation for Named Queries

This annotation is used to define a named (SQL) query that can be used in this persistence unit. Specified on the class .

@Entity
@NamedNativeQuery(name="PeopleCalledSmith", query="SELECT * FROM PERSON WHERE SURNAME = 'Smith'")
public class Person
{
    ...
}

See the documentation for Named Queries

This annotation is used to define a series of result mappings for SQL queries that can be used in this persistence unit. Specified on the class .

@Entity
@SqlResultSetMappings({
    @SqlResultSetMapping(name="PEOPLE_PLUS_AGE",
        entities={@EntityResult(entityClass=Person.class)}, columns={@ColumnResult(name="AGE")}),
    @SqlResultSetMapping(name="FIRST_LAST_NAMES",
        columns={@ColumnResult(name="FIRSTNAME"), @ColumnResult(name="LASTNAME")})
    })
public class Person
{
    ...
}

This annotation is used to define a mapping for the results of an SQL query and can be used in this persistence unit. Specified on the class .

@Entity
@SqlResultSetMapping(name="PEOPLE_PLUS_AGE",
    entities={@EntityResult(entityClass=Person.class)}, columns={@ColumnResult(name="AGE")})
public class Person
{
    ...
}

This annotation is used to define a method that is a callback for pre-persist events. Specified on the method . It has no attributes.

@Entity
public class MyClass
{
    ...

    @PrePersist
    void registerObject()
    {
        ...
    }
}

See the documentation for Lifecycle Callbacks

This annotation is used to define a method that is a callback for post-persist events. Specified on the method . It has no attributes.

@Entity
public class MyClass
{
    ...

    @PostPersist
    void doSomething()
    {
        ...
    }
}

See the documentation for Lifecycle Callbacks

This annotation is used to define a method that is a callback for pre-remove events. Specified on the method . It has no attributes.

@Entity
public class MyClass
{
    ...

    @PreRemove
    void registerObject()
    {
        ...
    }
}

See the documentation for Lifecycle Callbacks

This annotation is used to define a method that is a callback for post-remove events. Specified on the method . It has no attributes.

@Entity
public class MyClass
{
    ...

    @PostRemove
    void doSomething()
    {
        ...
    }
}

See the documentation for Lifecycle Callbacks

This annotation is used to define a method that is a callback for pre-update events. Specified on the method . It has no attributes.

@Entity
public class MyClass
{
    ...

    @PreUpdate
    void registerObject()
    {
        ...
    }
}

See the documentation for Lifecycle Callbacks

This annotation is used to define a method that is a callback for post-update events. Specified on the method . It has no attributes.

@Entity
public class MyClass
{
    ...

    @PostUpdate
    void doSomething()
    {
        ...
    }
}

See the documentation for Lifecycle Callbacks

This annotation is used to define a method that is a callback for post-load events. Specified on the method . It has no attributes.

@Entity
public class MyClass
{
    ...

    @PostLoad
    void registerObject()
    {
        ...
    }
}

See the documentation for Lifecycle Callbacks

This annotation is used to define a generator using sequences in the datastore. It is scoped to the persistence unit. Specified on the class/field/method .

@Entity
@SequenceGenerator(name="MySeq", sequenceName="SEQ_2")
public class MyClass
{
    ...
}

This annotation is used to define a generator using a table in the datastore for storing the values. It is scoped to the persistence unit. Specified on the class/field/method .

@Entity
@TableGenerator(name="MySeq", table="MYAPP_IDENTITIES", pkColumnValue="MyClass")
public class MyClass
{
    ...
}

This annotation is used to define the discriminator column for a class. Specified on the class .

@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name="OBJECT_TYPE", discriminatorType=DiscriminatorType.STRING)
public class MyClass
{
    ...
}

See the documentation for Inheritance

This annotation is used to define the value to be stored in the discriminator column for a class (when used). Specified on the class .

@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name="OBJECT_TYPE", discriminatorType=DiscriminatorType.STRING)
@DiscriminatorValue("MyClass")
public class MyClass
{
    ...
}

See the documentation for Inheritance

This annotation is used to define the names of the primary key columns when this class has a superclass. Specified on the class .

@Entity
@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
@PrimaryKeyJoinColumns({@PrimaryKeyJoinColumn(name="PK_FIELD_1", referredColumnName="BASE_1_ID"),
                        @PrimaryKeyJoinColumn(name="PK_FIELD_2", referredColumnName="BASE_2_ID")})
public class MyClass
{
    ...
}

This annotation is used to define the name of the primary key column when this class has a superclass. Specified on the class .

@Entity
@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
@PrimaryKeyJoinColumn(name="PK_FIELD_1")
public class MyClass
{
    ...
}

This annotation is used to define a field of a superclass that has its column overridden. Specified on the class .

@Entity
@AttributeOverride(name="attr", column=@Column(name="NEW_NAME"))
public class MyClass extends MySuperClass
{
    ...
}

This annotation is used to define fields of a superclass that have their columns overridden. Specified on the class .

@Entity
@AttributeOverrides({@AttributeOverride(name="attr1", column=@Column(name="NEW_NAME_1")),
                     @AttributeOverride(name="attr2", column=@Column(name="NEW_NAME_2"))})
public class MyClass extends MySuperClass
{
    ...
}

This annotation is used to define a 1-1/N-1 field of a superclass that has its column overridden. Specified on the class .

@Entity
@AssociationOverride(name="friend", joinColumn=@JoinColumn(name="FRIEND_ID"))
public class Employee extends Person
{
    ...
}

This annotation is used to define 1-1/N-1 fields of a superclass that have their columns overridden. Specified on the class .

@Entity
@AssociationOverrides({@AssociationOverride(name="friend", joinColumn=@JoinColumn(name="FRIEND_ID")),
                       @AssociationOverride(name="teacher", joinColumn=@JoinColumn(name="TEACHER_ID"))})
public class Employee extends Person
{
    ...
}

This annotation is used to define a field to use for the identity of the class. Specified on the field/method .

@Entity
public class MyClass
{
    @Id
    long id;
    ...
}

This annotation is used to define a field as being embedded. Specified on the field/method .

@Entity
public class MyClass
{
    @Embedded
    Object myField;
    ...
}

This annotation is used to define a field to use for the identity of the class when embedded. Specified on the field/method .

@Entity
public class MyClass
{
    @EmbeddedId
    MyPrimaryKey pk;
    ...
}

This annotation is used to define a field as holding the version for the class. Specified on the field/method .

@Entity
public class MyClass
{
    @Id
    long id;

    @Version
    int ver;
    ...
}

This annotation is used to define a field of the class as persistent. Specified on the field/method .

@Entity
public class Person
{
    @Id
    long id;

    @Basic(optional=false)
    String forename;
    ...
}

See the documentation for Fields/Properties

This annotation is used to define a field of the class as not persistent. Specified on the field/method .

@Entity
public class Person
{
    @Id
    long id;

    @Transient
    String personalInformation;
    ...
}

See the documentation for Fields/Properties

This annotation is used to define that a collection/map is stored using a join table. Specified on the field/method .

@Entity
public class Person
{
    @OneToMany
    @JoinTable(name="PEOPLES_FRIENDS")
    Collection friends;
    ...
}

This annotation is used to define that a collection/map of non-entities is stored using a join table. This is new from JPA2 Specified on the field/method .

@Entity
public class Person
{
    @ElementCollection
    @CollectionTable(name="PEOPLES_FRIENDS")
    Collection<String> values;
    ...
}

This annotation is used to define that a field will be stored using a large object in the datastore. Specified on the field/method .

@Entity
public class Person
{
    @Lob
    byte[] photo;
    ...
}

This annotation is used to define that a field is stored as a temporal type. Specified on the field/method .

@Entity
public class Person
{
    @Temporal(TemporalType.TIMESTAMP)
    java.util.Date dateOfBirth;
    ...
}

This annotation is used to define that a field is stored enumerated (not that it wasnt obvious from the type!). Specified on the field/method .

enum Gender {MALE, FEMALE};

@Entity
public class Person
{
    @Enumerated
    Gender gender;
    ...
}

This annotation is used to define that a field represents a 1-1 relation. Specified on the field/method .

@Entity
public class Person
{
    @OneToOne
    Person bestFriend;
    ...
}

See the documentation for 1-1 Relations

This annotation is used to define that a field represents a 1-N relation. Specified on the field/method .

@Entity
public class Person
{
    @OneToMany
    Collection<Person> friends;
    ...
}

See the documentation for 1-N Relations

This annotation is used to define that a field represents a M-N relation. Specified on the field/method .

@Entity
public class Customer
{
    @ManyToMany(mappedBy="customers")
    Collection<Supplier> suppliers;
    ...
}

@Entity
public class Supplier
{
    @ManyToMany
    Collection<Customer> customers;
    ...
}

See the documentation for M-N Relations

This annotation is used to define that a field represents a N-1 relation. Specified on the field/method .

@Entity
public class House
{
    @OneToMany(mappedBy="house")
    Collection<Window> windows;
    ...
}

@Entity
public class Window
{
    @ManyToOne
    House house;
    ...
}

See the documentation for N-1 Relations

This annotation is used to define that a field represents a 1-N relation to non-entity objects. This is new from JPA2 Specified on the field/method .

@Entity
public class Person
{
    @ElementCollection
    Collection<String> values;
    ...
}

This annotation is used to define the generation of a value for a (PK) field. Specified on the field/method .

@Entity
public class Person
{
    @Id
    @GeneratedValue(strategy=GenerationType.TABLE)
    long id;
    ...
}

This annotation is used to define the field in the value class that represents the key in a Map. Specified on the field/method .

@Entity
public class Person
{
    @OneToMany
    @MapKey(name="nickname")
    Map<String, Person> friends;
    ...
}

This annotation is used to define a field in the element class that is used for ordering the elements of the List when it is retrieved. Specified on the field/method .

@Entity
public class Person
{
    @OneToMany
    @OrderBy(value="nickname")
    List<Person> friends;
    ...
}

This annotation is used to definethat the JPA implementation will handle the ordering of the List elements using a surrogate column. Specified on the field/method .

@Entity
public class Person
{
    @OneToMany
    @OrderColumn
    List<Person> friends;
    ...
}

This annotation is used to define the column where a field is stored. Specified on the field/method .

@Entity
public class Person
{
    @Basic
    @Column(name="SURNAME", length=100, nullable=false)
    String surname;
    ...
}

This annotation is used to define the FK column for joining to another table. This is part of a 1-1, 1-N, or N-1 relation. Specified on the field/method .

@Entity
public class Person
{
    @OneToOne
    @JoinColumn(name="PET_ID", nullable=true)
    Animal pet;
    ...
}

This annotation is used to define the FK columns for joining to another table. This is part of a 1-1, 1-N, or N-1 relation. Specified on the field/method .

@Entity
public class Person
{
    @OneToOne
    @JoinColumns({@JoinColumn(name="PET1_ID"), @JoinColumn(name="PET2_ID")})
    Animal pet; // composite PK
    ...
}

This annotation is used to define a unique constraint to apply to a table. It is specified as part of @Table, @JoinTable or @SecondaryTable.

@Entity
@Table(name="PERSON", uniqueConstraints={@UniqueConstraint(columnNames={"firstName","lastName"})})
public class Person
{
    @Basic
    String firstName;

    @Basic
    String lastName;
    ...
}

See the documentation for Schema Constraints

DataNucleus Extension Annotation used to define a set of extensions specific to DataNucleus. Specified on the class or field .

@Entity
@Extensions({@Extension(key="firstExtension", value="myValue"),
             @Extension(key="secondExtension", value="myValue")})
public class Person
{
    ...
}

DataNucleus Extension Annotation used to define an extension specific to DataNucleus. Specified on the class or field .

@Entity
@Extension(key="RunFast", value="true")
public class Person
{
    ...
}