Úvod redakce

Tento článek představuje technologii Jalapeño od InterSystems a
slouží jako pozvánka na květnovou přednášku CZJUGu, kterou přednese Andreas Dieckow, Principal
Product Manager, Strategic Planning, InterSystems
Corporation.

Úvod

Díky své vlastnosti „jednou to napiš a implementuj
kdekoliv” má programovací jazyk Java mnoho příznivců
a uživatelů. Ale Java je také objektově-orientovaný
jazyk a jeho datové objekty nebyly autory navrženy
jako persistentní.

I nejhorlivější přívrženci Javy připustí, že s
objektově-relačním mapováním, vyžadujícím uchovávání
javovských objektů v relační databázi, je spousta
práce. Podle některých odhadů může zabrat až 60-70 %
celkového úsilí vývojářů. Kromě podpory JDBC jako v
kterékoliv relační databázi Caché od InterSystems
nabízela objektově-orientované způsoby pro realizaci
datové persistence Java aplikací. Pro Caché třídy
mohou být vytvořeny projekce typu Java proxy tříd
nebo Enterprise Java Beans s vysoce výkonnou
persistencí řízenou samotnými beany. Tyto přístupy
jednak eliminují objektově-relační mapování, ale
současně po vývojářích v Javě vyžadují, aby vytvářeli
své datové (tedy persistentní) objekty v Caché, ještě
před vytvořením projekcí a používali je ve svém
javovském vývojovém prostředí.

Tento příspěvek představuje technologii Jalapeño
firmy InterSystems, která umožňuje spíše „Java-in”
než „Caché-out” přístup k aplikačnímu vývoji. Bude
pojednávat o tom, jak zajistit persistenci „starých
dobrých javovských objektů” – známých jako „plain old
Java objects” (POJO) v Caché a popíše výhody spojené
s užíváním objektové technologie pro ukládání dat.
Bude zde také podán přehled nezbytných kroků, aby
aplikace vytvořená s technologií Jalapeño běžela nad
relační databázi.

Co je technologie Jalapeño?

Technologie Jalapeño společnosti InterSystems
(JAva Language
PErsistence with NO mapping) umožňuje vývojářům v Javě
definovat třídy objektů v jakémkoli oblíbeném
javovském prostředí a persistentně je uchovávat v
Caché bez objektově-relačního mapování a bez nutnosti
naučit se používat Caché Studio.

Tyto vysoce výkonné metody přístupu k datovým
objektům, automaticky generované Caché, existují
nezávisle na Java třídě, takže vývojáři mohou ve
svých aplikacích pracovat s objekty POJO a nemusí je
zajímat, jakým mechanizmem jsou data uchovávána.
Persistence Java objektů jako skutečných objektů, při
eliminaci objektově-relačního mapování, významně
zkracuje dobu vývoje. Výhodou je ale také lepší
výkon, protože není potřeba rozkládat a sestavovat
(jinými slovy serializovat či deserializovat) objekty
při jejich ukládání i čtení.

I když je výhodnější ukládat data jako objekty,
najdou se případy, kdy může být nutné dotazovat se
databáze s použitím SQL, buď v Java aplikaci nebo
přes analytický a reportingový nástroj třetí strany.
Prostřednictvím své Unifikované datové architektury
(Unified Data Architecture) Caché automaticky
vystavuje data jako relační tabulky. Ale ještě jednou
opakujeme, není potřeba žádné mapování. Caché je
kompatibilní s JDBC – a SQL dotazy v aplikaci mohou
sdílet stejné databázové spojení jako metody
objektové persistence používané technologií Jalapeño.

Použití technologie Jalapeño

V podstatě existují dva kroky, které vývojář v
Javě potřebuje udělat pro persistenci objektů POJO v
Caché. Prvním je vytvořit a zkompilovat Caché třídy z
definic POJO, druhá je zahrnout a použít Jalapeño
Object Manager v Java aplikaci.

Vytvoření Caché tříd

