Java Exchange.getIn方法代码示例

import org.apache.camel.Exchange; //导入方法依赖的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.Exchange; //导入方法依赖的package包/类
@Override
public void onCompletion(Exchange exchange) {
	if (wrappedAggregationStrategy != null
			&& wrappedAggregationStrategy instanceof CompletionAwareAggregationStrategy) {
		((CompletionAwareAggregationStrategy) wrappedAggregationStrategy).onCompletion(exchange);
	}

	// Remove exception, fault and redelivery info from exchange
	exchange.setException(null);
	exchange.removeProperty(Exchange.FAILURE_HANDLED);
	exchange.removeProperty(Exchange.FAILURE_ENDPOINT);
	exchange.removeProperty(Exchange.FAILURE_ROUTE_ID);
	exchange.removeProperty(Exchange.ERRORHANDLER_CIRCUIT_DETECTED);
	exchange.removeProperty(Exchange.ERRORHANDLER_HANDLED);
	exchange.removeProperty(Exchange.EXCEPTION_HANDLED);
	exchange.removeProperty(Exchange.EXCEPTION_CAUGHT);

	Message message = exchange.hasOut() ? exchange.getOut() : exchange.getIn();
	message.setFault(false);
	message.removeHeader(Exchange.REDELIVERED);
	message.removeHeader(Exchange.REDELIVERY_COUNTER);
	message.removeHeader(Exchange.REDELIVERY_DELAY);
	message.removeHeader(Exchange.REDELIVERY_EXHAUSTED);
	message.removeHeader(Exchange.REDELIVERY_MAX_COUNTER);
}
 

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

    Status status = exchange.getIn().getBody(Status.class);

    User user = status.getUser();
    String name = user.getName();
    String screenName = user.getScreenName();

    Contact contact = new Contact();
    contact.setLastName(name);
    contact.setTwitterScreenName__c(screenName);

    in.setBody(contact);
}
 

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

    String actionName = in.getHeader(SpongeConstants.SPONGE_ACTION, String.class);
    if (actionName != null) {
        // Remove the header so it won't be propagated.
        in.removeHeader(SpongeConstants.SPONGE_ACTION);
    }

    if (actionName == null) {
        actionName = action != null ? action : CamelProducerAction.NAME;
    }

    Object result = engine.getOperations().call(actionName, exchange);

    exchange.getIn().setBody(result);
}
 

import org.apache.camel.Exchange; //导入方法依赖的package包/类
/**
 * Lets marshal the body to JSON using Jackson if we require it.
 * <br>
 * The current rules are to only marshal to JSON if we don't have a {@link Exchange#CONTENT_TYPE} header.
 * If we can convert the body to a String then we test if its already JSON and if not we marshal it using the JSON
 * data format with the Jackson library
 */
public void jsonMarshalIfRequired(Exchange exchange) throws Exception {
    Message in = exchange.getIn();
    if (in == null) {
        return;
    }
    String contentType = in.getHeader(Exchange.CONTENT_TYPE, String.class);
    if (!Strings.isEmpty(contentType)) {
        // lets preserve existing content types as it could be XML, YAML or something else
        return;
    }
    Object body = in.getBody();
    if (body != null) {
        if (isPossibleJsonClass(exchange, body.getClass(), body)) {
            try {
                String text = in.getBody(String.class);
                if (text != null) {
                    if (isJsonLookingString(text.trim())) {
                        in.setHeader(Exchange.CONTENT_TYPE, JSON_CONTENT_TYPE);
                    }
                    in.setBody(text);
                    return;
                }
            } catch (Exception e) {
                // ignore
            }
        }

        in.setHeader(Exchange.CONTENT_TYPE, JSON_CONTENT_TYPE);

        jsonMarshalProducer.process(exchange);
    }
}
 

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

    final String body = in.getBody(String.class);
    if (body == null) {
        return;
    }

    final JsonNode payload;
    try {
        payload = MAPPER.readTree(body);
    } catch (final JsonProcessingException e) {
        LOG.warn("Unable to parse payload, continuing without conversion", e);

        return;
    }

    payload.with("parameters").fields().forEachRemaining(e -> in.setHeader(e.getKey(), e.getValue().asText()));

    final JsonNode requestBody = payload.get("body");
    if (requestBody == null) {
        in.setBody(null);
    } else {
        in.setBody(MAPPER.writeValueAsString(requestBody));
    }
}
 

