defaulttransportservicedescriptor.java

提供ESB 应用mule源代码 提供ESB 应用mule源代码

            {
                System.arraycopy(args, 0, newArgs, 3, newArgs.length - 3);
            }

            try
            {
                MessageReceiver mr = (MessageReceiver) ClassUtils.instanciateClass(receiverClass, newArgs, classLoader);
                mr.initialise();
                return mr;
            }
            catch (Exception e)
            {
                throw new TransportServiceException(CoreMessages.failedToCreateObjectWith("Message Receiver", getService()), e);
            }

        }
        else
        {
            throw new TransportServiceException(CoreMessages.objectNotSetInService("Message Receiver", getService()));
        }
    }

    /* (non-Javadoc)
     * @see org.mule.transport.service.TransportServiceDescriptor#createDispatcherFactory()
     */
    public MessageDispatcherFactory createDispatcherFactory() throws TransportServiceException
    {
        if (dispatcherFactory != null)
        {
            try
            {
                return (MessageDispatcherFactory) ClassUtils.instanciateClass(dispatcherFactory,
                        ClassUtils.NO_ARGS, classLoader);
            }
            catch (Exception e)
            {
                throw new TransportServiceException(CoreMessages.failedToCreateObjectWith("Message Dispatcher Factory", dispatcherFactory), e);
            }
        }
        else
        {
            //Its valid not to have a Dispatcher factory on the transport
            return null;
        }
    }

    /* (non-Javadoc)
     * @see org.mule.transport.service.TransportServiceDescriptor#createRequesterFactory()
     */
    public MessageRequesterFactory createRequesterFactory() throws TransportServiceException
    {
        if (requesterFactory != null)
        {
            try
            {
                return (MessageRequesterFactory) ClassUtils.instanciateClass(requesterFactory,
                        ClassUtils.NO_ARGS, classLoader);
            }
            catch (Exception e)
            {
                throw new TransportServiceException(
                        CoreMessages.failedToCreateObjectWith("Message Requester Factory", requesterFactory), e);
            }
        }
        else
        {
            //Its valid not to have a Dispatcher factory on the transport
            return null;
        }
    }

    /* (non-Javadoc)
     * @see org.mule.transport.service.TransportServiceDescriptor#createTransactionFactory()
     */
    public TransactionFactory createTransactionFactory() throws TransportServiceException
    {
        if (transactionFactory != null)
        {
            try
            {
                return (TransactionFactory) ClassUtils.instanciateClass(transactionFactory,
                        ClassUtils.NO_ARGS, classLoader);
            }
            catch (Exception e)
            {
                throw new TransportServiceException(CoreMessages.failedToCreateObjectWith("Transaction Factory", transactionFactory), e);
            }
        }
        else
        {
            return null;
        }
    }

    /* (non-Javadoc)
     * @see org.mule.transport.service.TransportServiceDescriptor#createConnector(java.lang.String)
     */
    public Connector createConnector() throws TransportServiceException
    {
        Connector newConnector;
        // if there is a factory, use it
        try
        {
            if (connector != null)
            {
                Class connectorClass;
                if (classLoader != null)
                {
                    connectorClass = ClassUtils.loadClass(connector, classLoader);
                }
                else
                {
                    connectorClass = ClassUtils.loadClass(connector, getClass());
                }
                newConnector = (Connector) connectorClass.newInstance();
            }
            else
            {
                throw new TransportServiceException(CoreMessages.objectNotSetInService("Connector", getService()));
            }
        }
        catch (TransportServiceException e)
        {
            throw e;
        }
        catch (Exception e)
        {
            throw new TransportServiceException(CoreMessages.failedToCreateObjectWith("Connector", connector), e);
        }

        if (newConnector.getName() == null)
        {
            newConnector.setName("_" + newConnector.getProtocol() + "Connector#" + connector.hashCode());
        }
        return newConnector;
    }

    /* (non-Javadoc)
     * @see org.mule.transport.service.TransportServiceDescriptor#createInboundTransformer()
     */
    public List createInboundTransformers() throws TransportFactoryException
    {
        if (inboundTransformer != null)
        {
            return CollectionUtils.singletonList(inboundTransformer);
        }
        if (defaultInboundTransformer != null)
        {
            logger.info("Loading default inbound transformer: " + defaultInboundTransformer);
            try
            {
                inboundTransformer = (Transformer) ClassUtils.instanciateClass(
                        defaultInboundTransformer, ClassUtils.NO_ARGS, classLoader);
                return CollectionUtils.singletonList(inboundTransformer);
            }
            catch (Exception e)
            {
                throw new TransportFactoryException(CoreMessages.failedToLoadTransformer("inbound", defaultInboundTransformer), e);
            }
        }
        return null;
    }

    /* (non-Javadoc)
     * @see org.mule.transport.service.TransportServiceDescriptor#createOutboundTransformer()
     */
    public List createOutboundTransformers() throws TransportFactoryException
    {
        if (outboundTransformer != null)
        {
            return CollectionUtils.singletonList(outboundTransformer);
        }
        if (defaultOutboundTransformer != null)
        {
            logger.info("Loading default outbound transformer: " + defaultOutboundTransformer);
            try
            {
                outboundTransformer = (Transformer) ClassUtils.instanciateClass(
                        defaultOutboundTransformer, ClassUtils.NO_ARGS, classLoader);
                return CollectionUtils.singletonList(outboundTransformer);
            }
            catch (Exception e)
            {
                throw new TransportFactoryException(CoreMessages.failedToLoadTransformer("outbound", defaultOutboundTransformer), e);
            }
        }
        return null;
    }

    /* (non-Javadoc)
     * @see org.mule.transport.service.TransportServiceDescriptor#createResponseTransformer()
     */
    public List createResponseTransformers() throws TransportFactoryException
    {
        if (responseTransformer != null)
        {
            return CollectionUtils.singletonList(responseTransformer);
        }
        if (defaultResponseTransformer != null)
        {
            logger.info("Loading default response transformer: " + defaultResponseTransformer);
            try
            {
                responseTransformer = (Transformer) ClassUtils.instanciateClass(
                        defaultResponseTransformer, ClassUtils.NO_ARGS, classLoader);
                return CollectionUtils.singletonList(responseTransformer);
            }
            catch (Exception e)
            {
                throw new TransportFactoryException(CoreMessages.failedToLoadTransformer("response", defaultResponseTransformer), e);
            }
        }
        return null;
    }

    /* (non-Javadoc)
     * @see org.mule.transport.service.TransportServiceDescriptor#createEndpointBuilder()
     */
    public EndpointURIBuilder createEndpointBuilder() throws TransportFactoryException
    {
        if (endpointBuilder == null)
        {
            logger.debug("Endpoint resolver not set, Loading default resolver: "
                    + UrlEndpointURIBuilder.class.getName());
            return new UrlEndpointURIBuilder();
        }
        else
        {
            logger.debug("Loading endpointUri resolver: " + endpointBuilder);
            try
            {
                return (EndpointURIBuilder) ClassUtils.instanciateClass(endpointBuilder, ClassUtils.NO_ARGS, classLoader);
            }
            catch (Exception e)
            {
                throw new TransportFactoryException(CoreMessages.failedToLoad("Endpoint Builder: " + endpointBuilder), e);
            }
        }
    }

    public void setExceptionMappings(Properties props)
    {
        this.exceptionMappings = props;
    }

    public Properties getExceptionMappings()
    {
        return this.exceptionMappings;
    }
}