Java Processor.process方法代码示例

import org.apache.camel.Processor; //导入方法依赖的package包/类
@Override
	public Processor wrapProcessorInInterceptors(CamelContext context,
			final ProcessorDefinition<?> definition, final Processor target,
			final Processor nextTarget) throws Exception {
		return new DelegateAsyncProcessor(new Processor() {
			@Override
			public void process(Exchange exchange) throws Exception {
//				if(!camelConfig.isRunning()){
//					System.err.println("系统将关闭，不在处理任务");
//					return ;
//				}
				System.out.println("defainition :"+definition);
				System.out.println("nextTarget :"+nextTarget);
				target.process(exchange);
			}
		});
	}
 

import org.apache.camel.Processor; //导入方法依赖的package包/类
public boolean process(final Exchange exchange, final AsyncCallback callback) {
    List<Processor> list = getProcessors();
    // too hard to do multiple async, so we do it sync
    for (Processor processor : list) {
        try {
            Exchange copy = copyExchangeStrategy(processor, exchange);
            processor.process(copy);
        } catch (Throwable e) {
            exchange.setException(e);
            // stop on failure
            break;
        }
    }
    callback.done(true);
    return true;
}
 

import org.apache.camel.Processor; //导入方法依赖的package包/类
/**
 * Creates a {@link PollingConsumer} and polls all pending messages on the endpoint
 * and invokes the given {@link Processor} to process each {@link Exchange} and then closes
 * down the consumer and throws any exceptions thrown.
 */
public static void pollEndpoint(Endpoint endpoint, Processor processor, long timeout) throws Exception {
    PollingConsumer consumer = endpoint.createPollingConsumer();
    try {
        ServiceHelper.startService(consumer);

        while (true) {
            Exchange exchange = consumer.receive(timeout);
            if (exchange == null) {
                break;
            } else {
                processor.process(exchange);
            }
        }
    } finally {
        try {
            ServiceHelper.stopAndShutdownService(consumer);
        } catch (Exception e) {
            LOG.warn("Failed to stop PollingConsumer: " + consumer + ". This example is ignored.", e);
        }
    }
}
 

import org.apache.camel.Processor; //导入方法依赖的package包/类
public void processExpired(ActivityState activityState) throws Exception {
        Processor processor = getOverdueAction();
        if (processor != null) {
            Date now = new Date();
/*
            TODO this doesn't work and returns null for some strange reason
            ProcessInstance instance = activityState.getProcessInstance();
            ActivityState secondState = second.getActivityState(instance);
            if (secondState == null) {
                log.error("Could not find the second state! Process is: " 
                + instance + " with first state: " + first.getActivityState(instance) 
                + " and the state I was called with was: " + activityState);
            }
*/

            ActivityState secondState = activityState;
            Date overdue = secondState.getTimeOverdue();
            if (now.compareTo(overdue) >= 0) {
                Exchange exchange = createExchange();
                exchange.getIn().setBody(activityState);
                processor.process(exchange);
            } else {
                LOG.warn("Process has not actually expired; the time is: " + now + " but the overdue time is: " + overdue);
            }
        }
    }
 

import org.apache.camel.Processor; //导入方法依赖的package包/类
/**
 * Processes the exchange using a custom processor.
 *
 * @param exchange the exchange
 * @param processor the custom processor
 */
protected boolean customProcessExchange(final Exchange exchange, final Processor processor) {
    GenericFile<T> file = getExchangeFileProperty(exchange);
    log.trace("Custom processing file: {}", file);

    // must extract the absolute name before the begin strategy as the file could potentially be pre moved
    // and then the file name would be changed
    String absoluteFileName = file.getAbsoluteFilePath();

    try {
        // process using the custom processor
        processor.process(exchange);
    } catch (Exception e) {
        if (log.isDebugEnabled()) {
            log.debug(endpoint + " error custom processing: " + file + " due to: " + e.getMessage() + ". This exception will be ignored.", e);
        }
        handleException(e);
    } finally {
        // always remove file from the in progress list as its no longer in progress
        // use the original file name that was used to add it to the repository
        // as the name can be different when using preMove option
        endpoint.getInProgressRepository().remove(absoluteFileName);
    }

    return true;
}
 

import org.apache.camel.Processor; //导入方法依赖的package包/类
public Processor wrapProcessorInInterceptors(final CamelContext context, final ProcessorDefinition<?> definition,
                                             final Processor target, final Processor nextTarget) throws Exception {

    return new DelegateAsyncProcessor(new Processor() {

        public void process(Exchange exchange) throws Exception {
            // we just count number of interceptions
            count++;
            LOG.info("I am the container wide interceptor. Intercepted total count: " + count);
            target.process(exchange);
        }

        @Override
        public String toString() {
            return "ContainerWideInterceptor[" + target + "]";
        }
    });
}
 

import org.apache.camel.Processor; //导入方法依赖的package包/类
public Processor wrapProcessorInInterceptors(final CamelContext context, final ProcessorDefinition<?> definition,
                                             final Processor target, final Processor nextTarget) throws Exception {

    // as this is based on an unit test we are a bit lazy and just create an inlined processor
    // where we implement our interception logic.
    return new Processor() {
        public void process(Exchange exchange) throws Exception {
            // we just count number of interceptions
            count++;
            LOG.info("I am the container wide interceptor. Intercepted total count: " + count);
            // its important that we delegate to the real target so we let target process the exchange
            target.process(exchange);
        }

        @Override
        public String toString() {
            return "ContainerWideInterceptor[" + target + "]";
        }
    };
}
 