Jalapeño nabízí utilitu (pojmenovanou Schema
Builder), která automaticky vytváří a kompiluje
persistentní Caché třídy založené na definicích Java
tříd. (Schema Builder je javovskou třídou zahrnutou v
knihovně CacheDB.jar dodávané spolu s Caché.)
Vývojáři mohou ovlivňovat, jak Caché strukturuje
objektový model, tím, že do svých definic POJO tříd
vloží „anotace”. Anotace (zavedené v JDK 1.5)
neovlivňují chování Java tříd za běhu programu. Pouze
poskytují další metadata o požadovaném objektovém
modelu Caché. Anotace může například říci Caché, že
jedna třída dědí z jiné nebo že na danou vlastnost
třídy by měl být vytvořen index.

Příklady 1A a 1B ukazují jednoduchou definici Java
třídy a Caché třídy, která je z ní odvozena.
Povšimněte si, že Caché třída dědí z třídy poskytnuté
InterSystems, nazvané %Library.Persistent, a že byl
vytvořen index nad vlastností „Name”.

Pokud si to vyloženě nepřejí, nemusejí se vývojáři
v Javě nikdy podívat na Caché třídy vytvořené Schema
Builderem nebo o nich uvažovat. Pomocí objektů POJO
mohou programovat ve svém oblíbeném vývojovém
prostředí. Když se jejich objektový model změní,
stačí jim znovu spustit Schema Builder, aby se tyto
změny odrazily v odpovídajících persistentních Caché
třídách.

Použití Správce Objektů (Object Manager)

V jiných propojovacích mechanizmech Javy a Caché,
třeba při vytváření projekcí Caché tříd jako proxy
Java tříd, jsou persistentní metody (zděděné z
%Library.Persistent) transformovány do Java
„přístupových” metod. Každá Java třída obsahuje svoji
vlastní množinu přístupových metod. Naopak při
použití technologie Jalapeño se objekty POJO nemění,
aby zahrnuly přístupové metody. Místo toho javovská
aplikace používá element zvaný Object Manager, který
navazuje spojení s databází, vytváří instance
příslušných Caché tříd i přístupové metody, které
také spouští.

Object Manager je Java třídou, kterou InterSystems
dodává jsou součást knihovny tříd CacheDB.jar. K
jejímu použití je potřeba udělat následující kroky,
které jsou důvěrně známé každému programátorovi v
Javě:

  • Zahrňte CacheDB.jar do proměnné CLASSPATH v
    aplikaci
  • Importujte balíček „pojo”. (V CacheDB.jar mohou
    být také další balíčky, které můžete chtít
    naimportovat.)
  • Vytvořte instanci třídy Object Manager

Příklad 2 ukazuje vytvoření instance Object
Manager . Všimněte si, že Object Manager (dále česky
“Správce Objektů”) navazuje JDBC spojení s
databázovým serverem. V Caché mohou objekt i JDBC
databázový přístup sdílet stejné spojení. Tím pádem
může Správce Objektů využívat vysoce výkonné
persistentní metody, ale dotazy na data mohou být
také prováděny s pomocí SQL.

Příklad 1A – Java třída

import
com.intersys.pojo.annotations.CacheClass;


import com.intersys.pojo.annotations.Index;





@CacheClass(name=”Person”,primaryKey=”ID”,sqlTableName=”PERSON”)


@Index(description=”Name Index on Person
table”,name=”PersonIndexOne”,propertyNames={“name”},sqlName=”PersonIDX”)


public class Person {

public String
name;


public String ssn;


public String telephone;

}

Příklad 1B – odpovídající vygenerovaná třída Caché

Class User.Person Extends %Library.Persistent [
ClientName = Person, Not ProcedureBlock, SqlTableName
= PERSON ]


{

Property name As
%Library.String(JAVATYPE = “java.lang.String”, MAXLEN
= 4096);


Property ssn As %Library.String(JAVATYPE =
“java.lang.String”, MAXLEN = 4096);


Property telephone As %Library.String(JAVATYPE =
“java.lang.String”, MAXLEN = 4096);


Index PersonIndexOne On name [ SqlName = PersonIDX
];


XData JavaBlock


{

<JavaBlock>


<Package implementation=”CacheRefactor.cache”
pojo=”CacheRefactor”></Package>


<UseSameNames>false</UseSameNames>


<Name implementation=”Person”
pojo=”Person”></Name>


<ResolveNameCollisions>false</ResolveNameCollisions>


<EagerFetchRequired>true</EagerFetchRequired>


</JavaBlock>

}

}

 

