Spring es una infraestructura popular para desarrollar las aplicaciones Java. WebSphere eXtreme
Scale proporciona soporte para que
Spring pueda gestionar transacciones de eXtreme Scale y configurar clientes y servidores de eXtreme Scale.
Acerca de esta tarea
Spring Framework
es altamente integrable con
eXtreme Scale,
tal como se describe en las secciones siguientes.
Procedimiento
- Transacciones nativas: Spring proporciona transacciones gestionadas por contenedor junto con el estilo de un servidor de aplicaciones Java Platform,
Enterprise Edition, pero tiene la ventaja de que el mecanismo Springs puede tener distintas implementaciones conectadas. Este tema describe un gestor de transacciones de la plataforma eXtreme Scale que se puede utilizar con Spring. Esto permite a los programadores anotar sus
POJO (Plain Old Java Object) y, a continuación, hacer que
Spring adquiera automáticamente los objetos Sessions de eXtreme Scale, así como empezar, confirmar, retrotraer, suspender y reanudar transacciones eXtreme Scale. Las transacciones Spring se describen de forma más completa en el Capítulo 10 de la documentación de referencia oficial de Spring. A continuación se explica cómo crear un gestor de transacciones eXtreme Scale y utilizarlo con los POJO anotados. También explica cómo utilizar este enfoque con eXtreme Scale local o cliente así como una aplicación de estilo Data Grid con ubicación compartida.
- Gestor de transacciones: para trabajar con Spring, eXtreme Scale proporciona una implementación de un PlatformTransactionManager de Spring. Este gestor puede proporcionar sesiones deeXtreme Scale gestionadas a los POJO gestionados por
Spring. A través del uso de anotaciones, Spring gestiona estas sesiones para los POJO en términos de ciclo de vida de transacción. El siguiente fragmento de código XML muestra cómo crear un gestor de transacciones:
<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>
Esto muestra el bean transactionManager declarándose y conectándose al bean Service que utilizará transacciones Spring. Los demostraremos utilizando anotaciones y por este motivo existe la cláusula tx:annotation al principio.
- Obtención de una sesión de ObjectGrid:
Un POJO que tiene métodos gestionados por Spring ahora puede obtener la Session de
ObjectGrid para la transacción actual utilizando Session s = txManager.getSession();
Esto devuelve la sesión para que lo utilice POJO.
Los beans que participan en la misma transacción recibirán la misma sesión cuando llame a este método. Spring manejará automáticamente el inicio de Session y también invocará automáticamente la confirmación o la retrotracción cuando sea necesario. Puede obtener un EntityManager de ObjectGrid llamando simplemente a getEntityManager desde el objeto Session.
- Establecimiento de la instancia de ObjectGrid
para una hebra: una sola máquina virtual Java
(JVM) puede alojar muchas instancias de ObjectGrid. Cada fragmento primario colocado en una JVM tiene su propia instancia de ObjectGrid.
Una JVM que funcione como cliente para un ObjectGrid remoto utiliza una instancia de ObjectGrid
devuelta de ClientClusterContext del método de conexión para interactuar con Grid. Antes de invocar un método en un POJO que utilicen transacciones Spring para ObjectGrid, la hebra debe prepararse con la instancia de ObjectGrid a utilizar. La instancia TransactionManager tiene un método que permite especificar una instancia de ObjectGrid concreta.
Una vez que se ha especificado, todas las llamadas a txManager.getSession posteriores devolverán
Sessions para esa instancia de ObjectGrid.
El siguiente ejemplo muestra un
ejemplo para utilizar esta prestación:
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");
Aquí utilizamos un Spring
ApplicationContext. ApplicationContext se utiliza para obtener una referencia para
txManager y especificar un ObjectGrid que se va a utilizar con esta hebra.
A continuación, el código obtiene una referencia para el servicio e invoca métodos del mismo.
Cada llamada al método de este nivel hace que Spring cree una Session y realice llamadas de inicio/confirmación alrededor de la llamada al método. Todas las excepciones causarán una retrotracción.
- Interfaz de SpringLocalTxManager: la interfaz de SpringLocalTxManager
se implementa mediante Platform Transaction Manager de ObjectGrid
y tiene todas las interfaces públicas. Los métodos de esta interfaz sirven para seleccionar la instancia de ObjectGrid para utilizar en una hebra y obtener una Session para la hebra. Todos los POJO que utilizan las transacciones locales de ObjectGrid deben incluirse con una referencia a esta instancia del gestor y sólo se debe crear una única instancia, es decir, su ámbito debe ser singleton. Esta instancia se crea utilizando un método estático en ObjectGridSpringFactory. getLocalPlatformTransactionManager().
Restricción: WebSphere eXtreme Scale no da soporte a la confirmación en dos fases o JTA por diversas razones, principalmente que tienen que ver con la escalabilidad. Por ello, excepto en el último participante de una única fase,
ObjectGrid no interactúa con transacciones globales de tipo XA o JTA.
Este gestor de plataformas está pensado para hacer que la utilización de transacciones de ObjectGrid locales sea lo más fácil posible para los desarrolladores de Spring.