Certainly, would have made more sense.
Currently, in JMS you define interfaces like this to map routes - equivalent
to a CDI Event Bridge - to JMS Destinations (Queues and Topics):
public interfaces MyMappingInterface{
@Inbound
public void handleStrings(@Observes String s, @JmsDestination("jms/MyTopic")
Topic topic);
@Outbound
public void handleLongs(@Observes Long l, @JmsDestination("jms/MyQueue")
Queue queue);
}
This says that a listener will be created for the topic jms/MyTopic and any
TextMessage or ObjectMessage with payload type String.class will be
forwarded to an observer method defined like this:
public void observeStrings(@Observes @Inbound String s) {
}
Likewise, the second line in the interface says that Events of type Long
that are fired with the @Outbound qualifier will be sent to a Queue
jms/MyQueue,
@Inject @Outbound Event<Long> longEvent;
Results in Seam JMS dynamically generating an observer method on deployment
that handles and forwards the long fired.
What I'm proposing is that we do away with (not literally, I would keep it
in) the interface. Instead, we look at the events injected and the
observers defined. The same observer method would be defined like this:
@JMS("jms/MyTopic")
public void observeStrings(@Observes @Inbound String s) {
}
And the injected event:
@Inject @JMS("jms/MyQueue") @Outbound Event<Long> longEvent;
Does that make sense?
John
On Thu, Jun 2, 2011 at 7:49 AM, Pete Muir <pmuir(a)redhat.com> wrote:
On 2 Jun 2011, at 02:29, John D. Ament wrote:
> Something I've been thinking about for a while now is the mapping APIs
used by Seam JMS. Currently, you write an interface to define routes used
by JMS events. This requires a bit of extra code that I'm not a big fan of.
What I was thinking was put an extra annotation on either the injection
point of the event or the observer method. The idea is that the annotation
would include all of the destination configuration necessary. For example:
>
> @Inject
@JMS("jms/QueueOne","jms/QueueTwo","jms/QueueThree")
Event<MyType> myTypeEvent;
>
> @JMS("jms/MyTopic")
> public void handleMessages(@Observes Long longsInTopic) {
>
> ....
>
> }
>
> The issues I see, since essentially I have to create an extra
observer/firing pair to support each of these, is how to determine the
observed type in the event. In general, any thoughts? Is it possible to
determine the event's type in this case? If so, does the approach make
sense?
Can you show what this replaces? I.e. before and after?