Java Spring云数据流多主题事务管理

我正在尝试用Java创建一个PoC应用程序，以了解在使用Kafka进行消息发布时如何在Spring Cloud Stream中进行事务管理。我试图模拟的用例是一个接收消息的处理器。然后，它进行一些处理，并生成两条发送到两个不同主题的新消息。我希望能够将这两条消息作为单个事务发布。因此，如果发布第二条消息失败，我希望滚动（而不是提交）第一条消息。SpringCloudStream支持这样的用例吗

我已经设置了

@Transactional

注释，并且我可以看到一个全局事务在消息传递给消费者之前开始。但是，当我尝试通过

MessageChannel.send（）

方法发布消息时，我可以看到一个新的本地事务在

KafkaProducerMessageHandler

class'

HandlerRequestMessage（）

方法中启动并完成。这意味着消息的发送不参与全局事务。因此，如果在发布第一条消息后引发异常，则不会回滚该消息。全局事务被回滚，但由于第一条消息已经提交，因此实际上没有做任何事情

spring:
  cloud:
    stream:
      kafka:
        binder:
          brokers: localhost:9092
          transaction:
            transaction-id-prefix: txn.
            producer: # these apply to all producers that participate in the transaction
              partition-key-extractor-name: partitionKeyExtractorStrategy
              partition-selector-name: partitionSelectorStrategy
              partition-count: 3
              configuration:
               acks: all
               enable:
                 idempotence: true
               retries: 10
        bindings:
          input-customer-data-change-topic:
            consumer:
              configuration:
                isolation:
                  level: read_committed
              enable-dlq: true
      bindings:
        input-customer-data-change-topic:
          content-type: application/json
          destination: com.fis.customer
          group: com.fis.ec
          consumer:
            partitioned: true
            max-attempts: 1
        output-name-change-topic:
          content-type: application/json
          destination: com.fis.customer.name          
        output-email-change-topic:
          content-type: application/json
          destination: com.fis.customer.email

编辑

我们越来越近了。不再创建本地事务。但是，即使出现异常，全局事务仍会被提交。据我所知，异常不会传播到

TransactionTemplate.execute（）

方法。因此，事务被提交。似乎

sendMessage（）

方法中的

MessageProducerSupport

类“吞咽”了catch子句中的异常。如果定义了一个错误通道，则会向其发布一条消息，因此不会重新引发异常。我试图关闭错误频道（

spring.cloud.stream.kafka.binder.transaction.producer.error-channel-enabled=false

），但这并没有关闭它。因此，为了进行测试，我只需在调试器中将错误通道设置为null，以强制重新调用异常。似乎就是这样。但是，即使我将该消费者的

最大尝试次数

设置为1，原始消息仍会不断重新传递给初始消费者。

请参阅

spring.cloud.stream.kafka.binder.transaction.transactionIdPrefix

启用活页夹中的事务。请参见Kafka文档中的transaction.id和spring Kafka文档中的事务。启用事务时，将忽略单个生产者属性，所有生产者都使用spring.cloud.stream.kafka.binder.transaction.producer.*属性

默认为空（无事务）

spring.cloud.stream.kafka.binder.transaction.producer.*

事务绑定器中生产者的全局生产者属性。请参阅spring.cloud.stream.kafka.binder.transaction.transaction IDPrefix和kafka生产者属性以及所有绑定支持的常规生产者属性

默认设置：请参见各个生产者属性

您必须配置共享全局生产者

不要添加

@Transactional

-在提交事务之前，容器将启动事务并向事务发送偏移量

如果侦听器抛出异常，事务将回滚，

DefaultAfterRollbackPostProcessor

将重新查找主题/分区，以便重新传递记录

编辑

绑定器事务管理器的配置中存在一个错误，导致输出绑定启动一个新的本地事务

要解决此问题，请使用以下容器定制器bean重新配置TM

