Ú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ý.