Package org.springframework.jca.endpoint

# Class GenericMessageEndpointManager

java.lang.Object
org.springframework.jca.endpoint.GenericMessageEndpointManager

All Implemented Interfaces:
  `org.springframework.beans.factory.DisposableBean`, `org.springframework.beans.factory.InitializingBean`, `org.springframework.context.Lifecycle`, `org.springframework.context.Phased`, `org.springframework.context.SmartLifecycle`

public class GenericMessageEndpointManager extends Object implements org.springframework.context.SmartLifecycle, org.springframework.beans.factory.InitializingBean, org.springframework.beans.factory.DisposableBean
Generic bean that manages JCA 1.7 message endpoints within a Spring application context, activating and deactivating the endpoint as part of the application context's lifecycle.

This class is completely generic in that it may work with any ResourceAdapter, any MessageEndpointFactory, and any ActivationSpec. It can be configured in standard bean style, for example through Spring's XML bean definition format, as follows:

     <bean class="org.springframework.jca.endpoint.GenericMessageEndpointManager">
      <property name="resourceAdapter" ref="resourceAdapter"/>
      <property name="messageEndpointFactory">
        <bean class="org.springframework.jca.endpoint.GenericMessageEndpointFactory">
          <property name="messageListener" ref="messageListener"/>
        </bean>
      </property>
      <property name="activationSpec">
        <bean class="org.apache.activemq.ra.ActiveMQActivationSpec">
          <property name="destination" value="myQueue"/>
          <property name="destinationType" value="jakarta.jms.Queue"/>
        </bean>
      </property>
     </bean>

In this example, Spring's own `GenericMessageEndpointFactory` is used to point to a standard message listener object that happens to be supported by the specified target ResourceAdapter: in this case, a JMS `jakarta.jms.MessageListener` object as supported by the ActiveMQ message broker, defined as a Spring bean:

     <bean id="messageListener" class="com.myorg.messaging.myMessageListener">
       <!-- ... -->
     </bean>

The target ResourceAdapter may be configured as a local Spring bean as well (the typical case) or obtained from JNDI. For the example above, a local ResourceAdapter bean could be defined as follows (matching the "resourceAdapter" bean reference above):

     <bean id="resourceAdapter" class="org.springframework.jca.support.ResourceAdapterFactoryBean">
      <property name="resourceAdapter">
        <bean class="org.apache.activemq.ra.ActiveMQResourceAdapter">
          <property name="serverUrl" value="tcp://localhost:61616"/>
        </bean>
      </property>
      <property name="workManager">
        <bean class="..."/>
      </property>
     </bean>

For a different target resource, the configuration would simply point to a different ResourceAdapter and a different ActivationSpec object (which are both specific to the resource provider), and possibly a different message listener (for example, a CCI `MessageListener` for a resource adapter which is based on the JCA Common Client Interface).

The asynchronous execution strategy can be customized through the "workManager" property on the ResourceAdapterFactoryBean as shown above, where `<bean class="..."/>` should be replaced with configuration for any JCA-compliant `WorkManager`.

Transactional execution is a responsibility of the concrete message endpoint, as built by the specified MessageEndpointFactory. `GenericMessageEndpointFactory` supports XA transaction participation through its "transactionManager" property, typically with a Spring `JtaTransactionManager` or a plain `TransactionManager` implementation specified there.

     <bean class="org.springframework.jca.endpoint.GenericMessageEndpointManager">
      <property name="resourceAdapter" ref="resourceAdapter"/>
      <property name="messageEndpointFactory">
        <bean class="org.springframework.jca.endpoint.GenericMessageEndpointFactory">
          <property name="messageListener" ref="messageListener"/>
          <property name="transactionManager" ref="transactionManager"/>
        </bean>
      </property>
      <property name="activationSpec">
        <bean class="org.apache.activemq.ra.ActiveMQActivationSpec">
          <property name="destination" value="myQueue"/>
          <property name="destinationType" value="jakarta.jms.Queue"/>
        </bean>
      </property>
     </bean>

     <bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager"/>

Alternatively, check out your resource provider's ActivationSpec object, which should support local transactions through a provider-specific config flag, for example, ActiveMQActivationSpec's "useRAManagedTransaction" bean property.

     <bean class="org.springframework.jca.endpoint.GenericMessageEndpointManager">
      <property name="resourceAdapter" ref="resourceAdapter"/>
      <property name="messageEndpointFactory">
        <bean class="org.springframework.jca.endpoint.GenericMessageEndpointFactory">
          <property name="messageListener" ref="messageListener"/>
        </bean>
      </property>
      <property name="activationSpec">
        <bean class="org.apache.activemq.ra.ActiveMQActivationSpec">
          <property name="destination" value="myQueue"/>
          <property name="destinationType" value="jakarta.jms.Queue"/>
          <property name="useRAManagedTransaction" value="true"/>
        </bean>
      </property>
     </bean>

Since:
  2.5
Author:
  Juergen Hoeller
See Also:
  - `ResourceAdapter.endpointActivation(jakarta.resource.spi.endpoint.MessageEndpointFactory, jakarta.resource.spi.ActivationSpec)`
  - `ResourceAdapter.endpointDeactivation(jakarta.resource.spi.endpoint.MessageEndpointFactory, jakarta.resource.spi.ActivationSpec)`
  - `MessageEndpointFactory`
  - `ActivationSpec`

## Field Summary

### Fields inherited from interface org.springframework.context.SmartLifecycle

`DEFAULT_PHASE`

