One of the things that JDK 1.5 provides that can be of some use is annotations, and JDO provides its own set. When selecting to use annotations please bear in mind the following :

• You must have the jdo-api jar in your CLASSPATH since this provides the annotations
• Annotations should really only be used for attributes of persistence that you won’t be changing at deployment. Things such as table and column names shouldn’t really be specified using annotations although it is permitted. Instead it would be better to put such information in an ORM MetaData file.
• Annotations can be added in two places – for the class as a whole, or for a field in particular.
• You can annotate fields or getters with field-level information. If you annotate fields then the fields are processed for persistence. If you annotate the methods (getters) then the methods (properties) are processed for persistence.
• Annotations are prefixed by the @ symbol and can take properties (in brackets after the name, comma-separated)

@PersistenceCapable

This annotation is used when you want to mark a class as persistent. It equates to the <class> MetaData element (though with only some of its attributes). Specified on the class.

@PersistenceCapable(identityType=IdentityType.APPLICATION)
public class MyClass
{
...
}

@PersistenceAware

This annotation is used when you want to mark a class as being used in persistence but not being persistable. That is “persistence-aware” in JDO terminology. It has no attributes. Specified on the class.

@PersistenceAware
public class MyClass
{
...
}

See the documentation for Class Types

@Cacheable

This annotation is a shortcut for @PersistenceCapable(cacheable={value}) specifying whether the class can be cached in a Level 2 cache. Specified on the class. The default

@Cacheable("false")
public class MyClass
{
...
}

@EmbeddedOnly

This annotation is a shortcut for @PersistenceCapable(embeddedOnly=”true”) meaning that the class can only be persisted embedded into another class. It has no attributes. Specified on the class.

@EmbeddedOnly
public class MyClass
{
...
}

@Inheritance

Annotation used to define the inheritance for a class. Specified on the class.

@PersistenceCapable
@Inheritance(strategy=InheritanceStrategy.NEW_TABLE)
public class MyClass
{
...
}

@Discriminator

Annotation used to define a discriminator to be stored with instances of this class and is used to determine the types of the objects being stored. Specified on the class.

@PersistenceCapable
@Inheritance(strategy=InheritanceStrategy.NEW_TABLE)
@Discriminator(strategy=DiscriminatorStrategy.CLASS_NAME)
public class MyClass
{
...
}

@DatastoreIdentity

Annotation used to define the identity when using datastore-identity for the class. Specified on the class.

@PersistenceCapable
@DatastoreIdentity(strategy=IdGeneratorStrategy.INCREMENT)
public class MyClass
{
...
}

@Version

Annotation used to define the versioning details for use with optimistic transactions. Specified on the class.

@PersistenceCapable
@Version(strategy=VersionStrategy.VERSION_NUMBER)
public class MyClass
{
...
}

See the documentation for transactions

@PrimaryKey

Annotation used to define the primary key constraint for a class. Maps across to the <primary-key> MetaData element. Specified on the class.

@PersistenceCapable
@PrimaryKey(name="MYCLASS_PK")
public class MyClass
{
...
}

@FetchPlans

Annotation used to define a set of fetch plans. Specified on the class. Used by named queries

@PersistenceCapable
@FetchPlans({@FetchPlan(name="plan_3", maxFetchDepth=3, fetchGroups={"group1", "group4"}),
@FetchPlan(name="plan_4", maxFetchDepth=2, fetchGroups={"group1", "group2"})})
public class MyClass
{
...
}

See the documentation for FetchGroups

@FetchPlan

Annotation used to define a fetch plan Is equivalent to the <fetch-plan> metadata element. Specified on the class. Used by named queries

@PersistenceCapable
@FetchPlan(name="plan_3", maxFetchDepth=3, fetchGroups={"group1", "group4"})
public class MyClass
{
...
}

See the documentation for FetchGroups

@FetchGroups

Annotation used to define a set of fetch groups for a class. Specified on the class.

@PersistenceCapable
@FetchGroups({@FetchGroup(name="one_two", members={@Persistent(name="field1"), @Persistent(name="field2")}),
@FetchGroup(name="three", members={@Persistent(name="field3")})})
public class MyClass
{
@Persistent
String field1;
    @Persistent
    String field2;
    @Persistent
    String field3;
    ...
}

See the documentation for FetchGroups

@FetchGroup

Annotation used to define a fetch group. Is equivalent to the <fetch-group> metadata element. Specified on the class.

@PersistenceCapable
@FetchGroup(name="one_two", members={@Persistent(name="field1"), @Persistent(name="field2")})
public class MyClass
{
@Persistent
String field1;
    @Persistent
    String field2;
    ...
}

See the documentation for FetchGroups