import org.apache.camel.Processor; //导入方法依赖的package包/类
/**
 * Processes the exchange by the processors
 *
 * @param processor the processor
 * @param exchange the exchange
 */
protected static void doProcess(Processor processor, Exchange exchange) {
    // must remember some properties which we cannot use during onCompletion processing
    // as otherwise we may cause issues
    // but keep the caused exception stored as a property (Exchange.EXCEPTION_CAUGHT) on the exchange
    Object stop = exchange.removeProperty(Exchange.ROUTE_STOP);
    Object failureHandled = exchange.removeProperty(Exchange.FAILURE_HANDLED);
    Object errorhandlerHandled = exchange.removeProperty(Exchange.ERRORHANDLER_HANDLED);
    Object rollbackOnly = exchange.removeProperty(Exchange.ROLLBACK_ONLY);
    Object rollbackOnlyLast = exchange.removeProperty(Exchange.ROLLBACK_ONLY_LAST);

    Exception cause = exchange.getException();
    exchange.setException(null);

    try {
        processor.process(exchange);
    } catch (Exception e) {
        exchange.setException(e);
    } finally {
        // restore the options
        if (stop != null) {
            exchange.setProperty(Exchange.ROUTE_STOP, stop);
        }
        if (failureHandled != null) {
            exchange.setProperty(Exchange.FAILURE_HANDLED, failureHandled);
        }
        if (errorhandlerHandled != null) {
            exchange.setProperty(Exchange.ERRORHANDLER_HANDLED, errorhandlerHandled);
        }
        if (rollbackOnly != null) {
            exchange.setProperty(Exchange.ROLLBACK_ONLY, rollbackOnly);
        }
        if (rollbackOnlyLast != null) {
            exchange.setProperty(Exchange.ROLLBACK_ONLY_LAST, rollbackOnlyLast);
        }
        if (cause != null) {
            exchange.setException(cause);
        }
    }
}
 

import org.apache.camel.Processor; //导入方法依赖的package包/类
public Processor wrap(RouteContext routeContext, final Processor processor) {
    return new Processor() {
        public void process(Exchange exchange) throws Exception {
            invoked++;
            // let the original processor continue routing
            exchange.getIn().setHeader(name, "was wrapped");
            processor.process(exchange);
            exchange.getIn().setHeader(name, "policy finished execution");
        }
    };
}
 

import org.apache.camel.Processor; //导入方法依赖的package包/类
/**
 * Applies the {@link Binding} processor to the given exchange before passing it on to the delegateProcessor (either a producer or consumer)
 */
public void pipelineBindingProcessor(Processor bindingProcessor, Exchange exchange, Processor delegateProcessor) throws Exception {
    bindingProcessor.process(exchange);

    Exchange delegateExchange = PipelineHelper.createNextExchange(exchange);
    delegateProcessor.process(delegateExchange);
}
 

import org.apache.camel.Processor; //导入方法依赖的package包/类
@Override
public Processor wrap(RouteContext routeContext, final Processor processor) {
    return new Processor() {
        @Override
        public void process(Exchange exchange) throws Exception {
            counter.incrementAndGet();
            processor.process(exchange);
        }
    };
}
 

import org.apache.camel.Processor; //导入方法依赖的package包/类
public Processor wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, final Processor target, Processor nextTarget) throws Exception {
    Processor answer = new Processor() {
        public void process(Exchange exchange) throws Exception {
            String order = exchange.getIn().getHeader("order", "", String.class);
            order = order + getOrder();
            exchange.getIn().setHeader("order", order);

            target.process(exchange);
        }
    };
    return answer;
}
 

import org.apache.camel.Processor; //导入方法依赖的package包/类
public Processor wrapProcessorInInterceptors(final CamelContext context, final ProcessorDefinition<?> definition,
                                             final Processor target, final Processor nextTarget) throws Exception {

    return new Processor() {
        public void process(Exchange exchange) throws Exception {
            // we just want to count number of interceptions
            counter.incrementAndGet();

            // and continue processing the exchange
            target.process(exchange);
        }
    };
}
 

import org.apache.camel.Processor; //导入方法依赖的package包/类
public Processor wrap(final RouteContext routeContext, final Processor processor) {
    return new Processor() {
        public void process(Exchange exchange) throws Exception {
            invoked++;
            exchange.getIn().setHeader(name, "was wrapped");
            processor.process(exchange);
        }
    };
}
 

import org.apache.camel.Processor; //导入方法依赖的package包/类
public void testDataFormatReturnsSameExchange() throws Exception {
    Exchange exchange = createExchangeWithBody(new DefaultCamelContext(), "body");
    Processor processor = new UnmarshalProcessor(new MyDataFormat(exchange));

    processor.process(exchange);

    assertEquals("UnmarshalProcessor did not copy OUT from IN message", "body", exchange.getOut().getBody());
}