Spring ist ein vielfach eingesetztes Framework für die Entwicklung von Java-Anwendungen.
WebSphere eXtreme Scale unterstützt
den Einsatz von Spring für die Verwaltung von eXtreme-Scale-Transaktionen und die Konfiguration von eXtreme-Scale-Clients und -Servern.
Informationen zu diesem Vorgang
Das Spring-Framework ist, wie in den folgenden Abschnitten beschrieben wird,
in hohem Maß integrierbar mit
eXtreme Scale.
Vorgehensweise
- Native
Transaktionen: Spring stellt
containerverwaltete Transaktionen im Stil eines Java-EE-Anwendungsservers (Java Platform,
Enterprise Edition) bereit, hat aber den Vorteil,
dass in den Spring-Mechanismus verschiedene Implementierungen integriert werden können.
In diesem Abschnitt wird ein eXtreme Scale Plattform Transaction Manager
beschrieben, der mit Spring verwendet werden kann.
Dies ermöglicht Programmierern, ihre POJOs (Plain Old Java Objects)
zu annotieren und anschließend Session-Objekte über Spring von
eXtreme Scale abrufen und eXtreme-Scale-Transaktionen
starten, festschreiben, rückgängig machen, aussetzen und fortsetzen zu lassen.
Spring-Transaktionen werden ausführlicher in
Kapitel 10 der offiziellen Referenzdokumentation zu Spring beschrieben.
Im Folgenden wird erläutert, wie ein eXtreme-Scale-Transaktionsmanager erstellt und mit annotierten POJOs verwendet wird.
Es wird auch erläutert, wie dieser Ansatz mit einer Client- oder lokalen eXtreme-Scale-Umgebung
und mit einer kollokierten Data-Grid-Anwendung verwendet wird.
- Transaktionsmanager: Für die Arbeit mit Spring stellt eXtreme Scale eine Implementierung
eines PlatformTransactionManager von Spring bereit. Dieser Manager kann POJOs, die von Spring verwaltet werden, verwaltete eXtreme-Scale-Sitzungen bereitstellen.
Mit Annotationen verwaltet Spring diese Sitzungen für die POJOs in einem Transaktionslebenszyklus.
Das folgende XML-Snippet veranschaulicht, wie ein Transaktionsmanager erstellt wird:
<aop:aspectj-autoproxy/>
<tx:annotation-driven transaction-manager="transactionManager"/>
<bean id="ObjectGridManager"
class="com.ibm.websphere.objectgrid.ObjectGridManagerFactory"
factory-method="getObjectGridManager"/>
<bean id="ObjectGrid"
factory-bean="ObjectGridManager"
factory-method="createObjectGrid"/>
<bean id="transactionManager"
class="com.ibm.websphere.objectgrid.spring.ObjectGridSpringFactory"
factory-method="getLocalPlatformTransactionManager"/>
</bean>
<bean id="Service" class="com.ibm.websphere.objectgrid.spring.test.TestService">
<property name="txManager" ref+"transactionManager"/>
</bean>
Dieses Snippet zeigt, dass die Bean "transactionManager" deklariert und
mit der Bean "Service", die Spring-Transaktionen verwendet, verbunden wird.
Dies wird mit Hilfe von Annotationen veranschaulicht, und dies ist auch der Grund für die
Klausel "tx:annotation" am Anfang.
- ObjectGrid-Sitzung anfordern:
Ein POJO, dessen Methoden von Spring verwaltet werden, kann jetzt
das ObjectGrid-Session-Objekt für die aktuelle Transaktion
wie folgt anfordern:
Session s = txManager.getSession();
Diese Methode gibt die Sitzung zurück, die
das POJO verwenden soll. An derselben Transaktion beteiligte Beans
empfangen dasselbe Session-Objekt, wenn sie diese Methode aufrufen.
Spring startet das Session-Objekt automatisch und ruft auch bei Bedarf automatisch
die Methode "commit" oder "rollback" auf. Sie können auch ein
ObjectGrid-EntityManager-Objekt anfordern, indem Sie einfach "getEntityManager" über das Session-Objekt aufrufen.
- ObjectGrid-Instanz für einen Thread festlegen: In einer einzelnen
Java Virtual Machine
(JVM) können viele ObjectGrid-Instanzen ausgeführt werden. Jedes primäre Shard in einer JVM hat eine
eigene ObjectGrid-Instanz. Eine JVM, die als Client für ein fernes
ObjectGrid auftritt, verwendet eine ObjectGrid-Instanz, die über das
ClientClusterContext-Objekt der Methode "connect" zurückgegeben wird, um mit diesem Grid zu interagieren.
Vor dem Aufruf einer Methode in einem POJO über Spring-Transaktionen für das ObjectGrid
muss der Thread mit der zu verwendenden ObjectGrid-Instanz verbunden werden.
Die TransactionManager-Instanz hat eine Methode, mit der eine bestimmte ObjectGrid_Instanz angegeben werden kann.
Wenn diese Methode angegeben wird, geben alle nachfolgenden Aufrufe von txManager.getSession
Session-Objekte für diese ObjectGrid-Instanz zurück.
Das folgende Beispiel
zeigt eine Beispielfunktion "main" für das Testen dieser Funktionalität:
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(new String[]
{"applicationContext.xml"});
SpringLocalTxManager txManager = (SpringLocalTxManager)ctx.getBean("transactionManager");
txManager.setObjectGridForThread(og);
ITestService s = (ITestService)ctx.getBean("Service");
s.initialize();
assertEquals(s.query(), "Billy");
s.update("Bobby");
assertEquals(s.query(), "Bobby");
System.out.println("Requires new test");
s.testRequiresNew(s);
assertEquals(s.query(), "1");
Hier wird ein Spring-ApplicationContext-Objekt verwendet.
Das ApplicationContext-Objekt wird verwendet, um eine Referenz auf das
txManager-Objekt anzufordern und um ein in diesem Thread zu verwendendes ObjectGrid anzugeben.
Anschließend fordert der Code eine Referenz auf den Service an und ruft Methoden in diesem Service auf.
Jeder Methodenaufruf auf dieser Ebene bewirkt, dass Spring ein Session-Objekt erstellt
und begin/commit-Aufrufe um den Methodenaufruf herum absetzt. Alle Ausnahmen führen zu einem Rollback.
- Schnittstelle "SpringLocalTxManager": Die Schnittstelle "SpringLocalTxManager" wird von ObjectGrid Platform Transaction Manager implementiert und enthält alle
allgemein zugänglichen Schnittstellen.
Die Methoden in dieser Schnittstelle sind für die Auswahl der ObjectGrid-Instanz, die in einem Thread
verwendet werden, soll, und für das Abrufen eines Session-Objekts für den Thread bestimmt.
Alle POJOs, die lokale ObjectGrid-Transaktionen verwenden, müssen über eine Referenz
auf diese Managerinstanz injiziert werden, und es muss nur eine einzige Instanz erstellt werden, d. h.,
der Geltungsbereich muss "Singleton" sein.
Diese Instanz wird mit einer statischen Methode in ObjectGridSpringFactory.getLocalPlatformTransactionManager() erstellt.
Einschränkung: WebSphere eXtreme Scale unterstützt
aus verschiedenen Gründen, die sich hauptsächlich auf die Skalierbarkeit beziehen, weder JTA noch die zweiphasige Festschreibung.
Deshalb interagiert ObjectGrid bis auf einen letzten einphasigen Teilnehmer nicht
in globalen XA- oder JTA-Transaktionen.
Dieser Plattformmanager soll lokale ObjectGrid-Transaktionen für
Spring-Entwickler so einfach wie möglich machen.