Java Message.copyFrom方法代码示例

import org.apache.camel.Message; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public void process(Exchange exchange) throws Exception {
    Message in = exchange.getIn();
    Address address = in.getHeader(Constants.ADDRESS_HEADER, Address.class);
    Class<?> datatype = in.getHeader(Constants.DATATYPE_HEADER, Class.class);
    Object value = in.getBody(Object.class);
    PlcWriteRequest plcSimpleWriteRequest = new PlcWriteRequest(datatype, address, value);
    PlcWriter plcWriter = plcConnection.getWriter().orElseThrow(() -> new IllegalArgumentException("Writer for driver not found"));
    CompletableFuture<PlcWriteResponse> completableFuture = plcWriter.write(plcSimpleWriteRequest);
    int currentlyOpenRequests = openRequests.incrementAndGet();
    try {
        log.debug("Currently open requests including {}:{}", exchange, currentlyOpenRequests);
        PlcWriteResponse plcWriteResponse = completableFuture.get();
        if (exchange.getPattern().isOutCapable()) {
            Message out = exchange.getOut();
            out.copyFrom(exchange.getIn());
            out.setBody(plcWriteResponse);
        } else {
            in.setBody(plcWriteResponse);
        }
    } finally {
        int openRequestsAfterFinish = openRequests.decrementAndGet();
        log.trace("Open Requests after {}:{}", exchange, openRequestsAfterFinish);
    }
}
 

import org.apache.camel.Message; //导入方法依赖的package包/类
@Override
public boolean process(Exchange exchange, AsyncCallback callback) {
    try {
        Message in = exchange.getIn();

        @SuppressWarnings("unchecked")
        List<T> list = expression.evaluate(exchange, List.class);
        Collections.sort(list, comparator);

        if (exchange.getPattern().isOutCapable()) {
            Message out = exchange.getOut();
            out.copyFrom(in);
            out.setBody(list);
        } else {
            in.setBody(list);
        }
    } catch (Exception e) {
        exchange.setException(e);
    }

    callback.done(true);
    return true;
}
 

import org.apache.camel.Message; //导入方法依赖的package包/类
public void testCopyFromSameHeadersInstance() {
    Exchange exchange = new DefaultExchange(context);

    Message in = exchange.getIn();
    Map<String, Object> headers = in.getHeaders();
    headers.put("foo", 123);

    Message out = new DefaultMessage();
    out.setBody("Bye World");
    out.setHeaders(headers);

    out.copyFrom(in);

    assertEquals(123, headers.get("foo"));
    assertEquals(123, in.getHeader("foo"));
    assertEquals(123, out.getHeader("foo"));
}
 

import org.apache.camel.Message; //导入方法依赖的package包/类
@Override
public void process(Exchange exchange) throws Exception { //NOPMD
    InputStream stream = exchange.getIn().getMandatoryBody(InputStream.class);
    try {
        // lets setup the out message before we invoke the signing
        // so that it can mutate it if necessary
        Message out = exchange.getOut();
        out.copyFrom(exchange.getIn());
        verify(stream, out);
        clearMessageHeaders(out);
    } catch (Exception e) {
        // remove OUT message, as an exception occurred
        exchange.setOut(null);
        throw e;
    } finally {
        IOHelper.close(stream, "input stream");
    }
}
 

import org.apache.camel.Message; //导入方法依赖的package包/类
private Message getMessageForResponse(Exchange exchange) {
	if (exchange.getPattern().isOutCapable()) {
		Message out = exchange.getOut();
		out.copyFrom(exchange.getIn());
		return out;
	}

	return exchange.getIn();
}
 

import org.apache.camel.Message; //导入方法依赖的package包/类
@Converter
public static Processor toProcessor(final Predicate predicate) {
    return new Processor() {
        public void process(Exchange exchange) throws Exception {
            boolean answer = predicate.matches(exchange);
            Message out = exchange.getOut();
            out.copyFrom(exchange.getIn());
            out.setBody(answer);
        }
    };

}
 

import org.apache.camel.Message; //导入方法依赖的package包/类
@Override
public boolean process(Exchange exchange, AsyncCallback callback) {
    try {
        Object newBody = expression.evaluate(exchange, Object.class);

        if (exchange.getException() != null) {
            // the expression threw an exception so we should break-out
            callback.done(true);
            return true;
        }

        boolean out = exchange.hasOut();
        Message old = out ? exchange.getOut() : exchange.getIn();

        // create a new message container so we do not drag specialized message objects along
        // but that is only needed if the old message is a specialized message
        boolean copyNeeded = !(old.getClass().equals(DefaultMessage.class));

        if (copyNeeded) {
            Message msg = new DefaultMessage();
            msg.copyFrom(old);
            msg.setBody(newBody);

            // replace message on exchange
            ExchangeHelper.replaceMessage(exchange, msg, false);
        } else {
            // no copy needed so set replace value directly
            old.setBody(newBody);
        }

    } catch (Throwable e) {
        exchange.setException(e);
    }

    callback.done(true);
    return true;
}
 

import org.apache.camel.Message; //导入方法依赖的package包/类
public boolean process(Exchange exchange, AsyncCallback callback) {
    ObjectHelper.notNull(dataFormat, "dataFormat");

    // if stream caching is enabled then use that so we can stream accordingly
    // for example to overflow to disk for big streams
    OutputStreamBuilder osb = OutputStreamBuilder.withExchange(exchange);

    Message in = exchange.getIn();
    Object body = in.getBody();

    // lets setup the out message before we invoke the dataFormat
    // so that it can mutate it if necessary
    Message out = exchange.getOut();
    out.copyFrom(in);

    try {
        dataFormat.marshal(exchange, body, osb);
        out.setBody(osb.build());
    } catch (Throwable e) {
        // remove OUT message, as an exception occurred
        exchange.setOut(null);
        exchange.setException(e);
    }

    callback.done(true);
    return true;
}
 

