Comment sérialiser l'objet personnalisé que vous envoyez dans le modèle JMS Méthode Convertir et envoyer

Question

J'utilise le code mentionné ci-dessous pour publier un sujet. Il est du format convertAndSend (destination de destination, un message d'objet)

Event event; 
    jmsTemplate.convertAndSend(topic, event); 

Mon interface actuelle de l'événement est quelque chose comme ça,

public interface Event { 

    public boolean isEmpty(); 

    public AcEventDatafileTransaction getDatafileTransaction(); 

    public AcEventObjectTransaction getObjectTransaction(); 

    boolean isDatafileTransaction(); 

    boolean isObjectTransaction(); 

    boolean isRdbmsTransaction(); 

    String getTransactionId(); 

    } 

Sa mise en œuvre est quelque chose comme ça,

public class EventPublisherImpl implements Event { 
    private final AcTransactionRecord transactionRecord; 
    private final Ac ac; 
    private final String[] actualTemplates; 
    private final String[] curveTemplates; 

    public AcEventPublisherImpl(final Ac ac, 
           final String[] actualTemplates, 
           final String[] curveTemplates, 
           final AcTransactionRecord acTransactionRecord) { 
     this.ac = ac; 
     this.transactionRecord = acTransactionRecord; 
     this.actualTemplates = actualTemplates; 
     this.curveTemplates = curveTemplates; 
    } 

    @Override 
    public boolean isEmpty() { 
     return transactionRecord.isEmpty(); 
    } 

    @Override 
    public AcEventDatafileTransaction getDatafileTransaction() { 
     if (isDatafileTransaction()) { 
      return new AcEventDatafileTransactionPublisherImpl(transactionRecord.getDatafileTransaction()); 
     } 
     return null; 
    } 


    @Override 
    public AcEventObjectTransaction getObjectTransaction() { 
     if (isObjectTransaction()) { 
      return new AcEventObjectTransactionPublisherImpl(ac, actualTemplates, curveTemplates, transactionRecord.getObjectOperations()); 
     } 
     return null; 
    } 

    @Override 
    public boolean isDatafileTransaction() { 
     return transactionRecord.getType() == AcTransactionRecord.DATAFILE_TRANS; 
    } 

    @Override 
    public boolean isObjectTransaction() { 
     return transactionRecord.getType() == AcTransactionRecord.OBJECT_TRANS; 
    } 

    @Override 
    public boolean isRdbmsTransaction() {  
     return transactionRecord.getType() == AcTransactionRecord.RDBMS_TRANS; 
    } 

    @Override 
    public String getTransactionId() { 
     if (transactionRecord != null) { 
      return Integer.toString(transactionRecord.getNumber()); 
     } 
     return ""; 
    } 
    } 

Comment puis-je le convertir en un format sérialisable?

Mon objectif est de publier un objet événement dans un sujet. Pour cela, j'utilise la méthode convertAndSend. Cette méthode nécessite un objet d'une classe sérialisée, que je n'ai pas actuellement. C'est ce que j'essaie d'accomplir. J'ai regardé des exemples où une classe avec quelques attributs est sérialisée en utilisant le convertisseur de message https://examples.javacodegeeks.com/enterprise-java/spring/spring-framework-jmstemplate-example/

S'il vous plaît suggérer une méthode par le biais du code ou pointez sur l'exemple approprié et comment cela m'aide.

Answer 1

Les méthodes surchargées convertAndSend() et receiveAndConvert() déléguer JmsTemplate le processus de conversion à une instance de l'interface MessageConverter. Cette interface définit un contrat simple à convertir entre des objets Java et des messages JMS. L'implémentation par défaut SimpleMessageConverter prend en charge la conversion entre String et TextMessage, byte[] et BytesMesssage et java.util.Map et MapMessage.

Donc, pour soutenir le type de mesure, nous devons créer convertisseur personnalisé qui implémente MessageConverter pour convertir l'objet Event à l'un des type de message pris en charge. La solution la plus simple consiste à enregistrer MappingJackson2MessageConverter fourni par le ressort qui prend en charge la conversion de l'objet à TextMessage sous forme de json.

@Bean // Serialize message content to json using TextMessage 
public MessageConverter jacksonJmsMessageConverter() { 
    MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter(); 
    converter.setTargetType(MessageType.TEXT); 
    converter.setTypeIdPropertyName("_type"); 
    return converter; 
} 

Vous pouvez regarder comment le processus de sérialisation se fait sur le code source si vous voulez créer votre propre convertisseur.

Pour recevoir le message, le plus simple est d'utiliser @JmsListener l'annotation, le printemps convertira implicitement le message à son type java en utilisant le convertisseur enregistré

@Component 
public class Receiver { 
    @JmsListener(destination = "dest") 
    public void receiveMessage(Event event) { 
    // do whatever you need with the event 
    } 
} 

une autre façon est d'utiliser javax.jms.MessageListener mais vous devez manuellement Convertissez le message vous-même.

@Component 
public class ExampleListener implements MessageListener { 

@Autowired 
private ObjectMapper objectMapper; 

public void onMessage(Message message) { 
    if (message instanceof TextMessage) {// we set the converter targetType to text 
     try { 
      String json = ((TextMessage) message).getText(); // here you have your event object as json string 
      Event event = objectMapper.readValue(json, Event.class); // convert back to event object 
     } 
     catch (JMSException ex) { 
      throw new RuntimeException(ex); 
     } 
    } 
    else { 
     throw new IllegalArgumentException("Message must be of type TextMessage"); 
    } 
} 

Ref:

• MappingJackson2MessageConverter
• https://spring.io/guides/gs/messaging-jms/