@Bean
public ListenerContainerCustomizer<AbstractMessageListenerContainer<byte[], byte[]>> customizer() {
    return (container, dest, group) -> {
        KafkaTransactionManager<?, ?> tm = (KafkaTransactionManager<?, ?>) container.getContainerProperties()
                .getTransactionManager();
        tm.setTransactionSynchronization(AbstractPlatformTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
    };
}

及

及

---

谢谢你的回复。我删除了@Transactional注释并更新了生产者的application.yaml文件。第一条消息发送后仍在提交中。因此，在MessageChannel.send（）调用之后引发的异常不会回滚。这些主题的使用者是否具有

隔离=读取提交的
？如果是，请在GitHub gist或pastebin等地方发布调试日志。不过，我可能要到明天才能看到它。是的，消费者是这样配置的。我把debig日志内容上传到Gist：谢谢你看这个！那个日志似乎只有tomcat的东西。但我复制了这个问题；这是一个错误-我用一个变通方法编辑了我的答案。请在原始帖子中查看我的编辑。我们正在取得进展，但仍然存在一些问题。
public interface CustomerDataChangeStreams
{
   @Input("input-customer-data-change-topic")
   SubscribableChannel inputCustomerDataChange();

   @Output("output-email-change-topic")
   MessageChannel outputEmailDataChange();

   @Output("output-name-change-topic")
   MessageChannel outputNameDataChange();
}

@Component
public class CustomerDataChangeListener
{
   @Autowired
   private CustomerDataChangeProcessor mService;

   @StreamListener("input-customer-data-change-topic")
   public Message<String> handleCustomerDataChangeMessages(
      @Payload final ImmutableCustomerDetails customerDetails)
   {
      return mService.processMessage(customerDetails);
   }
}

@Component
public class CustomerDataChangeProcessor
{
   private final CustomerDataChangeStreams mStreams;

   @Value("${spring.cloud.stream.bindings.output-email-change-topic.destination}")
   private String mEmailChangeTopic;

   @Value("${spring.cloud.stream.bindings.output-name-change-topic.destination}")
   private String mNameChangeTopic;

   public CustomerDataChangeProcessor(final CustomerDataChangeStreams streams)
   {
      mStreams = streams;
   }

   public void processMessage(final CustomerDetails customerDetails)
   {
      try
      {
         sendNameMessage(customerDetails);
         sendEmailMessage(customerDetails);
      }
      catch (final JSONException ex)
      {
         LOGGER.error("Failed to send messages.", ex);
      }
   }

   public void sendNameMessage(final CustomerDetails customerDetails)
      throws JSONException
   {
      final JSONObject nameChangeDetails = new JSONObject();
      nameChangeDetails.put(KafkaConst.BANK_ID_KEY, customerDetails.bankId());
      nameChangeDetails.put(KafkaConst.CUSTOMER_ID_KEY, customerDetails.customerId());
      nameChangeDetails.put(KafkaConst.FIRST_NAME_KEY, customerDetails.firstName());
      nameChangeDetails.put(KafkaConst.LAST_NAME_KEY, customerDetails.lastName());
      final String action = customerDetails.action();
      nameChangeDetails.put(KafkaConst.ACTION_KEY, action);

      final MessageChannel nameChangeMessageChannel = mStreams.outputNameDataChange();
      emailChangeMessageChannel.send(MessageBuilder.withPayload(nameChangeDetails.toString())
         .setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_JSON)
         .setHeader(KafkaHeaders.TOPIC, mNameChangeTopic).build());

      if ("fail_name_illegal".equalsIgnoreCase(action))
      {
         throw new IllegalArgumentException("Customer name failure!");
      }
   }

   public void sendEmailMessage(final CustomerDetails customerDetails) throws JSONException
   {
      final JSONObject emailChangeDetails = new JSONObject();
      emailChangeDetails.put(KafkaConst.BANK_ID_KEY, customerDetails.bankId());
      emailChangeDetails.put(KafkaConst.CUSTOMER_ID_KEY, customerDetails.customerId());
      emailChangeDetails.put(KafkaConst.EMAIL_ADDRESS_KEY, customerDetails.email());
      final String action = customerDetails.action();
      emailChangeDetails.put(KafkaConst.ACTION_KEY, action);

      final MessageChannel emailChangeMessageChannel = mStreams.outputEmailDataChange();
      emailChangeMessageChannel.send(MessageBuilder.withPayload(emailChangeDetails.toString())
         .setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_JSON)
         .setHeader(KafkaHeaders.TOPIC, mEmailChangeTopic).build());

      if ("fail_email_illegal".equalsIgnoreCase(action))
      {
         throw new IllegalArgumentException("E-mail address failure!");
      }
   }
}

@Bean
public ListenerContainerCustomizer<AbstractMessageListenerContainer<byte[], byte[]>> customizer() {
    return (container, dest, group) -> {
        KafkaTransactionManager<?, ?> tm = (KafkaTransactionManager<?, ?>) container.getContainerProperties()
                .getTransactionManager();
        tm.setTransactionSynchronization(AbstractPlatformTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
    };
}

spring:
  kafka:
    bootstrap-servers:
    - 10.0.0.8:9092
    - 10.0.0.8:9093
    - 10.0.0.8:9094
    consumer:
      auto-offset-reset: earliest
      enable-auto-commit: false
      properties:
        isolation.level: read_committed
  cloud:
    stream:
      bindings:
        input:
          destination: so57379575in
          group: so57379575in
          consumer:
            max-attempts: 1
        output:
          destination: so57379575out
      kafka:
        binder:
          transaction:
            transaction-id-prefix: so57379575tx.
            producer:
              configuration:
                acks: all
                retries: 10

#logging:
#  level:
#    org.springframework.kafka: trace
#    org.springframework.transaction: trace

in:two
2019-08-07 12:43:33.457 ERROR 36532 --- [container-0-C-1] o.s.integration.handler.LoggingHandler   : org.springframework.messaging.MessagingException: Exception thrown while 
...
Caused by: java.lang.RuntimeException: fail
...
in:one
dlt:two
out:ONE