import org.apache.camel.Message; //导入方法依赖的package包/类
public boolean process(Exchange exchange, AsyncCallback callback) {
    ObjectHelper.notNull(dataFormat, "dataFormat");

    InputStream stream = null;
    Object result = null;
    try {
        stream = exchange.getIn().getMandatoryBody(InputStream.class);

        // lets setup the out message before we invoke the dataFormat so that it can mutate it if necessary
        Message out = exchange.getOut();
        out.copyFrom(exchange.getIn());

        result = dataFormat.unmarshal(exchange, stream);
        if (result instanceof Exchange) {
            if (result != exchange) {
                // it's not allowed to return another exchange other than the one provided to dataFormat
                throw new RuntimeCamelException("The returned exchange " + result + " is not the same as " + exchange + " provided to the DataFormat");
            }
        } else if (result instanceof Message) {
            // the dataformat has probably set headers, attachments, etc. so let's use it as the outbound payload
            exchange.setOut((Message) result);
        } else {
            out.setBody(result);
        }
    } catch (Throwable e) {
        // remove OUT message, as an exception occurred
        exchange.setOut(null);
        exchange.setException(e);
    } finally {
        // The Iterator will close the stream itself
        if (!(result instanceof Iterator)) {
            IOHelper.close(stream, "input stream");
        }
    }
    callback.done(true);
    return true;
}
 

import org.apache.camel.Message; //导入方法依赖的package包/类
/**
 * Copies the <code>source</code> exchange to <code>target</code> exchange
 * preserving the {@link ExchangePattern} of <code>target</code>.
 *
 * @param source source exchange.
 * @param result target exchange.
 */
public static void copyResultsPreservePattern(Exchange result, Exchange source) {

    // --------------------------------------------------------------------
    //  TODO: merge logic with that of copyResults()
    // --------------------------------------------------------------------

    if (result == source) {
        // we just need to ensure MEP is as expected (eg copy result to OUT if out capable)
        // and the result is not failed
        if (result.getPattern() == ExchangePattern.InOptionalOut) {
            // keep as is
        } else if (result.getPattern().isOutCapable() && !result.hasOut() && !result.isFailed()) {
            // copy IN to OUT as we expect a OUT response
            result.getOut().copyFrom(source.getIn());
        }
        return;
    }

    // copy in message
    result.getIn().copyFrom(source.getIn());

    // copy out message
    if (source.hasOut()) {
        // exchange pattern sensitive
        Message resultMessage = source.getOut().isFault() ? result.getOut() : getResultMessage(result);
        resultMessage.copyFrom(source.getOut());
    }

    // copy exception
    result.setException(source.getException());

    // copy properties
    if (source.hasProperties()) {
        result.getProperties().putAll(source.getProperties());
    }
}
 

import org.apache.camel.Message; //导入方法依赖的package包/类
@Override
public void process(Exchange exchange) throws Exception { //NOPMD

    try {
        LOG.debug("XML signature generation started using algorithm {} and canonicalization method {}", getConfiguration()
                .getSignatureAlgorithm(), getConfiguration().getCanonicalizationMethod().getAlgorithm());

        // lets setup the out message before we invoke the signing
        // so that it can mutate it if necessary
        Message out = exchange.getOut();
        out.copyFrom(exchange.getIn());

        Document outputDoc = sign(out);

        ByteArrayOutputStream outStream = new ByteArrayOutputStream();
        XmlSignatureHelper.transformNonTextNodeToOutputStream(outputDoc, outStream, omitXmlDeclaration(out), getConfiguration().getOutputXmlEncoding());
        byte[] data = outStream.toByteArray();
        out.setBody(data);
        setOutputEncodingToMessageHeader(out);
        clearMessageHeaders(out);
        LOG.debug("XML signature generation finished");
    } catch (Exception e) {
        // remove OUT message, as an exception occurred
        exchange.setOut(null);
        throw e;
    }
}
 

import org.apache.camel.Message; //导入方法依赖的package包/类
private Message getMessageForResponse(final Exchange exchange) {
    if (exchange.getPattern().isOutCapable()) {
        Message out = exchange.getOut();
        out.copyFrom(exchange.getIn());
        return out;
    }
    return exchange.getIn();
}
 

import org.apache.camel.Message; //导入方法依赖的package包/类
private Message getMessageForResponse(Exchange exchange) {
    if (exchange.getPattern().isOutCapable()) {
        Message out = exchange.getOut();
        out.copyFrom(exchange.getIn());
        return out;
    }

    return exchange.getIn();
}
 

import org.apache.camel.Message; //导入方法依赖的package包/类
private void setResult(Exchange exchange, Object result) {
    Message message;
    if (exchange.getPattern().isOutCapable()) {
        message = exchange.getOut();
        message.copyFrom(exchange.getIn());
    } else {
        message = exchange.getIn();
    }
    message.setBody(result);
}
 

import org.apache.camel.Message; //导入方法依赖的package包/类
public static Message getMessageForResponse(final Exchange exchange) {
    if (exchange.getPattern().isOutCapable()) {
        Message out = exchange.getOut();
        out.copyFrom(exchange.getIn());
        return out;
    }
    return exchange.getIn();
}