Java ServiceHelper.stopAndShutdownService方法代码示例

import org.apache.camel.util.ServiceHelper; //导入方法依赖的package包/类
private void shutdownServices(Object service) {
    // do not rethrow exception as we want to keep shutting down in case of problems

    // allow us to do custom work before delegating to service helper
    try {
        if (service instanceof Service) {
            ServiceHelper.stopAndShutdownService(service);
        } else if (service instanceof Collection) {
            ServiceHelper.stopAndShutdownServices((Collection<?>)service);
        }
    } catch (Throwable e) {
        log.warn("Error occurred while shutting down service: " + service + ". This exception will be ignored.", e);
        // fire event
        EventHelper.notifyServiceStopFailure(this, service, e);
    }
}
 

import org.apache.camel.util.ServiceHelper; //导入方法依赖的package包/类
protected void doStop() throws Exception {
    // when stopping we intend to shutdown
    ServiceHelper.stopAndShutdownService(statistics);
    if (stopServicePool) {
        ServiceHelper.stopAndShutdownService(pool);
    }
    try {
        ServiceHelper.stopAndShutdownServices(producers.values());
    } finally {
        // ensure producers are removed, and also from JMX
        for (Producer producer : producers.values()) {
            getCamelContext().removeService(producer);
        }
    }
    producers.clear();
    if (statistics != null) {
        statistics.clear();
    }
}
 

import org.apache.camel.util.ServiceHelper; //导入方法依赖的package包/类
/**
 * Releases an acquired producer back after usage.
 *
 * @param endpoint the endpoint
 * @param pollingConsumer the pollingConsumer to release
 */
public void releasePollingConsumer(Endpoint endpoint, PollingConsumer pollingConsumer) {
    if (pollingConsumer instanceof ServicePoolAware) {
        // release back to the pool
        pool.release(endpoint, pollingConsumer);
    } else {
        boolean singleton = false;
        if (pollingConsumer instanceof IsSingleton) {
            singleton = ((IsSingleton) pollingConsumer).isSingleton();
        }
        if (!singleton) {
            try {
                // stop and shutdown non-singleton producers as we should not leak resources
                ServiceHelper.stopAndShutdownService(pollingConsumer);
            } catch (Exception ex) {
                if (ex instanceof RuntimeCamelException) {
                    throw (RuntimeCamelException)ex;
                } else {
                    throw new RuntimeCamelException(ex);
                }
            }
        }
    }
}
 

import org.apache.camel.util.ServiceHelper; //导入方法依赖的package包/类
@Override
protected void doStop() throws Exception {
    // stop event notifier
    camelContext.getManagementStrategy().removeEventNotifier(eventNotifier);
    ServiceHelper.stopService(eventNotifier);

    // stop and close collector
    ServiceHelper.stopAndShutdownService(spanCollector);
    if (spanCollector instanceof Closeable) {
        IOHelper.close((Closeable) spanCollector);
    }
    // clear braves
    braves.clear();
    // remove route policy
    camelContext.getRoutePolicyFactories().remove(this);
}
 

import org.apache.camel.util.ServiceHelper; //导入方法依赖的package包/类
@Override
protected void doShutdown() throws Exception {
    ServiceHelper.stopAndShutdownService(processor);
    if (shutdownExecutorService) {
        getCamelContext().getExecutorServiceManager().shutdownNow(executorService);
    }
}
 

import org.apache.camel.util.ServiceHelper; //导入方法依赖的package包/类
@Override
public void releasePollingConsumer(Endpoint endpoint, PollingConsumer pollingConsumer) {
    // stop and shutdown the consumer as its not cache or reused
    try {
        ServiceHelper.stopAndShutdownService(pollingConsumer);
    } catch (Exception e) {
        throw ObjectHelper.wrapRuntimeCamelException(e);
    }
}
 

