com.sap.cloud.sdk.s4hana.datamodel.messaging.jms.JmsMessagingVdmConverter Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2019 SAP SE or an SAP affiliate company. All rights reserved.
 */

package com.sap.cloud.sdk.s4hana.datamodel.messaging.jms;

import java.nio.charset.StandardCharsets;
import java.util.Collection;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.jms.JMSException;
import javax.jms.TextMessage;

import com.google.common.annotations.Beta;
import com.sap.cloud.sdk.cloudplatform.util.FacadeLocator;
import com.sap.cloud.sdk.s4hana.datamodel.messaging.core.Message;
import com.sap.cloud.sdk.s4hana.datamodel.messaging.core.MessageFactory;
import com.sap.cloud.sdk.s4hana.datamodel.messaging.core.MessageFactoryMapper;
import com.sap.cloud.sdk.s4hana.datamodel.messaging.core.MessagingException;
import com.sap.cloud.sdk.s4hana.datamodel.messaging.core.MessagingVdmConverter;

import io.vavr.control.Option;

/**
 * Generic converter for turning JMS messages into Messaging VDM objects.
 *
 * This relies on {@link MessageFactoryMapper} objects to pick the right {@link MessageFactory} based on the message
 * type.
 *
 * Multiple {@link MessageFactoryMapper} objects can be configured, and each {@link MessageFactoryMapper} can have
 * mappings for the same message type. In this case, the mapping of the most recently added {@link MessageFactoryMapper}
 * is used.
 */
@Beta
public class JmsMessagingVdmConverter
{
    private static final Collection providedMappers =
        FacadeLocator.getFacades(MessageFactoryMapper.class);

    private final MessagingVdmConverter messageConverter;

    /**
     * Creates a converter instance with the {@link MessageFactoryMapper} provided by other dependencies.
     */
    public JmsMessagingVdmConverter()
    {
        messageConverter = new MessagingVdmConverter();
        providedMappers.forEach(messageConverter::addMessageFactoryMappers);
    }

    /**
     * Creates a converter instance with the {@link MessageFactoryMapper} provided by other dependencies, plus the
     * provided {@link MessageFactoryMapper} instances on top. Note that in case of duplicate mappings, the one from the
     * right-most {@link MessageFactoryMapper} will be used.
     *
     * @param messageFactoryMappers
     *            Mapping classes that implement the {@link MessageFactoryMapper} interface and map message types to
     *            message factory class names.
     */
    public JmsMessagingVdmConverter( @Nonnull final MessageFactoryMapper... messageFactoryMappers )
    {
        this();
        messageConverter.addMessageFactoryMappers(messageFactoryMappers);
    }

    /**
     * Augment existing converter with provided {@link MessageFactoryMapper} instances. Note that in case of duplicate
     * mappings, the one from the right-most {@link MessageFactoryMapper} will be used.
     *
     * @param messageFactoryMappers
     *            Mapping classes that implement the {@link MessageFactoryMapper} interface and map message types to
     *            message factory class names.
     */
    public void addMessageFactoryMappers( @Nonnull final MessageFactoryMapper... messageFactoryMappers )
    {
        messageConverter.addMessageFactoryMappers(messageFactoryMappers);
    }

    /**
     * Translates JMS messages into Messaging VDM objects.
     *
     * @param incomingMessage
     *            The original JMS message.
     * @return A Messaging VDM object representation of the original JMS message.
     * @throws MessagingException
     *             If there are problems parsing the JMS message or converting it to a Messaging VDM object.
     */
    @Nullable
    public Message fromJmsMessage( @Nullable final javax.jms.Message incomingMessage )
        throws MessagingException
    {
        if( incomingMessage != null ) {
            final String payload = extractPayload(incomingMessage);
            return messageConverter.fromMessage(payload);
        }
        return null;
    }

    private String extractPayload( @Nonnull final javax.jms.Message message )
        throws MessagingException
    {
        try {
            final Option maybePayload = extractFromTextMessage(message);
            return maybePayload.isDefined() ? maybePayload.get() : extractFromGenericMessage(message);
        }
        catch( final JMSException e ) {
            throw new MessagingException(
                "An Exception was thrown while extracting the payload from a message. Message: \n" + message,
                e);
        }
    }

    private Option extractFromTextMessage( @Nonnull final javax.jms.Message message )
        throws JMSException
    {
        return (message instanceof TextMessage) ? Option.of(((TextMessage) message).getText()) : Option.none();
    }

    private String extractFromGenericMessage( @Nonnull final javax.jms.Message message )
        throws JMSException
    {
        return new String(message.getBody(byte[].class), StandardCharsets.UTF_8);
    }
}