Příklad 2 – instanciace třídy Object Manager

public DBService (String[] args) throws
Exception


{

String host =
“localhost”;


String username=”_SYSTEM”; // null for default


String password=”SYS”; // null for default


for (int i = 0; i < args.length; i++)

if
(args[i].equals(“-user”))

username =
args[++i];

else if (args[i].equals(“-password”))

password =
args[++i];

else if (args[i].equals(“-host”))

host =
args[++i];

String url=”jdbc:Cache://” + host + “:1972/USER”;


Class.forName(“com.intersys.jdbc.CacheDriver”);


Connection connection = DriverManager.getConnection
(url, username, password);


objectManager =
ApplicationContext.createObjectManager(connection);

}

 

Implementace nad relační databází

Schopnost Správce Objektů ovládat přístup jak k
objektovým, tak relačním datům nabývá zvláštní
důležitosti, jestliže Java aplikace vytvořená s
technologií Jalapeño vyžaduje implementaci nad
relační databází, namísto Caché. Nasazení v relační
architektuře je velmi jednoduché a vyžaduje jen dva
dodatečné kroky.

Za prvé, musí být vytvořeno příslušné schéma
relační databáze. Caché pro tento případ nabízí
exportní utilitu (jako součást CacheDB.jar), jež může
vytvořit projekci objektového modelu – původně
odvozeného z definic tříd POJO – jako DDL souborů,
které mohou být importovány do relační databáze. Je
důležité si povšimnout, že se nejedná o stejnou věc
jako v případě standardních relačních projekcí Caché.
Protože objektové schéma v Caché bylo vytvořeno z
definic Java tříd, exportní utilita „ví” pár věcí o
objektech POJO navíc a používá tyto informace při
vytváření schématu relačních dat.

Jakmile bylo příslušné relační databázové schéma
vytvořeno, stačí jen nakonfigurovat Správce Objektů
tak, aby se připojoval k relační databázi namísto
Caché. Správce Objektů automaticky použije metody
objektové persistence (Open, Save, New, Delete) při
připojování ke Caché a metody relační persistence
(Select, Update, Insert, Delete) při připojování k
relační databázi.

Ačkoliv technologie Jalapeño společnosti
InterSystems usnadňuje nasazení javovských aplikací v
relačním prostředí, vývojáři pravděpodobně zjistí, že
aplikace běží rychleji s Caché. Caché totiž nejen že
umožňuje vysoce výkonnou objektovou persistenci, ale
bylo také dokázáno, že odpovídá na SQL dotazy – a to
zvláště ty složité – rychleji než relační databáze.

Závěr

Caché dlouhou dobu podporovala několik způsobů
datové persistence v Java aplikacích, přes JDCB, nebo
přístup k objektovým datům. Ale až doposud byly tyto
postupy „Caché-centrické”. Po vývojářích se chtělo,
aby definovali objekty v Caché a pak vytvořili jejich
projekci v prostředí Javy. Nová technologie Jalapeño
v Caché dává vývojářům možnost pro dosažení datové
persistence použít postup „Java-in”. Persistentní
Caché třídy mohou být definovány a kompilovány z
definic tříd POJO. Při běhu programu jsou databázové
připojení a persistence řízeny Správcem Objektů,
který je poskytován jako součást Jalapeño. Vývojáři
mohou použit původní objekty POJO, aniž by přemýšleli
o tom, jak je v databázi zajištěna persistence. Kromě
toho, že jsou vývojáři v Javě osvobozeni od nutnosti
používat Caché Studio, jsou také osvobozeni od
únavného a velmi časově náročného objektově-relačního
mapování. Caché dovoluje jak objektový, tak relační
přístup k datům jedním spojením, takže vývojáři mohou
uvažovat v pojmech objektů. Jejich javovské aplikace
mohou využívat vysoce výkonné metody
objektově-orientované persistence a dotazovat Caché
databázi s použitím SQL, pokud se to hodí.
Technologie Jalapeño neomezuje vývojáře v
implementaci jejich aplikací nad Caché. Při minimální
další práci může javovská aplikace vytvořená s
technologií Jalapeño běžet nad relační databází, i
když výsledný výkon pravděpodobně nebude tak skvělý.