Whitepapers & Broschüren

Laden Sie hier die PDF-Fassung

Plain Old Java Persistenz mit Caché

Andreas Dieckow
Principal Product Manager, Strategic Planning
InterSystems Corporation

Einführung

Die Programmiersprache Java erfreut sich hoher Beliebtheit dank der Eigenschaft, dass einmal erstellter Code beinahe überall bereit­gestellt werden kann: "Write once, Deploy anywhere" heißt hier die Devise. Aber Java ist eine objektorientierte Sprache, deren Daten­objekte grundsätzlich nicht persistent sind. Selbst die glühendsten Verfechter von Java werden zugestehen, dass objektrelationales Mapping zum Erhalt persistenter Java-Objekte in einer relationalen Datenbank eine lästige Aufgabe ist. Nach Schätzungen kann dies 60% – 70% des gesamten Entwicklungsaufwands ausmachen.

Caché  von InterSystems unterstützt JDBC wie jede andere relationale Datenbank und bietet zudem objektorientierte Verfahren, um die Datenpersistenz für Java-Anwendungen bereitzustellen. Caché-Klassen können als Java-Proxy-Klassen oder als Enterprise Java Beans mit hochperformanter Bean-Managed Persistence projiziert werden. Diese Ansätze vermeiden objektrelationales Mapping. Java-Entwickler müssen jedoch ihre Datenobjekte in Caché erstellen, bevor diese projiziert und in der Java-Entwicklungsumgebung genutzt werden können.

Dieses White Paper stellt die Jalapeño-Technologie von InterSystems vor, die zur Entwicklung von Anwendungen auf einen “Java-in” anstatt des “Caché-out”-Ansatzes setzt. Es wird erörtert, wie “Plain Old Java Objects” (POJOs) in Caché persistent gemacht werden und die Vorteile der Verwendung der Objekttechnologie für die Datenspeicherung aufgezeigt. Außerdem werden die erforder-lichen Schritte dargestellt, um eine in Jalapeño-Technologie erstellte Anwendung mit einer relationalen Datenbank zu betreiben.

Die Jalapeño-Technologie - Übersicht

Die Jalapeño-Technologie (JAva LAnguage PErsistence with NO mapping) von InterSystems erlaubt Java-Entwicklern die De­finition von Objektklassen in jeder beliebigen Java-Entwicklungsumgebung. Die Klassen können in Caché persistent definiert werden – ohne objektrelationales Mapping und ohne Caché Studio zu erlernen oder zu ver­wenden. Die hochperformanten objekt­orien­tierten Datenzugriffsverfahren, die automatisch von Caché generiert werden, existieren unab­hängig von der Java-Klasse. Dies bedeutet, dass Entwickler POJOs in Anwendungen verwenden können, ohne sich um die Mechanik der Datenspeicherung kümmern zu müssen.

Werden Java-Objekte als Objekte persistent gemacht, und so objektrelationales Mapping überflüssig, senkt dies die Entwicklungs­zeit ganz erheblich. Und es bietet auch einen Performance-Vorteil, da für das Aufteilen und erneute Zusammensetzen von Objekten bei deren Speicherung oder Abruf keine Verarbeitung erforderlich ist.

Auch wenn Daten vorzugsweise als Objekte gespeichert werden sollten, kann es manchmal erforderlich sein, die Datenbank mit SQL abzufragen, entweder in der Java-Anwendung oder über ein Datenanalyse- und Reporting-Tool eines Drittanbieters. Dank der Unified Data Architecture stellt Caché automatisch die Daten als relationale Tabellen dar. Auch hier ist kein Mapping erforderlich. Caché ist kompatibel zu JDBC, und SQL-Abfragen in der Anwendung können dieselbe Datenbank­verbindung wie die Objektpersistenzmethoden nutzen, die von der Jalapeño-Technologie verwendet werden.

Einsatz der Jalapeñ-Technologie