@Sequence

Annotation used to define a sequence generator. Is equivalent to the <sequence> metadata element. Specified on the class.

@Queries

Annotation used to define a set of named queries for a class. Specified on the class.

@PersistenceCapable
@Queries({@Query(name="PeopleCalledSmith", language="JDOQL",
value="SELECT FROM mydomain.Person WHERE surname == \"Smith\""),
@Query(name="PeopleCalledJones", language="JDOQL",
value="SELECT FROM mydomain.Person WHERE surname == \"Jones\"")})
public class Person
{
@Persistent
String surname;
    ...
}

@Query

Annotation used to define a named query. Is equivalent to the <query> metadata element. Specified on the class.

@PersistenceCapable
@Query(name="PeopleCalledSmith", language="JDOQL",
value="SELECT FROM mydomain.Person WHERE surname == \"Smith\"")
public class Person
{
@Persistent
String surname;
    ...
}

@Indices

Annotation used to define a set of indices for a class. Specified on the class.

@PersistenceCapable
@Indices({@Index(name="MYINDEX_1", members={"field1","field2"}), @Index(name="MYINDEX\_2", members={"field3"})})
public class Person
{
...
}

@Index

Annotation used to define an index for the class as a whole typically being a composite index across multiple columns or fields/properties. Is equivalent to the <index> metadata element when specified under class. Specified on the class.

@PersistenceCapable
@Index(name="MY_COMPOSITE_IDX", members={"field1", "field2"})
public class MyClass
{
@Persistent
String field1;
    @Persistent
    String field2;
    ...
}

@Uniques

Annotation used to define a set of unique constraints for a class. Specified on the class.

@PersistenceCapable
@Uniques({@Unique(name="MYCONST_1", members={"field1","field2"}), @Unique(name="MYCONST_2", members={"field3"})})
public class Person
{
...
}

@Unique

Annotation used to define a unique constraints for the class as a whole typically being a composite constraint across multiple columns or fields/properties. Is equivalent to the <unique> metadata element when specified under class. Specified on the class.

@PersistenceCapable
@Unique(name="MY_COMPOSITE_IDX", members={"field1", "field2"})
public class MyClass
{
@Persistent
String field1;
    @Persistent
    String field2;
    ...
}

@ForeignKeys

Annotation used to define a set of foreign-key constraints for a class. Specified on the class.

@ForeignKey

Annotation used to define a foreign-key constraint for the class. Specified on the class.

@Joins

Annotation used to define a set of joins (to secondary tables) for a class. Specified on the class.

@PersistenceCapable
@Joins({@Join(table="MY_OTHER_TABLE", column="MY_PK_COL"),
@Join(table="MY_SECOND_TABLE", column="MY_PK_COL")})
public class MyClass
{
@Persistent(table="MY_OTHER_TABLE")
String myField;
    @Persistent(table="MY_SECOND_TABLE")
    String myField2;
    ...
}

@Join

Annotation used to specify a join for a secondary table. Specified on the class.

@PersistenceCapable(name="MYTABLE")
@Join(table="MY_OTHER_TABLE", column="MY_PK_COL")
public class MyClass
{
@Persistent(name="MY_OTHER_TABLE")
String myField;
...
}

@Columns

Annotation used to define the columns which have no associated field in the class. User should specify a minimum of @Column “name”, “jdbcType”, and “insertValue”. Specified on the class.