import org.apache.camel.Exchange; //导入方法依赖的package包/类
@Override
public void process(final Exchange exchange) throws Exception {
    // parse input json and extract Id field
    final Message in = exchange.getIn();
    final String body = in.getBody(String.class);

    if (body == null) {
        return;
    }

    final ObjectNode node = (ObjectNode) MAPPER.readTree(body);

    final String idPropertyName = determineIdProperty(exchange);

    final JsonNode idProperty = node.remove(idPropertyName);
    if (idProperty == null) {
        exchange.setException(
            new SalesforceException("Missing option value for Id or " + SalesforceEndpointConfig.SOBJECT_EXT_ID_NAME, 404));

        return;
    }

    final String idValue = idProperty.textValue();
    if ("Id".equals(idPropertyName)) {
        in.setHeader(SalesforceEndpointConfig.SOBJECT_ID, idValue);
    } else {
        in.setHeader(SalesforceEndpointConfig.SOBJECT_EXT_ID_VALUE, idValue);
    }

    // base fields are not allowed to be updated
    clearBaseFields(node);

    // update input json
    in.setBody(MAPPER.writeValueAsString(node));
}
 

import org.apache.camel.Exchange; //导入方法依赖的package包/类
public void process(Exchange exchange) throws Exception {
	
	Message in = exchange.getIn();
	Map<String,Object> tuple= (Map<String, Object>) in.getBody();
	MoneyTransfer mt = new  MoneyTransfer();
	mt.setId((Long)tuple.get(MoneyTransfer.FIELD_ID));
	mt.setKeycode((String)tuple.get(MoneyTransfer.FIELD_KEYCODE));
	mt.setPaymentMethod((String)tuple.get(MoneyTransfer.FIELD_PAYMENT_METHOD));
	mt.setAmount_hf_sender_currency((BigDecimal)tuple.get(MoneyTransfer.FIELD_AMOUNT_HF_SENDER_CUR));
	mt.setStatus((String)tuple.get(MoneyTransfer.FIELD_STATUS));
	in.setBody(mt);
	in.setHeader(InfinispanConstants.KEY, mt.getKeycode());

}
 

import org.apache.camel.Exchange; //导入方法依赖的package包/类
public static Event getEvent(Exchange exchange) {
    if (exchange.getIn() != null) {
        Object body = exchange.getIn().getBody();
        if (body != null) {
            if (body instanceof Event) {
                return (Event) body;
            } else if (body instanceof EventDefinition) {
                return ((EventDefinition) body).make();
            }
        }
    }

    return null;
}
 

import org.apache.camel.Exchange; //导入方法依赖的package包/类
private byte[] getInBody(Exchange exchange) {
    Message in = exchange.getIn();
    if (in.getBody() == null) {
        return null;
    }
    if (inFormat != null) {
        return marshal(in.getBody(), exchange, inFormat);
    } else if (inType != null) {
        in.setBody(in.getBody(inType));
    }
    return in.getBody(byte[].class); 
}
 

import org.apache.camel.Exchange; //导入方法依赖的package包/类
private void setInBody(byte[] bytes, Exchange exchange) {
    Message in = exchange.getIn();
    if (bytes == null) {
        in.setBody(null);
    } else if (outFormat != null) {
        in.setBody(unmarshal(bytes, exchange, outFormat));
    } else if (outType != null) {
        in.setBody(bytes, outType);
    } else { // fallback
        in.setBody(bytes, InputStream.class);
    }
}
 

import org.apache.camel.Exchange; //导入方法依赖的package包/类
private Exchange processResult(final Exchange origExchange,
                               final SplitIndex index,
                               final Object splitPart) throws Exception {

    final Exchange subExchange = origExchange.copy();

    Message message = subExchange.getIn();
    message.setBody(splitPart);
    finalizeSubExchange(origExchange, subExchange, index);

    super.processNext(subExchange);
    return subExchange;
}
 

