| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package javax.jbi.component; |
| |
| import javax.jbi.JBIException; |
| import javax.management.ObjectName; |
| |
| /** |
| * This interface must be implemented by a JBI component to provide initialization, |
| * start, stop, and shutdown life cycle processing. These methods comprise the life |
| * cycle contract between the JBI implementation and the component. The life cycle |
| * of a component begins with a call to the init() method on an instance of the |
| * component's implementation of this interface, and ends with the first call to the |
| * shutDown() method on that instance. Between these two calls, there can be any |
| * number of stop() and start() calls. |
| * |
| * The JBI implementation must track the running state of a component, and ensure |
| * that life cycle state changes are always legal. For example, if the management |
| * interface for controlling a component's life cycle ({@link |
| * javax.jbi.management.ComponentLifeCycleMBean}) is used to start a component that |
| * was just installed (and thus in the <i>Shutdown</i> state), the implementation |
| * must invoke this component's {@link #init(ComponentContext)} method before |
| * invoking its {@link #start()} method. |
| * |
| * @author JSR208 Expert Group |
| */ |
| public interface ComponentLifeCycle { |
| |
| /** |
| * Get the JMX object name for the extension MBean for this component; if there |
| * is none, return null. |
| * |
| * @return the JMX object name of the additional MBean or null if there is no |
| * additional MBean. |
| */ |
| ObjectName getExtensionMBeanName(); |
| |
| /** |
| * Initialize the component. This performs initialization required by the component |
| * but does not make it ready to process messages. This method is called once for |
| * each life cycle of the component. |
| * |
| * If the component needs to register an additional MBean to extend its life cycle, |
| * or provide other component management tasks, it should be registered during this |
| * call. |
| * |
| * @param context the component's context, providing access to component data provided |
| * by the JBI environment; must be non-null. |
| * @throws JBIException if the component is unable to initialize. |
| */ |
| void init(ComponentContext context) throws JBIException; |
| |
| /** |
| * Shut down the component. This performs clean-up, releasing all run-time resources |
| * used by the component. Once this method has been called, {@link #init(ComponentContext)} |
| * must be called before the component can be started again with a call to {@link #start()}. |
| * |
| * @throws JBIException if the component is unable to shut down. |
| */ |
| void shutDown() throws JBIException; |
| |
| /** |
| * Start the component. This makes the component ready to process messages. This method |
| * is called after {@link #init(ComponentContext)}, both when the component is being |
| * started for the first time and when the component is being restarted after a previous |
| * call to {@link #shutDown()}. If {@link #stop()} was called previously but {@link #shutDown()} |
| * was not, {@link #start()} can be called again without another call to |
| * {@link #init(ComponentContext)}. |
| * |
| * @throws JBIException if the component is unable to start. |
| */ |
| void start() throws JBIException; |
| |
| /** |
| * Stop the component. This makes the component stop accepting messages for processing. |
| * After a call to this method, {@link #start()} may be called again without first |
| * calling {@link #init(ComponentContext)}. |
| * |
| * @throws JBIException if the component is unable to stop. |
| */ |
| void stop() throws JBIException; |
| } |