Class JmsInvokerClientInterceptor

Constructor Detail

• JmsInvokerClientInterceptor

  public JmsInvokerClientInterceptor()

Method Detail

• setConnectionFactory

  public void setConnectionFactory​(ConnectionFactory connectionFactory)

  Set the QueueConnectionFactory to use for obtaining JMS QueueConnections.

• getConnectionFactory

  protected ConnectionFactory getConnectionFactory()

  Return the QueueConnectionFactory to use for obtaining JMS QueueConnections.

• setQueue

  public void setQueue​(Queue queue)

  Set the target Queue to send invoker requests to.

• setQueueName

  public void setQueueName​(String queueName)

  Set the name of target queue to send invoker requests to.

  The specified name will be dynamically resolved via the DestinationResolver.

• setDestinationResolver

  public void setDestinationResolver​(DestinationResolver destinationResolver)

  Set the DestinationResolver that is to be used to resolve Queue references for this accessor.

  The default resolver is a DynamicDestinationResolver. Specify a JndiDestinationResolver for resolving destination names as JNDI locations.

  See Also:

  DynamicDestinationResolver, JndiDestinationResolver

• setRemoteInvocationFactory

  public void setRemoteInvocationFactory​(RemoteInvocationFactory remoteInvocationFactory)

  Set the RemoteInvocationFactory to use for this accessor.

  Default is a DefaultRemoteInvocationFactory.

  A custom invocation factory can add further context information to the invocation, for example user credentials.

• setMessageConverter

  public void setMessageConverter​(MessageConverter messageConverter)

  Specify the MessageConverter to use for turning RemoteInvocation objects into request messages, as well as response messages into RemoteInvocationResult objects.

  Default is a SimpleMessageConverter, using a standard JMS ObjectMessage for each invocation / invocation result object.

  Custom implementations may generally adapt Serializable objects into special kinds of messages, or might be specifically tailored for translating RemoteInvocation(Result)s into specific kinds of messages.

• setReceiveTimeout

  public void setReceiveTimeout​(long receiveTimeout)

  Set the timeout to use for receiving the response message for a request (in milliseconds).

  The default is 0, which indicates a blocking receive without timeout.

  See Also:

  MessageConsumer.receive(long), MessageConsumer.receive()

• getReceiveTimeout

  protected long getReceiveTimeout()

  Return the timeout to use for receiving the response message for a request (in milliseconds).

• afterPropertiesSet

  public void afterPropertiesSet()

  Description copied from interface: InitializingBean
  Invoked by the containing BeanFactory after it has set all bean properties and satisfied BeanFactoryAware, ApplicationContextAware etc.

  This method allows the bean instance to perform validation of its overall configuration and final initialization when all bean properties have been set.

  Specified by:

  afterPropertiesSet in interface InitializingBean

• invoke

  public Object invoke​(MethodInvocation methodInvocation)
                throws Throwable

  Description copied from interface: MethodInterceptor
  Implement this method to perform extra treatments before and after the invocation. Polite implementations would certainly like to invoke Joinpoint.proceed().

  Specified by:

  invoke in interface MethodInterceptor

  Parameters:

  methodInvocation - the method invocation joinpoint

  Returns:

  the result of the call to Joinpoint.proceed(); might be intercepted by the interceptor

  Throws:

  Throwable - if the interceptors or the target object throws an exception

• createRemoteInvocation

  protected RemoteInvocation createRemoteInvocation​(MethodInvocation methodInvocation)

  Create a new RemoteInvocation object for the given AOP method invocation.

  The default implementation delegates to the RemoteInvocationFactory.

  Can be overridden in subclasses to provide custom RemoteInvocation subclasses, containing additional invocation parameters like user credentials. Note that it is preferable to use a custom RemoteInvocationFactory which is a reusable strategy.

  Parameters:

  methodInvocation - the current AOP method invocation

  Returns:

  the RemoteInvocation object

  See Also:

  RemoteInvocationFactory.createRemoteInvocation(org.aopalliance.intercept.MethodInvocation)

• executeRequest

  protected RemoteInvocationResult executeRequest​(RemoteInvocation invocation)
                                           throws JMSException

  Execute the given remote invocation, sending an invoker request message to this accessor's target queue and waiting for a corresponding response.

  Parameters:

  invocation - the RemoteInvocation to execute

  Returns:

  the RemoteInvocationResult object

  Throws:

  JMSException - in case of JMS failure

  See Also:

  doExecuteRequest(javax.jms.Session, javax.jms.Queue, javax.jms.Message)