Ein Java-Entwickler muss im Grunde nur zwei Dinge tun, um POJOs in Caché persistent zu machen. Als Erstes werden Caché-Klassen aus POJO-Definitionen erstellt und kompiliert. Zweitens wird der Jalapeño Objekt Manager in die Java-Anwendung eingebunden und verwendet. .

Definition von Caché-Klassen

Unter dem Namen „Schema Builder“ stellt Jalapeño ein Tool bereit, das automatisch auf der Basis von Java-Klassendefinitionen persistente Caché-Klassen erstellt. (Schema Builder ist eine Java-Klasse, die in CacheDB.jar enthalten ist.) Entwickler können steuern, wie Caché das Objektmodell strukturiert, indem sie Anmerkungen (Annota­tions) in die POJO-Klassen­definitionen einfügen. Solche Anmerkungen (in JDK 1.5 eingeführt) wirken sich nicht auf das Laufzeitverhalten der Java-Klasse aus. Sie stellen nur zusätzliche Metadaten über das gewünschte Caché-Objektmodell bereit. Eine Anmerkung kann Caché beispielsweise anweisen, dass eine Klasse von einer anderen erbt, oder dass für eine bestimmte Eigenschaft einer Klasse ein Index erstellt werden soll.

Die Beispiele 1A und 1B (nächste Seite) zeigen eine einfache Definition einer Java-Klasse und die Caché-Klasse, die daraus abgeleitet ist. Beachten Sie hier, dass die Caché-Klasse von einer von InterSystems bereitgestellten Klasse namens %Library. Persistent erbt und ein Index für die Eigenschaft "Name" erstellt wurde.

Java-Entwickler brauchen sich nie die vom Schema Builder erstellten Caché-Klassen ansehen oder sich darüber Gedanken machen – aber es steht Ihnen frei, dies zu tun, wenn sie es gerne möchten. Sie können POJOs in ihrer bevorzugten IDE programmieren. Wenn sich das Objektmodell ändert, wird nur der Schema Builder neu ausgeführt, um die Änderungen in die zugehörigen persistenten Caché-Klassen zu übernehmen.

Beispiel 1A – eine Java-Klasse

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;

}

Beispiel 1B – die zugehörige Caché-Klasse

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>
}

Einsatz von Objekt Manager

In den anderen Java-Binding-Verfahren von Caché werden die Persistenzmethoden (geerbt von %Library.Persistent) in Java Accessor-Methoden transformiert, wenn Caché-Klassen als Java-Proxy-Klassen projiziert werden. Jede Java-Klasse enthält Accessor-Methoden. Im Unterschied dazu werden bei der Jalapeño-Technologie die POJOs nicht geändert, um Accessor-Methoden aufzunehmen. Statt­dessen verwendet die Java-Anwendung eine Kompo-nente, den so genannten Objekt Manager, der die Datenbankverbindung herstellt, die entsprechenden Caché-Klassen instanziiert und die Accessor-Methoden erstellt und ausführt.

Der Objekt Manager ist eine Java-Klasse und wird von InterSystems als Bestandteil von CacheDB.jar zur Verfügung gestellt. Die für die Verwendung erforderlichen Schritte werden jedem Java-Programmierer bekannt vorkommen:

• Aufnahme von CacheDB.jar in die CLASSPATH-Anweisung der Anwendung
  
  
• Import des “pojo”-Package. (Wenn Sie möchten, können auch weitere Packages von CacheDB.jar importiert werden.)
  
  
• Instanziierung des Objekt Managers

Beispiel 2 (unten) zeigt die Instanziierung des Objekt Managers. Beachten Sie, dass der Objekt Manager eine JDBC-Verbindung zum Daten­bankserver herstellt. Mit Caché können objektorientierter und JDBC-Datenbankzugriff dieselbe Verbindung nutzen. So kann der Objekt Manager hochperformante Persistenz­methoden verwenden, die Daten können jedoch auch mit SQL abgefragt werden.

 

Beispiel 2 – Instanziierung des Objekt Managers

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);
}

Deployment mit einer relationalen Datenbank