import org.apache.camel.Exchange; //导入方法依赖的package包/类
@Override
public void process(Exchange exchange) throws Exception {
	Message requestMessage = exchange.getIn();	
	if (requestMessage.getHeader("messageCount") != null) {
		exchange.setProperty("messageCount", requestMessage.getHeader("messageCount", Integer.class));
		exchange.setProperty("messageToSend", requestMessage.getHeader("messageCount", Integer.class));
	} else {
		exchange.setProperty("messageCount", messageCount);
		exchange.setProperty("messageToSend", messageCount);
	}
	
	if (requestMessage.getHeader("messageSize") != null) {
		exchange.setProperty("messageSize", requestMessage.getHeader("messageSize", Integer.class));
	} else {
		exchange.setProperty("messageSize", messageSize);
	}
	
	if (requestMessage.getHeader("transactionBatchSize") != null) {
		exchange.setProperty("transactionBatchSize", requestMessage.getHeader("transactionBatchSize", Integer.class));
		exchange.setProperty("requestTransactionBatchSize", requestMessage.getHeader("transactionBatchSize", Integer.class));
	} else {
		exchange.setProperty("transactionBatchSize", transactionBatchSize);
	}
	
	if (requestMessage.getHeader("transacted") != null) {
		exchange.setProperty("transacted", requestMessage.getHeader("transacted", Boolean.class));
	} else {
		exchange.setProperty("transacted", transacted);
	}
	
	if (requestMessage.getHeader("msgTTL") != null) {
		exchange.setProperty("msgTTL", requestMessage.getHeader("msgTTL",Long.class));
	} else {
		exchange.setProperty("msgTTL", msgTTL);
	}
	
	if (requestMessage.getHeader("persistent") != null) {
		exchange.setProperty("persistent", requestMessage.getHeader("persistent", Boolean.class));
	} else {
		exchange.setProperty("persistent", persistent);
	}
	
	if (requestMessage.getHeader("msgGroupID") != null)
		exchange.setProperty("JMSXGroupID", requestMessage.getHeader("msgGroupID", String.class));
	
	exchange.setProperty("destination", requestMessage.getHeader("destination",String.class));
}
 

import org.apache.camel.Exchange; //导入方法依赖的package包/类
@Override
protected void onExchange(Exchange exchange) throws Exception {
    Message incomingMessage = exchange.getIn();
    String newResourceUri = incomingMessage.getHeader(AtlasConstants.ATLAS_RESOURCE_URI, String.class);
    if (newResourceUri != null) {
        incomingMessage.removeHeader(AtlasConstants.ATLAS_RESOURCE_URI);

        log.debug("{} set to {} creating new endpoint to handle exchange", AtlasConstants.ATLAS_RESOURCE_URI,
                newResourceUri);
        AtlasEndpoint newEndpoint = findOrCreateEndpoint(getEndpointUri(), newResourceUri);
        newEndpoint.onExchange(exchange);
        return;
    }

    AtlasSession atlasSession = getAtlasContext(incomingMessage).createSession();
    boolean sourceIsXmlOrJson = isSourceXmlOrJson(atlasSession.getMapping());
    Object body = incomingMessage.getBody();
    if (sourceIsXmlOrJson && body instanceof InputStream) {
        // read the whole stream into a String
        // the XML and JSON parsers expect that
        body = incomingMessage.getBody(String.class);
    }

    // TODO Lookup multiple inputs and map with corresponding source docId
    //      https://github.com/atlasmap/camel-atlasmap/issues/18
    atlasSession.setInput(body);
    atlasContext.process(atlasSession);

    List<Audit> errors = new ArrayList<>();
    for (Audit audit : atlasSession.getAudits().getAudit()) {
        switch (audit.getStatus()) {
        case ERROR:
            errors.add(audit);
            break;
        case WARN:
            LOG.warn("{}: docId='{}', path='{}'", audit.getMessage(), audit.getDocId(), audit.getPath());
            break;
        default:
            LOG.info("{}: docId='{}', path='{}'", audit.getMessage(), audit.getDocId(), audit.getPath());
        }
    }
    if (!errors.isEmpty()) {
        StringBuilder buf = new StringBuilder("Errors: ");
        errors.stream().forEach(a -> buf.append(
                String.format("[%s: docId='%s', path='%s'], ", a.getMessage(), a.getDocId(), a.getPath())));
        throw new AtlasException(buf.toString());
    }

    // now lets output the results to the exchange
    Message out = exchange.getOut();
    out.setBody(atlasSession.getOutput());
    out.setHeaders(incomingMessage.getHeaders());
    out.setAttachments(incomingMessage.getAttachments());
}
 

import org.apache.camel.Exchange; //导入方法依赖的package包/类
@Override
/* default */ Message message(final Exchange exchange) {
    return exchange.getIn();
}