• createConnection

  protected Connection createConnection()
                                 throws JMSException

  Create a new JMS Connection for this JMS invoker.

  Throws:

  JMSException

• createSession

  protected Session createSession​(Connection con)
                           throws JMSException

  Create a new JMS Session for this JMS invoker.

  Throws:

  JMSException

• resolveQueue

  protected Queue resolveQueue​(Session session)
                        throws JMSException

  Resolve this accessor's target queue.

  Parameters:

  session - the current JMS Session

  Returns:

  the resolved target Queue

  Throws:

  JMSException - if resolution failed

• resolveQueueName

  protected Queue resolveQueueName​(Session session,
                                   String queueName)
                            throws JMSException

  Resolve the given queue name into a JMS Queue, via this accessor's DestinationResolver.

  Parameters:

  session - the current JMS Session

  queueName - the name of the queue

  Returns:

  the located Queue

  Throws:

  JMSException - if resolution failed

  See Also:

  setDestinationResolver(org.springframework.jms.support.destination.DestinationResolver)

• createRequestMessage

  protected Message createRequestMessage​(Session session,
                                         RemoteInvocation invocation)
                                  throws JMSException

  Create the invoker request message.

  The default implementation creates a JMS ObjectMessage for the given RemoteInvocation object.

  Parameters:

  session - the current JMS Session

  invocation - the remote invocation to send

  Returns:

  the JMS Message to send

  Throws:

  JMSException - if the message could not be created

• doExecuteRequest

  protected Message doExecuteRequest​(Session session,
                                     Queue queue,
                                     Message requestMessage)
                              throws JMSException

  Actually execute the given request, sending the invoker request message to the specified target queue and waiting for a corresponding response.

  The default implementation is based on standard JMS send/receive, using a TemporaryQueue for receiving the response.

  Parameters:

  session - the JMS Session to use

  queue - the resolved target Queue to send to

  requestMessage - the JMS Message to send

  Returns:

  the RemoteInvocationResult object

  Throws:

  JMSException - in case of JMS failure

• extractInvocationResult

  protected RemoteInvocationResult extractInvocationResult​(Message responseMessage)
                                                    throws JMSException

  Extract the invocation result from the response message.

  The default implementation expects a JMS ObjectMessage carrying a RemoteInvocationResult object. If an invalid response message is encountered, the onInvalidResponse callback gets invoked.

  Parameters:

  responseMessage - the response message

  Returns:

  the invocation result

  Throws:

  JMSException - is thrown if a JMS exception occurs

  See Also:

  onInvalidResponse(javax.jms.Message)

• onReceiveTimeout

  protected RemoteInvocationResult onReceiveTimeout​(RemoteInvocation invocation)

  Callback that is invoked by executeRequest(org.springframework.remoting.support.RemoteInvocation) when the receive timeout has expired for the specified RemoteInvocation.

  By default, an RemoteTimeoutException is thrown. Sub-classes can choose to either throw a more dedicated exception or even return a default RemoteInvocationResult as a fallback.

  Parameters:

  invocation - the invocation

  Returns:

  a default result when the receive timeout has expired

• onInvalidResponse

  protected RemoteInvocationResult onInvalidResponse​(Message responseMessage)
                                              throws JMSException

  Callback that is invoked by extractInvocationResult(javax.jms.Message) when it encounters an invalid response message.

  The default implementation throws a MessageFormatException.

  Parameters:

  responseMessage - the invalid response message

  Returns:

  an alternative invocation result that should be returned to the caller (if desired)

  Throws:

  JMSException - if the invalid response should lead to an infrastructure exception propagated to the caller

  See Also:

  extractInvocationResult(javax.jms.Message)

• recreateRemoteInvocationResult

  protected Object recreateRemoteInvocationResult​(RemoteInvocationResult result)
                                           throws Throwable

  Recreate the invocation result contained in the given RemoteInvocationResult object.

  The default implementation calls the default recreate() method.

  Can be overridden in subclasses to provide custom recreation, potentially processing the returned result object.

  Parameters:

  result - the RemoteInvocationResult to recreate

  Returns:

  a return value if the invocation result is a successful return

  Throws:

  Throwable - if the invocation result is an exception

  See Also:

  RemoteInvocationResult.recreate()

• convertJmsInvokerAccessException

  protected RemoteAccessException convertJmsInvokerAccessException​(JMSException ex)

  Convert the given JMS invoker access exception to an appropriate Spring RemoteAccessException.

  Parameters:

  ex - the exception to convert

  Returns:

  the RemoteAccessException to throw