## Constructor Summary

Constructors
Constructor
Description
`GenericMessageEndpointManager()`

## Method Summary

Modifier and Type
Method
Description
`void`
`afterPropertiesSet()`
Prepares the message endpoint, and automatically activates it if the "autoStartup" flag is set to "true".
`void`
`destroy()`
Deactivates the message endpoint, preparing it for shutdown.
`ActivationSpec`
`getActivationSpec()`
Return the JCA ActivationSpec to use for activating the endpoint.
`MessageEndpointFactory`
`getMessageEndpointFactory()`
Return the JCA MessageEndpointFactory to activate.
`int`
`getPhase()`
Return the phase in which this endpoint manager will be started and stopped.
`ResourceAdapter`
`getResourceAdapter()`
Return the JCA ResourceAdapter to manage endpoints for.
`boolean`
`isAutoStartup()`
Return the value for the 'autoStartup' property.
`boolean`
`isRunning()`
Return whether the configured message endpoint is currently active.
`void`
`setActivationSpec(ActivationSpec activationSpec)`
Set the JCA ActivationSpec to use for activating the endpoint.
`void`
`setAutoStartup(boolean autoStartup)`
Set whether to auto-start the endpoint activation after this endpoint manager has been initialized and the context has been refreshed.
`void`
`setMessageEndpointFactory(MessageEndpointFactory messageEndpointFactory)`
Set the JCA MessageEndpointFactory to activate, pointing to a MessageListener object that the endpoints will delegate to.
`void`
`setPhase(int phase)`
Specify the phase in which this endpoint manager should be started and stopped.
`void`
`setResourceAdapter(ResourceAdapter resourceAdapter)`
Set the JCA ResourceAdapter to manage endpoints for.
`void`
`start()`
Activates the configured message endpoint.
`void`
`stop()`
Deactivates the configured message endpoint.
`void`
`stop(Runnable callback)`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Constructor Details

### GenericMessageEndpointManager

public GenericMessageEndpointManager()

## Method Details

### setResourceAdapter

public void setResourceAdapter(@Nullable ResourceAdapter resourceAdapter)
Set the JCA ResourceAdapter to manage endpoints for.

### getResourceAdapter

@Nullable public ResourceAdapter getResourceAdapter()
Return the JCA ResourceAdapter to manage endpoints for.

### setMessageEndpointFactory

public void setMessageEndpointFactory(@Nullable MessageEndpointFactory messageEndpointFactory)
Set the JCA MessageEndpointFactory to activate, pointing to a MessageListener object that the endpoints will delegate to.

A MessageEndpointFactory instance may be shared across multiple endpoints (i.e. multiple GenericMessageEndpointManager instances), with different `ActivationSpec` objects applied.

See Also:
  - `GenericMessageEndpointFactory.setMessageListener(java.lang.Object)`

### getMessageEndpointFactory

@Nullable public MessageEndpointFactory getMessageEndpointFactory()
Return the JCA MessageEndpointFactory to activate.

### setActivationSpec

public void setActivationSpec(@Nullable ActivationSpec activationSpec)
Set the JCA ActivationSpec to use for activating the endpoint.

Note that this ActivationSpec instance should not be shared across multiple ResourceAdapter instances.

### getActivationSpec

@Nullable public ActivationSpec getActivationSpec()
Return the JCA ActivationSpec to use for activating the endpoint.

### setAutoStartup

public void setAutoStartup(boolean autoStartup)
Set whether to auto-start the endpoint activation after this endpoint manager has been initialized and the context has been refreshed.

Default is "true". Turn this flag off to defer the endpoint activation until an explicit `start()` call.

### isAutoStartup

public boolean isAutoStartup()
Return the value for the 'autoStartup' property. If "true", this endpoint manager will start upon a ContextRefreshedEvent.

Specified by:
  `isAutoStartup` in interface `org.springframework.context.SmartLifecycle`

### setPhase

public void setPhase(int phase)
Specify the phase in which this endpoint manager should be started and stopped. The startup order proceeds from lowest to highest, and the shutdown order is the reverse of that. By default, this value is `Integer.MAX_VALUE` meaning that this endpoint manager starts as late as possible and stops as soon as possible.

### getPhase

public int getPhase()
Return the phase in which this endpoint manager will be started and stopped.

Specified by:
  `getPhase` in interface `org.springframework.context.Phased`
Specified by:
  `getPhase` in interface `org.springframework.context.SmartLifecycle`

### afterPropertiesSet

public void afterPropertiesSet() throws ResourceException
Prepares the message endpoint, and automatically activates it if the "autoStartup" flag is set to "true".

Specified by:
  `afterPropertiesSet` in interface `org.springframework.beans.factory.InitializingBean`
Throws:
  `ResourceException`

### start

public void start()
Activates the configured message endpoint.

Specified by:
  `start` in interface `org.springframework.context.Lifecycle`

### stop

public void stop()
Deactivates the configured message endpoint.

Specified by:
  `stop` in interface `org.springframework.context.Lifecycle`

### stop

public void stop(Runnable callback)

Specified by:
  `stop` in interface `org.springframework.context.SmartLifecycle`

### isRunning

public boolean isRunning()
Return whether the configured message endpoint is currently active.

Specified by:
  `isRunning` in interface `org.springframework.context.Lifecycle`

### destroy

public void destroy()
Deactivates the message endpoint, preparing it for shutdown.

Specified by:
  `destroy` in interface `org.springframework.beans.factory.DisposableBean`