import org.apache.camel.util.ServiceHelper; //导入方法依赖的package包/类
/**
 * Releases an acquired producer back after usage.
 *
 * @param endpoint the endpoint
 * @param producer the producer to release
 * @throws Exception can be thrown if error stopping producer if that was needed.
 */
public void releaseProducer(Endpoint endpoint, Producer producer) throws Exception {
    if (producer instanceof ServicePoolAware) {
        // release back to the pool
        pool.release(endpoint, producer);
    } else if (!producer.isSingleton()) {
        // stop and shutdown non-singleton producers as we should not leak resources
        ServiceHelper.stopAndShutdownService(producer);
    }
}
 

import org.apache.camel.util.ServiceHelper; //导入方法依赖的package包/类
protected void doShutdown() throws Exception {
    ServiceHelper.stopAndShutdownService(producerCache);
    super.doShutdown();
}
 

import org.apache.camel.util.ServiceHelper; //导入方法依赖的package包/类
protected void doStop() throws Exception {
    // we should shutdown the services as this is our intention, to not re-use the services anymore
    ServiceHelper.stopAndShutdownService(consumerCache);
    consumerCache = null;
}
 

import org.apache.camel.util.ServiceHelper; //导入方法依赖的package包/类
@Override
public void releaseProducer(Endpoint endpoint, Producer producer) throws Exception {
    // stop and shutdown the producer as its not cache or reused
    ServiceHelper.stopAndShutdownService(producer);
}
 

import org.apache.camel.util.ServiceHelper; //导入方法依赖的package包/类
protected void doShutdown() throws Exception {
    ServiceHelper.stopAndShutdownService(consumer);
    queue.clear();
}
 

import org.apache.camel.util.ServiceHelper; //导入方法依赖的package包/类
@Override
protected void doShutdown() throws Exception {
    super.doStop();
    ServiceHelper.stopAndShutdownService(validatingProcessor);
}
 

import org.apache.camel.util.ServiceHelper; //导入方法依赖的package包/类
public void testQueueSize() throws Exception {
    // must start context as we do not use route builder that auto-start
    context.start();

    PollingConsumer consumer = context.getEndpoint(uri).createPollingConsumer();
    consumer.start();

    assertNotNull(consumer);
    EventDrivenPollingConsumer edpc = assertIsInstanceOf(EventDrivenPollingConsumer.class, consumer);
    assertEquals(0, edpc.getQueueSize());
    assertEquals(10, edpc.getQueueCapacity());
    assertFalse(edpc.isBlockWhenFull());

    for (int i = 0; i < 10; i++) {
        template.sendBody(uri, "Message " + i);
    }

    assertEquals(10, edpc.getQueueSize());

    try {
        template.sendBody(uri, "Message 10");
        fail("Should have thrown exception");
    } catch (CamelExecutionException e) {
        // queue should be full
        assertIsInstanceOf(IllegalStateException.class, e.getCause());
    }

    Exchange out = consumer.receive(5000);
    assertNotNull(out);
    assertEquals("Message 0", out.getIn().getBody());

    assertEquals(9, edpc.getQueueSize());
    assertEquals(10, edpc.getQueueCapacity());

    // now there is room
    template.sendBody(uri, "Message 10");

    assertEquals(10, edpc.getQueueSize());
    assertEquals(10, edpc.getQueueCapacity());

    ServiceHelper.stopService(consumer);
    // not cleared if we stop
    assertEquals(10, edpc.getQueueSize());
    assertEquals(10, edpc.getQueueCapacity());

    ServiceHelper.stopAndShutdownService(consumer);
    // now its cleared as we shutdown
    assertEquals(0, edpc.getQueueSize());
    assertEquals(10, edpc.getQueueCapacity());
}
 

import org.apache.camel.util.ServiceHelper; //导入方法依赖的package包/类
public void destroy() throws Exception {
    if (consumer != null) {
        ServiceHelper.stopAndShutdownService(consumer);
    }
}