How to use

setHeader

method

in

org.springframework.integration.support.MessageBuilder

/**
 * 消息生产接口
 *
 * @param message
 * @return
 */
@GetMapping("/sendMessage")
public String messageWithMQ(@RequestParam String message) {
  log.info("Send: " + message);
  testTopic.output().send(MessageBuilder.withPayload(message).setHeader("x-delay", 5000).build());
  return "ok";
}

/**
 * 消息生产接口
 *
 * @param message
 * @return
 */
@GetMapping("/sendMessage")
public String messageWithMQ(@RequestParam String message) {
  testTopic.output().send(MessageBuilder.withPayload(message).setHeader("version", "1.0").build());
  testTopic.output().send(MessageBuilder.withPayload(message).setHeader("version", "2.0").build());
  return "ok";
}

@Splitter
public List<Message<?>> splitIntoMessages(final List<EmailFragment> emailFragments) {
  final List<Message<?>> messages = new ArrayList<Message<?>>();
  for (EmailFragment emailFragment : emailFragments) {
    Message<?> message = MessageBuilder.withPayload(emailFragment.getData())
                    .setHeader(FileHeaders.FILENAME, emailFragment.getFilename())
                    .setHeader("directory", emailFragment.getDirectory())
                    .build();
    messages.add(message);
  }
  return messages;
}

@Override
public Message<?> preSend(Message<?> message, MessageChannel channel) {
  StepContext context = StepSynchronizationManager.getContext();
  if (context == null) {
    return message;
  }
  return MessageBuilder.fromMessage(message).setHeader(STEP_EXECUTION, context.getStepExecution()).build();
}

File file = File.createTempFile("temp", "txt");
Message<File> message = MessageBuilder.withPayload(file)
        .setHeader("customer", "cust1")
        .build();
