legacy/runtime/org.argeo.slc.support.activemq/src/main/java/org/argeo/slc/jms/ServiceMessageListenerAdapter.java

   1 /*
   2  * Copyright (C) 2007-2012 Mathieu Baudier
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *         http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.argeo.slc.jms;
  17
  18 import java.io.PrintWriter;
  19 import java.io.StringWriter;
  20 import java.util.ArrayList;
  21 import java.util.HashMap;
  22 import java.util.List;
  23 import java.util.Map;
  24
  25 import javax.jms.JMSException;
  26 import javax.jms.Message;
  27 import javax.jms.Session;
  28
  29 import org.argeo.slc.SlcException;
  30 import org.argeo.slc.msg.ExecutionAnswer;
  31 import org.springframework.jms.listener.adapter.MessageListenerAdapter;
  32
  33 public class ServiceMessageListenerAdapter extends MessageListenerAdapter {
  34         public final static String DEFAULT_METHOD_NAME_PARAMETER = "action";
  35         public final static String BODY_ARGUMENT = "BODY";
  36
  37         private Map<String, List<String>> methodArguments = new HashMap<String, List<String>>();
  38
  39         private static String methodNameParameter = DEFAULT_METHOD_NAME_PARAMETER;
  40
  41         @Override
  42         protected Object extractMessage(Message message) throws JMSException {
  43                 return new ExtractedMessage(message);
  44         }
  45
  46         @Override
  47         protected String getListenerMethodName(Message originalMessage,
  48                         Object extractedMessage) throws JMSException {
  49                 return ((ExtractedMessage) extractedMessage).methodName;
  50         }
  51
  52         @Override
  53         protected Object[] buildListenerArguments(Object extractedMessage) {
  54                 return ((ExtractedMessage) extractedMessage).arguments;
  55         }
  56
  57         @Override
  58         public void onMessage(Message message, Session session) throws JMSException {
  59                 try {// hacked and simplified from parent class
  60                         // Regular case: find a handler method reflectively.
  61                         Object convertedMessage = extractMessage(message);
  62                         String methodName = getListenerMethodName(message, convertedMessage);
  63
  64                         // Invoke the handler method with appropriate arguments.
  65                         Object[] listenerArguments = buildListenerArguments(convertedMessage);
  66                         Object result = invokeListenerMethod(methodName, listenerArguments);
  67                         if (result != null) {
  68                                 handleResult(result, message, session);
  69                         } else {
  70                                 ExecutionAnswer answer = ExecutionAnswer.ok("Execution of "
  71                                                 + methodName + " on " + getDelegate() + " succeeeded.");
  72                                 Message okMessage = getMessageConverter().toMessage(answer,
  73                                                 session);
  74                                 sendResponse(session, getResponseDestination(message,
  75                                                 okMessage, session), okMessage);
  76                         }
  77                 } catch (Exception e) {
  78                         if (session == null)
  79                                 return;
  80
  81                         StringWriter writer = new StringWriter();
  82                         e.printStackTrace(new PrintWriter(writer));
  83                         ExecutionAnswer answer = ExecutionAnswer.error(writer.toString());
  84                         Message errorMessage = getMessageConverter().toMessage(answer,
  85                                         session);
  86                         sendResponse(session, getResponseDestination(message, errorMessage,
  87                                         session), errorMessage);
  88                 }
  89         }
  90
  91         protected class ExtractedMessage {
  92                 private final String methodName;
  93                 private final Object[] arguments;
  94 //              private final Message originalMessage;
  95
  96                 public ExtractedMessage(Message originalMessage) throws JMSException {
  97 //                      this.originalMessage = originalMessage;
  98
  99                         if (!originalMessage.propertyExists(methodNameParameter))
 100                                 throw new SlcException("No property " + methodNameParameter
 101                                                 + " in incoming message,"
 102                                                 + " cannot determine service method");
 103
 104                         methodName = originalMessage.getStringProperty(methodNameParameter);
 105
 106                         if (!methodArguments.containsKey(methodName)) {// no arg specified
 107                                 arguments = new Object[0];
 108                         } else {
 109                                 List<String> parameterNames = methodArguments.get(methodName);
 110                                 List<Object> arguments = new ArrayList<Object>();
 111                                 int count = 0;
 112                                 for (String name : parameterNames) {
 113                                         if (name.equals(BODY_ARGUMENT)) {
 114                                                 Object body = getMessageConverter().fromMessage(
 115                                                                 originalMessage);
 116                                                 arguments.add(body);
 117                                         } else {
 118                                                 if (!originalMessage.propertyExists(name))
 119                                                         throw new SlcException("No property " + name
 120                                                                         + " in incoming message,"
 121                                                                         + " cannot determine argument #" + count);
 122                                                 arguments.add(originalMessage.getObjectProperty(name));
 123                                         }
 124                                         count++;
 125                                 }
 126                                 this.arguments = arguments.toArray();
 127                         }
 128                 }
 129         }
 130
 131         public void setMethodArguments(Map<String, List<String>> methodArguments) {
 132                 this.methodArguments = methodArguments;
 133         }
 134
 135         public static void setMethodNameParameter(String methodNameParameter) {
 136                 ServiceMessageListenerAdapter.methodNameParameter = methodNameParameter;
 137         }
 138
 139
 140 }