Messaging Pattern

Question

Hi,
Back Ground – We are building claim-processing system. Currently we are using AQ as a load balancer and spring MDP (in concurrent threads) that grabs the messages from the queue and start claim processing. I see in case heavy load the AQ can itself become a bottleneck and hence want to replace the AQ with Coherence and leverage the Messaging Pattern.
MDP – Message Driver Pojos
I have following questions on the Messaging Pattern
1.     Can the Coherence’s Messaging Pattern framework replace AQ?
2.     If answer to the above question is ‘yes’, how can we make ‘queue’ durable i.e. guarantee that no messages are lost.
3.     How many messages can be delivered per second using coherence?
Regards,
Gaurav Malhotra

Answer 1

Hi All,
I also integrated oracle coherence with spring integration. This enables the developer to work with pojos
Concept
Make a channel backed by oracle coherence as queue.
So I extended the queue channel as follows
>
public class CoherenceAwareQueueChannel extends QueueChannel {
     private final static String nameOfQueue = "aq";
     private NamedCache queueNamedCache = null;
     private NamedCache jmsIdNamedCache = null;
     public static final String JMS_ID_CACHE = "jmsMsgId";
     public static final String JMS_ID_KEY_GEN = "jmsIdKeyGen";
     public CoherenceAwareQueueChannel() {
          // do nothing
     public CoherenceAwareQueueChannel(int capacity) {
          // do nothing
     private NamedCache getQueueNamedCache() {
          if (queueNamedCache == null) {
               queueNamedCache = CacheFactory.getCache(nameOfQueue);
          return queueNamedCache;
     private long getJmsId() {
          long retVal = 0;
          getJmsNamedCache();
          JmsMsgId jmsMsgId = (JmsMsgId) jmsIdNamedCache.get(JMS_ID_KEY_GEN);
          if (jmsMsgId == null) {
               jmsMsgId = new JmsMsgId();
               retVal = jmsMsgId.getJmsId();
               jmsIdNamedCache.put(JMS_ID_KEY_GEN, jmsMsgId);
          } else {
               retVal = jmsMsgId.getJmsId();
               jmsIdNamedCache.put(JMS_ID_KEY_GEN, jmsMsgId);
          return retVal;
     private void getJmsNamedCache() {
          if (jmsIdNamedCache == null) {
               jmsIdNamedCache = CacheFactory.getCache(JMS_ID_CACHE);
     @Override
     public List<Message<?>> clear() {
          List<Message<?>> clearedMessages = new ArrayList<Message<?>>();
          Set<?> keys = getQueueNamedCache().keySet();
          for (Object key : keys) {
               clearedMessages.add((Message<?>) getQueueNamedCache().get(key));
          getQueueNamedCache().clear();
          return clearedMessages;
     @Override
     protected Message<?> doReceive(long timeout) {
          // What is the key? Top element of the key
          getJmsNamedCache();
          JmsMsgId jmsId = (JmsMsgId) jmsIdNamedCache.get(JMS_ID_KEY_GEN);
          Long currJmsId = jmsId.getCurrentJmsId();
          Assert.assertNotNull(currJmsId);
          Message<?> msg = (Message<?>) getQueueNamedCache().remove(currJmsId);
          jmsId.resetBy(1);
          jmsIdNamedCache.put(JMS_ID_KEY_GEN, jmsId);
          return msg;
     @Override
     protected boolean doSend(Message<?> message, long timeout) {
          Object jmsId = message.getHeaders().get(JmsHeaders.MESSAGE_ID); // take control
          Object id = (jmsId == null ? getJmsId() : jmsId);
          getQueueNamedCache().put(id, message,timeout);
          return true;
     @Override
     public int getQueueSize() {
          return queueNamedCache.size();
     @Override
     public int getRemainingCapacity() {
          return 999999999; // there is not limit
     @Override
     public List<Message<?>> purge(MessageSelector selector) {
          if (selector == null) {
               return this.clear();
          Set<?> keys = getQueueNamedCache().keySet();
          List<Message<?>> purgedMessages = new ArrayList<Message<?>>();
          for (Object key : keys) {
               Message<?> msg = (Message<?>) getQueueNamedCache().get(key);
               if (!selector.accept(msg) && this.getQueueNamedCache().remove(key) != null) {
                    purgedMessages.add(msg);
          return purgedMessages;
     public static class JmsMsgId implements ExternalizableLite {
          private static final long serialVersionUID = 1L;
          private long cnt = 0;
          public JmsMsgId() {
          public long getJmsId(){
               return ++cnt;
          public long getCurrentJmsId() {
               return cnt;
          public void resetBy(long cnt) {
               this.cnt = this.cnt - cnt;
          @Override
          public void readExternal(DataInput in) throws IOException {
               cnt = ExternalizableHelper.readLong(in);
          @Override
          public void writeExternal(DataOutput out) throws IOException {
               ExternalizableHelper.writeLong(out, cnt);
}My aq based cache store looks like
public class AqCacheStore extends AbstractCacheStore {
     @Autowired
     private JmsTemplate jmsTemplate;
     // TODO provide pluggable transformation strategy which convert CoherenceMessage to javax.jms.Message
     @SuppressWarnings("unchecked")
     @Override
     public void store(Object msgId, Object jmsMsg) {
          Assert.isTrue((jmsMsg instanceof GenericMessage));
          // TODO we should restrict the payload ad String
          jmsTemplate.send(JmsHelper.createJmsTextMessage(((GenericMessage) jmsMsg).getPayload().toString(),((GenericMessage) >jmsMsg).getHeaders().get(JmsHeaders.TYPE).toString()));
     @Override
     public Object load(Object msgId) {
          throw new IllegalArgumentException("Message should never be loaded..");
     @Override
     public void erase(Object msgId) {
          if (msgId != null) {
               jmsTemplate.receiveSelected("JMSMessageID = 'ID:" + msgId + "'");
          } else {
               jmsTemplate.receive();
     @Override
     public void eraseAll(Collection msgIds) {
          for (Object msgId : msgIds) {
               erase(msgId);
     @SuppressWarnings("unchecked")
     @Override
     public void storeAll(Map msgMap) {
          for (Iterator<Map.Entry> iter = msgMap.entrySet().iterator(); iter.hasNext();) {
Map.Entry entry = iter.next();
Object jmsMsg = entry.getValue();
jmsTemplate.send(JmsHelper.createJmsMessage(jmsMsg));
}My junit test cases looks like
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:com/oracle/aq/cachestore/junit/AqContext.xml" })
public class AqCacheStoreTest {
     @Autowired
     private AqCacheStore aqCacheStore;
     @Autowired
     private JmsTemplate jmsTemplate;
     @Autowired
     private QueueChannel coherenceQueue;
     @Autowired
     private PollingConsumer coherenceConsumer;
     @Test
     public void sendSIMsgToCoherenceQueueChannel() throws InterruptedException,
               JMSException {
          Assert.assertNotNull(aqCacheStore);
          Message<String> message = MessageBuilder.withPayload("gaurav in cache")
                    .setHeader(JmsHeaders.TYPE, "sometype").build();
          coherenceQueue.send(message);
          coherenceQueue.send(message);
     @Test
     public void recieveSIMsgFromCoherenceQueueChannel() {
          Assert.assertNotNull(aqCacheStore);
          Message<String> msg = (Message<String>) coherenceQueue.receive();
          System.err.println("^^^^^^^^^^^^^^^^^^^^^^^"+msg.getPayload());
          msg = (Message<String>) coherenceQueue.receive();
          System.err.println(">>>>>>>>>>>>>"+msg.getPayload());          
     public static class ServiceActivator {
          public void onMessage(Message<?> msg) {
               System.err.println("%%%%" + msg.getPayload());
}Conclusion
Message can be stored in both AQ and coherence and hence can be used for store and forward of messages, which are also persisted. I have used spring integration GenericMessage<T> and provide injectable strategy to convert to JMS message and visa versa Why??? javax.jms.Message is not serializable. By this we can leverage both power of bothcoherence and AQ. Also programming model encourages POJO driver coding and JMS specifications
Looking forward for the valuable feedback from the community.