try {
    .setHeader("customer", "cust2").build();
try {
  channel.send(message);
    .setHeader("customer", "cust3").build();
try {
  channel.send(message);
    .setHeader("customer", "cust1").build();
try {
  channel.send(message);

@Override
protected Object handleRequestMessage(Message<?> requestMessage) {
  if ("bar".equals(requestMessage.getPayload())) {
    return null;
  }
  Exception e = new RuntimeException();
  StackTraceElement[] st = e.getStackTrace();
  return MessageBuilder.withPayload(requestMessage.getPayload().toString().toUpperCase())
      .setHeader("callStack", st);
}

  @Override
  protected Message<String> handleRequestMessage(Message<?> requestMessage) {
    return MessageBuilder.withPayload("foo")
        .setHeader("bar", "baz").build();
  }
};

@Test
public void fromMessageWithMapMethodAndHeadersAnnotation() throws Exception {
  Method method = TestService.class.getMethod("mapHeaders", Map.class);
  MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method);
  processor.setBeanFactory(mock(BeanFactory.class));
  Message<String> message = MessageBuilder.withPayload("test")
      .setHeader("attrib1", 123)
      .setHeader("attrib2", 456).build();
  Map<String, Object> result = (Map<String, Object>) processor.processMessage(message);
  assertEquals(123, result.get("attrib1"));
  assertEquals(456, result.get("attrib2"));
}

@Test
public void delayHeaderIsDateInThePastAndDefaultDelayWouldTimeout() {
  delayHandler.setDefaultDelay(5000);
  this.setDelayExpression();
  startDelayerHandler();
  Message<?> message = MessageBuilder.withPayload("test")
      .setHeader("delay", new Date(new Date().getTime() - 60 * 1000)).build();
  input.send(message);
  waitForLatch(10000);
  assertSame(message.getPayload(), resultHandler.lastMessage.getPayload());
  assertSame(Thread.currentThread(), resultHandler.lastThread);
}

@Test
public void testDelayWithDefaultSchedulerCustomDelayHeader() {
  MessageBuilder<String> builder = MessageBuilder.withPayload("Hello");
  // set custom delay header
  builder.setHeader("foo", 2000);
  long start = System.currentTimeMillis();
  inputA.send(builder.build());
  assertNotNull(outputA.receive(10000));
  assertTrue((System.currentTimeMillis() - start) >= 2000);
}

@Test(expected = MessageHandlingException.class)
public void headerValueNotProvided() throws Exception {
  TestBean testBean = new TestBean();
  Method testMethod = testBean.getClass().getMethod("headerTest", String.class, Integer.class);
  MethodInvokingTransformer transformer = new MethodInvokingTransformer(testBean, testMethod);
  Message<String> message = MessageBuilder.withPayload("foo")
      .setHeader("wrong", 123).build();
  transformer.transform(message);
}

@Test
public void test() {
  control.send(new GenericMessage<String>("@myRouter.setChannelMapping('baz', 'qux')"));
  Message<?> message = MessageBuilder.withPayload("Hello, world!")
      .setHeader("routing.header", "baz").build();
  in.send(message);
  assertNotNull(qux.receive());
}

@Test
public void testDoubleExecutionWithNewScript() {
  processor = new GroovyCommandMessageProcessor();
  Message<?> message = MessageBuilder.withPayload("headers.foo").setHeader("foo", "bar").build();
  Object result = processor.processMessage(message);
  assertEquals("bar", result.toString());
  message = MessageBuilder.withPayload("headers.bar").setHeader("bar", "spam").build();
  result = processor.processMessage(message);
  assertEquals("spam", result.toString());
}

@Test
public void filterTest() {
  Message<?> message1 = MessageBuilder.withPayload("bad").setHeader("type", "bad").build();
  Message<?> message2 = MessageBuilder.withPayload("good").setHeader("type", "good").build();
  this.filterInput.send(message1);
  this.filterInput.send(message2);
  assertEquals("good", this.results.receive(10000).getPayload());
  assertNull(this.results.receive(0));
  assertEquals("bad", this.discardChannel.receive(10000).getPayload());
  assertNull(this.discardChannel.receive(0));
}

@Test
@RedisAvailable
public void testStoreSimpleStringInMap() {
  RedisMap<String, String> redisMap = new DefaultRedisMap<String, String>("bar", this.redisTemplate);
  assertEquals(0, redisMap.size());
  Message<String> message = MessageBuilder.withPayload("hello, world!").
      setHeader(RedisHeaders.KEY, "bar").setHeader(RedisHeaders.MAP_KEY, "foo").build();
  this.simpleMapChannel.send(message);
  String hello = redisMap.get("foo");
  assertEquals("hello, world!", hello);
}

@Test
public void fromMessageToPayload() throws Exception {
  Method method = TestService.class.getMethod("mapOnly", Map.class);
  MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method);
  processor.setBeanFactory(mock(BeanFactory.class));
  Message<Employee> message = MessageBuilder.withPayload(employee).setHeader("number", "jkl").build();
  Object result = processor.processMessage(message);
  Assert.assertTrue(result instanceof Map);
  Assert.assertEquals("jkl", ((Map<?, ?>) result).get("number"));
}

@Test
public void testProcessMessageWithDollarPropertyAccess() {
  Expression expression = expressionParser.parseExpression("headers.$foo_id");
  ExpressionEvaluatingMessageProcessor<String> processor = new ExpressionEvaluatingMessageProcessor<>(expression);
  processor.setBeanFactory(mock(BeanFactory.class));
  Message<String> message = MessageBuilder.withPayload("foo").setHeader("$foo_id", "xyz").build();
  assertEquals("xyz", processor.processMessage(message));
}

@Test
public void delayHeaderIsValidStringAndDefaultDelayWouldTimeout() {
  delayHandler.setDefaultDelay(5000);
  this.setDelayExpression();
  startDelayerHandler();
  Message<?> message = MessageBuilder.withPayload("test")
      .setHeader("delay", "20").build();
  input.send(message);
  waitForLatch(10000);
  assertSame(message.getPayload(), resultHandler.lastMessage.getPayload());
  assertNotSame(Thread.currentThread(), resultHandler.lastThread);
}

@Test
public void testIncludeChannelName() throws Exception {
  Message<String> sentMessage = MessageBuilder.withPayload("hello")
      .setHeader("foo", "bar").build();
  queueChannel2.send(sentMessage);
  Message<?> message = good.receive(10000);
  assertNotNull(message);
  assertEquals("hello processed ok from queueChannel2", message.getPayload());
  assertNotNull(message.getHeaders().get("foo"));
  assertEquals("bar", message.getHeaders().get("foo"));
}

@Test
public void testJmsReplyToIgnoredIfIncorrectType() throws JMSException {
  Message<String> message = MessageBuilder.withPayload("test")
      .setHeader(JmsHeaders.REPLY_TO, "not-a-destination").build();
  DefaultJmsHeaderMapper mapper = new DefaultJmsHeaderMapper();
  javax.jms.Message jmsMessage = new StubTextMessage();
  mapper.fromHeaders(message.getHeaders(), jmsMessage);
  assertNull(jmsMessage.getJMSReplyTo());
}