Der Zugriff mit dem Objekt Manager auf objektorientierte wie auch auf relationale Daten wird besonders dann wichtig, wenn eine mit der Jalapeño-Technologie erstellte Java-Anwendung nicht mit Caché sondern mit einer anderen, relationalen Datenbank eingesetzt werden muss. Der Betrieb in einer relationalen Architektur ist relativ einfach. Es sind nur zwei zusätzliche Schritte erforderlich.

Zunächst muss das entsprechende relationale Datenbankschema erstellt werden. Caché bietet ein Export-Utility (als Bestandteil von CacheDB.jar), das ein – ursprünglich von den POJO-Klassendefinitionen abgeleitetes – Objektmodell als DDL-Dateien projizieren kann, die in eine relationale Datenbank importiert werden können. Wichtig hierbei ist, dass dies jedoch nicht mit der standardmäßigen relationalen Projektion von Caché identisch ist. Da das Objektschema in Caché aus Java-Klassendefinitionen erstellt wurde, "weiß" das Export-Utility einiges über die POJOs und verwendet diese Informationen für die Definition des relationalen Datenschemas.

Nachdem das entsprechende relationale Daten-bankschema erstellt ist, wird nur noch der Objekt Manager konfiguriert, der dann eine Verbindung zur relationalen Daten­bank anstatt zu Caché herstellt. Der Objekt Manager verwendet automatisch Objektpersistenz-methoden (Open, Save, New, Delete) in Verbindung mit Caché sowie relationale Persistenzmethoden (SELECT, UPDATE, INSERT, DELETE) in Verbindung mit einer relationalen Datenbank.

Wenngleich die Jalapeño-Technologie von InterSystems das Deployment einer Java-Anwendung in einer relationalen Umgebung vereinfacht, werden Entwickler feststellen, dass ihre Anwendungen schneller ausgeführt werden, wenn sie mit Caché betrieben werden. Caché ermöglicht nicht nur eine hoch-performante Objektpersistenz, es zeichnet sich auch dadurch aus, dass es auf SQL-Abfragen – insbesondere komplexer Natur – schneller reagiert als relationale Datenbanken.

Zusammenfassung

Caché unterstützt seit langem verschiedene Verfahren, um die Datenpersistenz für Java-Anwendungen bereitzustellen, sowohl durch den JDCB- wie auch durch den objekt­orientierten Datenzugriff. Bislang waren diese Ansätze jedoch “Caché-zentriert”. Entwickler definieren Objekte in Caché und projizieren diese dann in ihre Java-Umgebung.

Durch die neue Jalapeño-Technologie von Caché können Entwickler zur Verwirklichung der Datenpersistenz einen "Java-in"-Ansatz verwenden. Persistente Caché-Klassen können aus POJO-Klassendefinitionen definiert und kompiliert werden. Zur Laufzeit kümmert sich ein Objekt Manager, der zum Lieferumfang von Jalapeño gehört, um Datenbankverbindung und Persistenz. Entwickler können mit den originalen POJOs arbeiten, ohne sich darum kümmern zu müssen, wie die Informationen persistent in die Datenbank gelangen.

Java-Entwickler müssen nicht mehr die Caché IDE verwenden, und die mühsame und zeitaufwändige Aufgabe des objektrelationalen Mappings gehört der Vergangenheit an. Caché erlaubt den objektorientierten wie auch den relationalen Zugriff auf Daten über dieselbe Verbindung, so dass Entwickler durchgängig objektorientiert vorgehen können. Die Java-Anwendungen können hochperformante objektorientierte Persistenzmethoden ver­wen­den und Daten in Caché-Datenbanken mit SQL abfragen, falls dies erforderlich ist.

Die Jalapeño-Technologie beschränkt Ent-wickler nicht darauf, Anwendungen unter Caché bereitzustellen. Mit sehr geringem Zusatzaufwand kann eine mit der Jalapeño-Technologie erstellte Java-Anwendung auf einer relationalen Datenbank ausgeführt werden, auch wenn die Performance hier nicht ganz so exzellent sein wird.