@PersistenceCapable
@Columns(@Column(name="MY_OTHER_COL", jdbcType="VARCHAR", insertValue="N/A")
public class MyClass
{
...
}

@Persistent

Annotation used to define the fields/properties to be persisted. Is equivalent to the <field> and <property> metadata elements. Specified on the field/method.

@PersistenceCapable
public class MyClass
{
    @Persistent(primaryKey="true")
    String myField;
    ...
}

See the documentation for Field Types

@Serialized

This annotation is a shortcut for @Persistent(serialized=”true”) meaning that the field is stored serialized. It has no attributes. Specified on the field/method.

@PersistenceCapable
public class MyClass
{
@Serialized
Object myField;
...
}

@NotPersistent

This annotation is a shortcut for @Persistent(persistenceModifier=PersistenceModifier.NONE) meaning that the field/property is not persisted. It has no attributes. Specified on the field/method.

@PersistenceCapable
public class MyClass
{
    @NotPersistent
    String myOtherField;
    ...
}

See the documentation for Field Types

@Transactional

This annotation is a shortcut for @Persistent(persistenceModifier=PersistenceModifier.TRANSACTIONAL) meaning that the field/property is not persisted yet managed. It has no attributes. Specified on the field/method.

@PersistenceCapable
public class MyClass
{
    @Transactional
    String myOtherField;
    ...
}

See the documentation for Field Types

@Cacheable

This annotation is a shortcut for @Persistent(cacheable={value}) specifying whether the field/property can be cached in a Level 2 cache. Specified on the field/property. The default

public class MyClass
{
    @Cacheable("false")
    Collection elements;
    ...
}

@PrimaryKey

This annotation is a shortcut for @Persistent(primaryKey=”true”) meaning that the field/property is part of the primary key for the class. No attributes are needed when specified like this. Specified on the field/method.

@PersistenceCapable
public class MyClass
{
    @PrimaryKey
    String myOtherField;
    ...
}

@Element

Annotation used to define the element for any collection/array to be persisted. Maps across to the <collection>, <array> and <element> MetaData elements. Specified on the field/method.

@PersistenceCapable
public class MyClass
{
    @Element(types=mydomain.MyElementClass.class, dependent="true")
    Collection myField;
    ...
}

@Order

Annotation used to define the ordering of an order-based Collection/array to be persisted. Maps across to the <order> MetaData element. Specified on the field/method.

@PersistenceCapable
public class MyClass
{
    @Element(types=mydomain.MyElementClass.class, dependent="true")
    @Order(column="ORDER_IDX")
    Collection myField;
    ...
}

@Key

Annotation used to define the key for any map to be persisted. Maps across to the <map> and <key> MetaData elements. Specified on the field/method.

@PersistenceCapable
public class MyClass
{
    @Key(types=java.lang.String.class)
    Map myField;
    ...
}

@Value

Annotation used to define the value for any map to be persisted. Maps across to the <map> and <value> MetaData elements. Specified on the field/method.

@PersistenceCapable
public class MyClass
{
@Key(types=java.lang.String.class)
@Value(types=mydomain.MyValueClass.class, dependent="true")
Map myField;
...
}

@Join

Annotation used to specify a join to a join table for a collection/array/map. Specified on the field/method.

@PersistenceCapable
public class MyClass
{
@Persistent
@Element(types=mydomain.MyElement.class)
@Join(table="MYCLASS\_ELEMENTS", column="MYCLASS\_ELEMENTS\_PK")
Collection myField;
...
}

@Embedded

Annotation used to define that the field contents is embedded into the same table as this field Maps across to the <embedded> MetaData element. Specified on the field/method.

@PersistenceCapable
public class MyClass
{
@Embedded(members={
@Persistent(name="field1", columns=@Column(name="OTHER\_FLD\_1")),
@Persistent(name="field2", columns=@Column(name="OTHER\_FLD\_2"))
}
MyOtherClass myField;
...
}
@PersistenceCapable
@EmbeddedOnly
public class MyOtherClass
{
@Persistent
String field1;
    @Persistent
    String field2;
}

@Columns

Annotation used to define the columns into which a field is persisted. If the field is persisted into a single column then @Column should be used. Specified on the field/method.

@PersistenceCapable
public class MyClass
{
@Persistent
@Columns({@Column(name="RED"), @Column(name="GREEN"), @Column(name="BLUE"), @Column(name="ALPHA")})
Color myField;
...
}

@Column

Annotation used to define that the colum where a field is persisted. Is equivalent to the <column> metadata element when specified under field. Specified on the field/method (and within other annotations).

@PersistenceCapable
public class MyClass
{
@Persistent
@Column(name="MYCOL", jdbcType="VARCHAR", length=40)
String field1;
    ...
}

@Index

Annotation used to define that this field is indexed. Is equivalent to the <index> metadata element when specified under field. Specified on the field/method.

@PersistenceCapable
public class MyClass
{
@Persistent
@Index(name="MYFIELD1\_IDX")
String field1;
    @Persistent
    @Index(name="MYFIELD2\_IDX", unique="true")
    String field2;
    ...
}

@Unique

Annotation used to define that this field has a unique constraint. Is equivalent to the <unique> metadata element when specified under field. Specified on the field/method.

@PersistenceCapable
public class MyClass
{
@Persistent
@Unique(name="MYFIELD1\_IDX")
String field1;
    ...
}

@ForeignKey

Annotation used to define the foreign key for a relationship field. Is equivalent to the <foreign-key> metadata element when specified under field. Specified on the field/method.

@PersistenceCapable
public class MyClass
{
@Persistent
@ForeignKey(name="MYFIELD1\_FK", deleteAction=ForeignKeyAction.RESTRICT)
String field1;
    ...
}

@Extensions

Annotation used to define a set of extensions specific to the JDO2 implementation being used. Specified on the class or field.

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

@Extension

Annotation used to define an extension specific to a particular JDO implementation. Is equivalent to the <extension> metadata element. Specified on the class or field.

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