How to use

getPayload

method

in

org.springframework.messaging.support.GenericMessage

public Message<?> acceptMessageSubclassAndReturnMessage(GenericMessage<String> m) {
  return new GenericMessage<String>(m.getPayload() + "-5");
}

public GenericMessage<String> acceptMessageSubclassAndReturnMessageSubclass(GenericMessage<String> m) {
  return new GenericMessage<String>(m.getPayload() + "-6");
}

@PostConstruct
public void init() {
  SubscribableChannel subscribableChannel = userMessage.input();
  subscribableChannel.subscribe(message -> {
    System.out.println("Subscribe by SubscribableChannel");
    String contentType = message.getHeaders().get("contentType", String.class);
    if ("text/plain".equals(contentType)) {
      try {
        saveUser((String) message.getPayload());
      } catch (IOException e) {
        e.printStackTrace();
      }
    } else {
      // message body 是字节流 byte[]
      byte[] body = (byte[]) message.getPayload();
      saveUser(body);
    }
  });
  // 监听 ActiveMQ Stream
  userMessage.activeMQIn().subscribe(message -> {
    if (message instanceof GenericMessage) {
      GenericMessage genericMessage = (GenericMessage) message;
      User user = (User) genericMessage.getPayload();
      userService.saveUser(user);
    }
  });
}

@PostConstruct
public void init() {
  SubscribableChannel subscribableChannel = userMessage.input();
  subscribableChannel.subscribe(message -> {
    System.out.println("Subscribe by SubscribableChannel");
    String contentType = message.getHeaders().get("contentType", String.class);
    if ("text/plain".equals(contentType)) {
      try {
        saveUser((String) message.getPayload());
      } catch (IOException e) {
        e.printStackTrace();
      }
    } else {
      // message body 是字节流 byte[]
      byte[] body = (byte[]) message.getPayload();
      saveUser(body);
    }
  });
  // 监听 ActiveMQ Stream
  userMessage.activeMQIn().subscribe(message -> {
    if (message instanceof GenericMessage) {
      GenericMessage genericMessage = (GenericMessage) message;
      User user = (User) genericMessage.getPayload();
      userService.saveUser(user);
    }
  });
}

@PostConstruct
public void init() {
  SubscribableChannel subscribableChannel = userMessage.input();
  subscribableChannel.subscribe(message -> {
    System.out.println("Subscribe by SubscribableChannel");
    String contentType = message.getHeaders().get("contentType", String.class);
    if ("text/plain".equals(contentType)) {
      try {
        saveUser((String) message.getPayload());
      } catch (IOException e) {
        e.printStackTrace();
      }
    } else {
      // message body 是字节流 byte[]
      byte[] body = (byte[]) message.getPayload();
      saveUser(body);
    }
  });
  // 监听 ActiveMQ Stream
  userMessage.activeMQIn().subscribe(message -> {
    if (message instanceof GenericMessage) {
      GenericMessage genericMessage = (GenericMessage) message;
      User user = (User) genericMessage.getPayload();
      userService.saveUser(user);
    }
  });
}

@SuppressWarnings("unchecked")
@Test
public void testMarshalling() throws Exception {
  JaxbAnnotatedPerson person = new JaxbAnnotatedPerson();
  person.setFirstName("john");
  marshallIn.send(new GenericMessage<Object>(person));
  GenericMessage<Result> res = (GenericMessage<Result>) marshalledOut.receive(2000);
  assertNotNull("No response recevied", res);
  assertTrue("payload was not a DOMResult", res.getPayload() instanceof DOMResult);
  Document doc = (Document) ((DOMResult) res.getPayload()).getNode();
  assertEquals("Wrong name for root element ", "person", doc.getDocumentElement().getLocalName());
}

@Test
public void testEmbedSome() throws Exception {
  EmbeddedJsonHeadersMessageMapper mapper = new EmbeddedJsonHeadersMessageMapper(MessageHeaders.ID);
  GenericMessage<String> message = new GenericMessage<>("foo");
  byte[] encodedMessage = mapper.fromMessage(message);
  Message<?> decoded = mapper.toMessage(encodedMessage);
  assertThat(decoded.getPayload()).isEqualTo(message.getPayload());
  assertThat(decoded.getHeaders().getTimestamp()).isNotEqualTo(message.getHeaders().getTimestamp());
  ObjectMapper objectMapper = new ObjectMapper();
  Map<String, Object> encodedMessageToCheck =
      objectMapper.readValue(encodedMessage, new TypeReference<Map<String, Object>>() {
      });
  Object headers = encodedMessageToCheck.get("headers");
  assertThat(headers).isNotNull();
  assertThat(headers).isInstanceOf(Map.class);
  @SuppressWarnings("unchecked")
  Map<String, Object> headersToCheck = (Map<String, Object>) headers;
  assertThat(headersToCheck).doesNotContainKey(MessageHeaders.TIMESTAMP);
}

@SuppressWarnings("unchecked")
@Test
public void testUnmarshalling() throws Exception {
  StringSource source = new StringSource("<person><firstname>bob</firstname></person>");
  unmarshallIn.send(new GenericMessage<Source>(source));
  GenericMessage<Object> res = (GenericMessage<Object>) unmarshallOut.receive(2000);
  assertNotNull("No response", res);
  assertTrue("Not a Person ", res.getPayload() instanceof JaxbAnnotatedPerson);
  JaxbAnnotatedPerson person = (JaxbAnnotatedPerson) res.getPayload();
  assertEquals("Worng firstname", "bob", person.getFirstName());
}

@Test
public void testProxyAndHeaderAnnotation() {
  final AtomicReference<Object> payloadReference = new AtomicReference<>();
  final AtomicReference<UUID> idReference = new AtomicReference<>();
  class MyHandler {
    public void handle(@Header(MessageHeaders.ID) UUID id, @Payload Object payload) {
      idReference.set(id);
      payloadReference.set(payload);
    }
  }
  MyHandler service = new MyHandler();
  final AtomicBoolean adviceCalled = new AtomicBoolean();
  ProxyFactory proxyFactory = new ProxyFactory(service);
  proxyFactory.addAdvice((MethodInterceptor) i -> {
    adviceCalled.set(true);
    return i.proceed();
  });
  service = (MyHandler) proxyFactory.getProxy(getClass().getClassLoader());
  GenericMessage<String> testMessage = new GenericMessage<>("foo");
  MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(service, "handle");
  processor.setBeanFactory(mock(BeanFactory.class));
  processor.processMessage(testMessage);
  assertEquals(testMessage.getPayload(), payloadReference.get());
  assertEquals(testMessage.getHeaders().getId(), idReference.get());
  assertTrue(adviceCalled.get());
}

@Test
@RedisAvailable
public void testInt3017IntegrationOutbound() throws Exception {
  final String queueName = "si.test.Int3017IntegrationOutbound";
  GenericMessage<Object> message = new GenericMessage<Object>(queueName);
  this.sendChannel.send(message);
  RedisTemplate<String, String> redisTemplate = new StringRedisTemplate();
  redisTemplate.setConnectionFactory(this.connectionFactory);
  redisTemplate.afterPropertiesSet();
  String result = redisTemplate.boundListOps(queueName).rightPop(5000, TimeUnit.MILLISECONDS);
  assertNotNull(result);
  InboundMessageMapper<String> mapper = new JsonInboundMessageMapper(String.class,
      new Jackson2JsonMessageParser());
  Message<?> resultMessage = mapper.toMessage(result);
  assertEquals(message.getPayload(), resultMessage.getPayload());
}