Implement the Interconnect Event Handler Interface

3.4 Implement the Interconnect Event Handler Interface

This topic describes how to implement the Interconnect Event Handler interface to handle interconnect events within the system.

Each domain application must implement the Interconnect Event Handler<T> interface to handle incoming events from Interconnect.

Interface Definition

public interface InterconnectEventHandler<T> {

    /**
     * Returns the target DTO class for automatic Map-to-DTO binding.
     * Enables automatic conversion of the incoming Map payload into
     * a strongly typed DTO using Jackson's ObjectMapper.
     */
    Class<T> payloadType();
    /**
     * Converts the raw Map payload into a domain DTO instance.
     * Override only if custom conversion logic is required.
     */
    default T assembleDto(Map<String, Object> payload, Class<T> dtoClass) {
        return ObjectMapperFactory.getInstance().convertValue(payload, dtoClass);
    }

    /**
     * Indicates whether the handler wants asynchronous processing.
     * Currently not supported — must return false.
     */
    default boolean wantsAsync() {
        return false;
    }

    /**
     * Optional pre-processing hook invoked before event processing begins.
     * Useful for input validation or payload enrichment.
     */
    default void onPreProcessEvent(EventContext ctx, T payload, String recordId) {
        // no-op by default
    }

    /**
     * Core domain processing method.
     * Must be implemented to handle incoming event payloads.
     * Returns an Ack indicating success or failure.
     */
    Ack onProcessEvent(EventContext ctx, T payload, String recordId);

    /**
     * Asynchronous version of event processing.
     * Not yet supported.
     */
    default void onProcessEventAsync(EventContext ctx, T payload, String recordId) {
        // no-op by default
    }

    /**
     * Optional post-processing hook invoked after event processing completes.
     * Useful for cleanup operations or audit logging.
     */
    default void onPostProcessEvent(EventContext ctx, T payload, String recordId) {
        // no-op by default
    }
}

Example Implementation

@Component("customerDataHandler")
public class CustomerDataHandler implements InterconnectEventHandler<CustomerDto> {

    @Override
    public Class<CustomerDto> payloadType() {
        return CustomerDto.class;
    }

    @Override
    public Ack onProcessEvent(EventContext ctx, CustomerDto payload, String recordId) {
        try {
            customerService.processCustomerData(payload);
            return Ack.success(recordId);
        } catch (Exception ex) {
            log.error("Failed to process customer data for record {}", recordId, ex);
            return Ack.failed(recordId, ex.getMessage());
        }
    }
}

Note:

The Spring bean name (customerDataHandler) must exactly match the Implementation Name configured in Interconnect.

Parent topic: Integration via Discovery Service