O Spring é uma estrutura popular para desenvolvimento de aplicativos Java. O
WebSphere eXtreme
Scale fornece suporte para permitir que o
Spring gerencie transações do eXtreme Scale e
configure clientes e servidores eXtreme Scale.
Sobre Esta Tarefa
A Estrutura Spring é altamente integrable com o
eXtreme Scale, conforme discutido nas seções a seguir.
Procedimento
- Transações nativas: O Spring fornece transações gerenciadas por contêiner junto com o estilo de um servidor de aplicativos Java Platform,
Enterprise Edition, mas com a vantagem de que o mecanismo Springs pode ter implementações diferentes conectadas. Este tópico descreve um gerenciador
eXtreme Scale Platform Transaction que pode ser utilizado com o
Spring. Isso permite que os programadores anotem os
Plain Old Java Objects (POJOs),
façam com que o Spring adquira automaticamente Sessões a partir do eXtreme Scale e comecem, confirmem, recuperem, suspendam e continuem as transações do eXtreme Scale. As transações do Spring são descritas mais completamente no Capítulo 10 da documentação oficial de referência do Spring.
O seguinte explica como criar um gerenciador de transações do eXtreme Scale e usá-lo com os POJOs anotados. Ele também explica
como utilizar esta abordagem com o eXtreme Scale cliente ou local,
bem como com um aplicativo do estilo Data Grid.
- Gerenciador de Transação: Para trabalhar com Spring, eXtreme Scale fornece uma implementação de um Spring PlatformTransactionManager. Este gerenciador pode fornecer
sessões gerenciadas do eXtreme Scale para POJOs gerenciados
pelo Spring. Através do uso das anotações, o Spring gerencia essas
sessões para os POJOs em termos de ciclo de vida da transação. O seguinte snippet XML mostra como criar um Gerenciador de transações:
<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>
Isto mostra o bean transactionManager que está sendo
declarado e vinculado ao bean Service que utilizará transações Spring.
Demonstraremos isto utilizando anotações e este é o motivo ara a cláusula
tx:annotation no início.
- Obtendo uma sessão do ObjectGrid:
Um POJO que possui métodos gerenciados pelo Spring agora
podem obter a sessão do ObjectGrid para a transação atual utilizando
Session s = txManager.getSession();
Isto retorna a
sessão para o POJO utilizar. Beans participando na mesma transação
receberão a mesma sessão quando eles chamam este método. O Spring
identificará automaticamente o início para o objeto Session e também
chamará automaticamente o commit ou rollback, quando necessário. Também
é possível obter um EntityManager do ObjectGrid simplesmente chamando
getEntityManager do objeto Session.
- Configurando a instância do ObjectGrid para um encadeamento: Uma única Java Virtual Machine (JVM) pode hospedar várias instâncias do ObjectGrid. Cada shard primário colocado em uma JVM possui sua própria instância
do ObjectGrid. Uma JVM atuando como um cliente para um ObjectGrid remoto utiliza uma
instância do ObjectGrid retornada do ClientClusterContext do método
de conexão para interagir com tal Grade.
Antes de chamar um método
em um POJO utilizando transações Spring para o ObjectGrid, o encadeamento
deve ser primed com a instância do ObjectGrid a utilizar. A instância do
TransactionManager possui um método permitindo que uma instância específica
do ObjectGrid seja especificada. Depois de especificada, todas as chamadas subsequentes do txManager.getSession retornarão Sessões para essa instância de ObjectGrid.
O exemplo a seguir
mostra um principal de amostra para exercitar este recurso:
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");
Aqui, utilizamos um Spring
ApplicationContext. O ApplicationContext é utilizado para obter uma
referência para o txManager e especificar um ObjectGrid a utilizar neste
encadeamento.
O código então obtém uma referência para o serviço e chama métodos nele. Cada
chamada de método neste nível faz com que o Spring crie um objeto Session e
faz chamadas begin/commit em torno da chamada de método. Quaisquer exceções
causarão um retrocesso.
- Interface SpringLocalTxManager: A interface SpringLocalTxManager é implementada pelo ObjectGrid Platform Transaction Manager e possui todas as interfaces públicas. Os métodos nesta interface são utilizados para selecionar a
instância do ObjectGrid para utilizar em um encadeamento e obter um
objeto Session para o encadeamento. Quaisquer POJOs que utilizam transações locais do ObjectGrid devem ser
injetados com uma referência para esta instância do gerenciador e apenas uma única instância
deve ser criada, ou seja, seu escopo deve ser um singleton. Esta instância é criada utilizando um método
estático no ObjectGridSpringFactory.
getLocalPlatformTransactionManager().
Restrição: O WebSphere eXtreme Scale não suporta o JTA ou two-phase commit por vários motivos, principalmente devido à escalabilidade. Assim, exceto em um último participante single-phase, o
ObjectGrid não interage em transações globais do tipo XA ou JTA.
Este gerenciador de plataformas é destinado a tornar o uso de transações
locais do ObjectGrid o mais fácil possível para os desenvolvedores do Spring.