Anotace a Hibernate

Anotace a Hibernate
Aleš Nosek, Ondřej Vadinský, Daniel Krátký
Anotace v Javě
Anotace jsou novinkou v Javy verze 5. Anotace umožňují doplnit kód Javy o
dodatečné informace. Zapisují se přímo do zdrojového kódu programu a jsou v
tomto podobné komentářům JavaDoc. Za předchůdce anotací můžeme
považovat systém XDoclet. Ten k zápisu doplňujících informací používal
komentáře JavaDoc.
Oproti Javadocu jsou však anotace mnohem silnějším nástrojem. JavaDoc
informace se totiž dají použít pouze v čase kompilace zdrojového kódu.
Například slouží k vygenerování popisných XML souborů apod. Informace
obsažené v anotacích lze oproti JavaDocu použít i za běhu programu. K přístupu
k nim se používá mechanizmus reflexe.
Ukázka použití anotací
Tady je jednoduchá ukázka využití anotací za běhu programu. V anotaci Greet
se uloží text pozdravu, který program vypíše:
@Greet(text="Hi all")
public class Main {
public static void main(String[] args) {
System.out.println(new
Main().getClass().getAnnotation(Greet.class).text());
}
}
Jak je vidět tak anotace a jejich použití je velice snadné a může pomoci při
vytváření vlastních aplikací. Jedno z použití může být například generování
metody toString().
Kromě vlastních anotací existují můžeme využít i předdefinovaných anotací,
které jsou součástí Java API:
@Deprecated
programátor by neměl takto označený element používat kompilátor vypíše
varování „The method deprecatedMethod() from the type A is deprecated.“
@Override
označená metoda má předefinovat metodu předka pokud to nedělá (chyba
programátora) kompilace skončí chybou „method does not override or
implement a method from a supertype“
@SupressWarning
pro daný element se nemá generovat specifický warning
Životnost anotací
Životnost anotace může být podle dokumentace nasledující:
•
•
•
CLASS - anotace jsou uloženy v class souboru pomoci kompilátoru, ale
nejsou ponechané virtuálním strojem pro přístup runtime.
RUNTIME - to samé jako v předchozím případě, ale JVM tyto anotace
poskytuje i pro potřeby runtime.
SOURCE - pokud je definována tato životnost, tak je daná anotace
kompilátorem “zničena”, proto není ani v class souboru a nemůže být
tudíž ani přitomna runtime.
To jakou bude mít určitá anotace životnost se určuje jejím anotováním. (kromě
tříd, metod, polí lze totiž anotovat i samotné anotace).
Objektově relační mapování
Při implementaci objektově relačního mapování v Javě se používají tyto tři
hlavní způsoby:
1. Použití externího souboru – jedná se obvykle o XML deskriptor obsahující
metadata pro ORM mapování, nastavení databáze apod. Tyto soubory lze
generovat i automaticky např. podle schematu přímo z databáze.
Nevýhodou je, že jich může být někdy velký počet.
2. Použití JavaDoc komentářů – použijí se zvláště definované tvary
komentářů, které se předzpracují pomocí nějakého nástroje. Například
XDoclet projde zdrojové soubory a podle značek, které do nich
programátor zapsal, vytvoří mapování pro databázi. Nevýhodou tohoto
přístupu je nutnost jednoho kroku navíc při překladu aplikace.
3. Poslední možností je moderní přístup v podobě anotací. Zápis mapování
se podobně jako u XDocletu provádí přímo do souboru se zdrojovým
kódem. Při úpravách aplikace nebo refactoringu se alespoň snáze
zachová aktuálnost mapování. Informace uložené v anotacích jsou
přístupné za běhu programu pomocí mechanizmu reflexe. Není proto
potřeba žádný externí XML soubor jako u prvního zmiňovaného přístupu.
Navíc mají anotace podporu v různých nástrojích jakou jsou vývojová
prostředí IntelliJ IDEA nebo Eclipse. Tyto IDE dokáží zvýrazňovat syntaxi
nebo doplňovat kód.
Anotace v Hibernate
Hibernate 3 umí anotace používat, informace pro OR mapování tedy nemusí
být uloženy v konfiguračních souborech, ale mohou být přímo součástí
zdrojového kódu programu. Hibernate vychází z anotací EJB, které v některých
případech rozšiřuje. Anotace EJB se však stále ještě vyvíjí, proto se i zápis
anotací pro Hibernate ještě může měnit.
Pro použití anotací v Hibernate je potřeba mít Hibernate verze 3.2 a vyšší a
samozřejmě Javu 5. K projektu se kromě standardních knohoven Hibernate
přilinkuje knihovna hibernate-annotations.jar a dále lib/ejb3-persistence.jar
(Java Persistence API).
Zdrojový kód programu začíná získáním Hibernate session factory:
sessionFactory = new
AnnotationConfiguration().buildSessionFactory();
Samozřejmě je stále nutný popisovač perzistentních tříd, který je obvykle
uložen v souboru hibernate.cfg.xml:
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<mapping class="PlaneType"/>
<mapping class="ModelPlane"/>
</session-factory>
</hibernate-configuration>
Mapování persistentních tříd
Persistentní třídy jsou tídy s privátními datovými atributy a příslušnými get/set
metodami, které se ukládají do databáze. Get/set metody jsou důležité pro
správnou funkčnost hibernate. Pokud není žádoucí, aby byly tyto metody
veřejné (typicky atribut id), mohou být private.
Anotace upravují mapování persistentních tříd do tabulek v databázi a jsou
součástí zdrojového kódu dané třídy, jak je ukázáno v následujícím příkladu:
@Entity
public class ModelPlane {
private Long id;
@Id
public Long getId()
{
return id;
}
public void setId(Long
{
this.id = id;
}
}
id)
Pro určení nepersistentních atributů slouží anotace @Transient. Takto
označený atribut se nebude ukládat ani načítat z databáze. Všechny ostatní
atributy jsou automaticky chápány jako persistentní.
Anotace @Entity označuje persistentní třídu, třída se tedy bude ukládat do
databáze.
@Id pak označuje primární klíč, který odlišuje jednotlivé záznamy v tabulce.
Následuje příklad, který ilustruje způsob generování primárních klíčů. K tomuto
účelu se využívá anotace @GeneratedValue následující anotaci @Id:
@Id @GeneratedValue(strategy=GenerationType.AUTO)
public Long getId() {
return id;
}
GenerationType.AUTO deklaruje automatické generování primárního klíče.
Persistentní třída může obsahovat anotaci @Table(name=“TABLE“). Tato
anotace následuje @Entity a určuje jméno tabulky, do které se bude třída
mapovat.
Jednotlivé get metody může předcházet anotace
@Column(name=“COLUMN“). Určuje jméno sloupce v tabulce, do kterého
se bude ukládat hodnota atributu vraceného metodou get.
Následující příklad vše ilustruje:
@Entity
@Table(name="T_MODEL_PLANE")
public class ModelPlane {
private Long id;
private String name;
@Id
@Column(name="PLANE_ID")
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@Column(name="PLANE_NAME")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Kromě vlastnosti name=“NAME“ je možné použít mnoho dalších, které
upřesňují další vlastnosti daného sloupce. Výčet vlastností anotace @Column
následuje:
@Column(
name="columnName";
boolean unique() default false;
boolean nullable() default true;
boolean insertable() default true;
boolean updatable() default true;
String columnDefinition() default "";
String table() default "";
int length() default 255;
int precision() default 0;
int scale() default 0;
)
Lze tedy ovlivnit, zda je sloupec unikátní, nulavatelný, zda do něj lze vkládat
hodnoty, nebo zda lze hodnoty aktualizovat.
Mapování vztahů mezi tabulkami
Mapování vztahů mezi tabulkami přes cizí klíče je velmi častý jev. Hibernate je
pro tento případ velmi dobře a flexibilně připraven. Anotace pro základní
vztahy jsou:
@OneToOne
@OneToMany
@ManyToOne
@ManyToMany
Jednou z těchto anotací, uvedenou nad nadpisem get metody daného atributu
informujeme Hibernate právě o tom, že jde o cizí klíč.
Povinným údajem je potom informace o chování při kaskádových operacích, tj.
při operacích s entitami zatíženými constraintami. Jako typy tohoto chování se
uvádí výčtové typy třídy CascadeType:
ALL, PERSIST, MERGE, REMOVE, REFRESH, DELETE, SAVE_UPDATE,
REPLICATE, DELETE_ORPHAN, LOCK a EVICT
K dané anotaci můžeme přidat informaci o daném sloupci pomocí anotace
@JoinColumn(name="COLUMN")
Čili ne pouze anotaci @Column, která se uvádí u obyčejných sloupců.
Příklad:
@Entity
public class Flight implements Serializable {
private Company company;
@ManyToOne( cascade = CascadeType.PERSIST,
CascadeType.MERGE} )
@JoinColumn(name="COMP_ID")
public Company getCompany() {
return company;
}
}
Tedy u get metody, která vrací instanci třídy Company, která je také
persistentní, ale v tabulce entity Flight je uveden pouze její klíč. Tento klíč je
definován ve sloupci COMP_ID. Pokud je tato get metoda zavolána, Hibernate
podle cizího klíče nejdříve vyhledá příslušnou entitu, vytvoří instanci její třídy a
naplní ji daty. Tuto instanci pak metoda vrací.
Named Query
Named query slouží k definování vlastních SQL dotazů. Je zde tedy prostor pro
přesažení standardního rámce nabízeného Hibernatem, možnost například
vyhledávat v souvislostech z různých tabulek nesvázaných potřebnými
constraintami (ať už z jakéhokoli důvodu).
Named query se ukládá do třídy entity jako anotace třídy (tj. nad hlavičkou
třídy) a sestává z těchto anotací:
@NamedQueries
@NamedQuery
Jak je zřejmé na první pohled, první anotace uzavírá množinu těch druhých.
Každá Named query pak musí mít jméno, podle kterého se volá a samotný
dotaz.
Příklad:
@NamedQueries(
{
@NamedQuery(
name="planeType.findById",
query="select p from PlaneType p left join
p.modelPlanes where id=:id"
),
@NamedQuery(
name="planeType.findAll",
query="select p from PlaneType p"
),
@NamedQuery(
fetch
name="planeType.delete",
query="delete from PlaneType where
id=:id"
)
}
)
Jak je vidět, do Named query se dosazují různé parametry, určující výsledek
dotazu.
Strind planeId = "FOO"
Query query =
em.createNamedQuery("planeType.delete");
query.setParameter("id",planeId);
List<Item> items = query.getResultList();
Kde "em" je javax.persistence.EntityManager. List výsledků bude v konkrétním
případě mazání prázdný.
Seznam Literatury
http://www.hibernate.org/hib_docs/annotations/reference/en/html_si
ngle/
http://www.onjava.com/pub/a/onjava/2007/02/08/an-introduction-tohibernate-3-annotations.html
http://www.scream.cz/2007/10/28/jemny-uvod-do-anotaci/
http://java.sun.com/j2se/1.5.0/docs/api/
http://en.wikipedia.org/wiki/Hibernate_%28Java%29