Comment imbriquer Spring MessageConverters de JMS

Question

J'aimerais écrire une classe MessageConverter qui peut envelopper un autre MessageConverter. Ce MessageConverter appelle le convertisseur enfant, qui est supposé générer un TextMessage. Cela prendrait la charge utile et GZIP le compresserait, créant un BytesMessage qui serait finalement renvoyé à l'expéditeur.

Le problème est écrit à partir deMessage (). Je peux reconvertir la charge en chaîne, mais je souhaite ensuite créer un "factice". TextMessage dans lequel insérer la chaîne à transmettre à la méthode fromMessage () de MessageConverter enfant. Là, je frappe un mur de briques parce que je ne peux pas créer de TextMessage sans un objet de session JMS et il semble qu’il n’ya aucun moyen d’obtenir une session dans ce contexte.

Je pourrais créer des propriétés supplémentaires pour connecter davantage d'objets à cette classe, mais il ne semble pas que je puisse facilement obtenir une session à partir d'un objet JMSTemplate, et je ne peux pas imaginer ce qu'il me faudrait d'autre. .

Je suis sur le point de créer une implémentation TextMessage privée dans ce code uniquement dans le but d'encapsuler une chaîne pour le MessageConverter enfant. Cette classe nécessitera des tonnes de méthodes factices pour étoffer l'interface, et toute cette dactylographie fait pleurer l'enfant Jésus.

Quelqu'un peut-il suggérer un meilleur moyen?

Answer 1

En fait, j’en ai donc créé un:

    private static class FakeTextMessage implements TextMessage {
            public FakeTextMessage(Message m) { this.childMessage = m; }
            private String text;
            private Message childMessage;
            public void setText(String t) { this.text = t; }
            public String getText() { return this.text; }

            // All the rest of the methods are simply pass-through
            // implementations of the rest of the interface, handing off to the child message.
            public void acknowledge() throws JMSException { this.childMessage.acknowledge(); }
            public void clearBody() throws JMSException { this.childMessage.clearBody(); }
            public void clearProperties() throws JMSException { this.childMessage.clearProperties(); }
            public Enumeration getPropertyNames() throws JMSException { return this.childMessage.getPropertyNames(); }
            public boolean propertyExists(String pn) throws JMSException { return this.childMessage.propertyExists(pn); }

            // and so on and so on
    }

Me fait aspirer à l'objectif C. Comment est-ce possible? :)

Answer 2

Voulez-vous vraiment insérer des instances MessageConverter dans d'autres instances MessageConverter? L'intérêt d'un MessageConverter est de transformer un message en quelque chose d'autre (qui n'est pas un message JMS). Ce n’est pas vraiment conçu pour les chaîner (chaque étape créant un faux message JMS).

Pourquoi ne pas simplement introduire votre propre interface

interface MessageBodyConverter {
  /** return a converted body of the original message */
  Object convert(Object body, Message originalMessage);
}

Vous pouvez ensuite créer un MessageConverter invoquant l'un de ces éléments (qui peut ensuite imbriquer aussi profondément que vous le souhaitez)

class MyMessageConverter implements MessageConverter {
  private final MessageBodyConverter converter;

  public Object fromMessage(Message message) {
    if (message instanceof ObjectMessage) {
       return converter.convert(objectMessage.getObject(), message);
    ...
  }
}

Vous pouvez ensuite chaîner ces objets MessageBodyConverter aussi profondément que vous le souhaitez. De plus, vous avez accès au message JMS d'origine (pour obtenir des en-têtes, etc.) sans avoir à créer de pseudo implémentations (probablement non conformes à JMS) de Message?