Java Lifecycle類代碼示例

import org.apache.catalina.Lifecycle; //導入依賴的package包/類
/**
 * Ensure child Realms are destroyed when this Realm is destroyed.
 */
@Override
protected void destroyInternal() throws LifecycleException {
    for (Realm realm : realms) {
        if (realm instanceof Lifecycle) {
            ((Lifecycle) realm).destroy();
        }
    }
    super.destroyInternal();
}
 

import org.apache.catalina.Lifecycle; //導入依賴的package包/類
/**
 * Prepare for the beginning of active use of the public methods of this
 * component and implement the requirements of
 * {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
 *
 * @exception LifecycleException
 *                if this component detects a fatal error that prevents this
 *                component from being used
 */
@Override
protected void startInternal() throws LifecycleException {
	// Start 'sub-realms' then this one
	Iterator<Realm> iter = realms.iterator();

	while (iter.hasNext()) {
		Realm realm = iter.next();
		if (realm instanceof Lifecycle) {
			try {
				((Lifecycle) realm).start();
			} catch (LifecycleException e) {
				// If realm doesn't start can't authenticate against it
				iter.remove();
				log.error(sm.getString("combinedRealm.realmStartFail", realm.getInfo()), e);
			}
		}
	}
	super.startInternal();
}
 

import org.apache.catalina.Lifecycle; //導入依賴的package包/類
/**
 * Stop an existing web application, attached to the specified context
 * path.  Only stops a web application if it is running.
 *
 * @param contextPath The context path of the application to be stopped
 *
 * @exception IllegalArgumentException if the specified context path
 *  is malformed (it must be "" or start with a slash)
 * @exception IllegalArgumentException if the specified context path does
 *  not identify a currently installed web application
 * @exception IOException if an input/output error occurs while stopping
 *  the web application
 */
public void stop(String contextPath) throws IOException {

    // Validate the format and state of our arguments
    if (contextPath == null)
        throw new IllegalArgumentException
            (sm.getString("standardHost.pathRequired"));
    if (!contextPath.equals("") && !contextPath.startsWith("/"))
        throw new IllegalArgumentException
            (sm.getString("standardHost.pathFormat", contextPath));
    Context context = findDeployedApp(contextPath);
    if (context == null)
        throw new IllegalArgumentException
            (sm.getString("standardHost.pathMissing", contextPath));
    host.log("standardHost.stop " + contextPath);
    try {
        ((Lifecycle) context).stop();
    } catch (LifecycleException e) {
        host.log("standardHost.stop " + contextPath + ": ", e);
        throw new IllegalStateException
            ("standardHost.stop " + contextPath + ": " + e);
    }

}
 

import org.apache.catalina.Lifecycle; //導入依賴的package包/類
@Override
public void lifecycleEvent(LifecycleEvent event) {
    try {
        Context context = (Context) event.getLifecycle();
        if (event.getType().equals(Lifecycle.CONFIGURE_START_EVENT)) {
            context.setConfigured(true);
        }
        // LoginConfig is required to process @ServletSecurity
        // annotations
        if (context.getLoginConfig() == null) {
            context.setLoginConfig(
                    new LoginConfig("NONE", null, null, null));
            context.getPipeline().addValve(new NonLoginAuthenticator());
        }
    } catch (ClassCastException e) {
        return;
    }
}
 

import org.apache.catalina.Lifecycle; //導入依賴的package包/類
/**
 * Prepare for the beginning of active use of the public methods of this
 * component.  This method should be called before any of the public
 * methods of this component are utilized.  It should also send a
 * LifecycleEvent of type START_EVENT to any registered listeners.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that prevents this component from being used
 */
public void start() throws LifecycleException {

    // Validate and update our current component state
    if (started)
        throw new LifecycleException
            (sm.getString("standardServer.start.started"));
    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);

    lifecycle.fireLifecycleEvent(START_EVENT, null);
    started = true;

    // Start our defined Services
    synchronized (services) {
        for (int i = 0; i < services.length; i++) {
            if (services[i] instanceof Lifecycle)
                ((Lifecycle) services[i]).start();
        }
    }

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);

}
 

import org.apache.catalina.Lifecycle; //導入依賴的package包/類
/**
 * Start {@link Valve}s) in this pipeline and implement the requirements
 * of {@link LifecycleBase#startInternal()}.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that prevents this component from being used
 */
@Override
protected synchronized void startInternal() throws LifecycleException {

    // Start the Valves in our pipeline (including the basic), if any
    Valve current = first;
    if (current == null) {
        current = basic;
    }
    while (current != null) {
        if (current instanceof Lifecycle)
            ((Lifecycle) current).start();
        current = current.getNext();
    }

    setState(LifecycleState.STARTING);
}
 

import org.apache.catalina.Lifecycle; //導入依賴的package包/類
/**
 * Prepare for the beginning of active use of the public methods of this
 * component and implement the requirements of
 * {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that prevents this component from being used
 */
@Override
protected void startInternal() throws LifecycleException {
    // Start 'sub-realms' then this one
    Iterator<Realm> iter = realms.iterator();
    
    while (iter.hasNext()) {
        Realm realm = iter.next();
        if (realm instanceof Lifecycle) {
            try {
                ((Lifecycle) realm).start();
            } catch (LifecycleException e) {
                // If realm doesn't start can't authenticate against it
                iter.remove();
                log.error(sm.getString("combinedRealm.realmStartFail",
                        realm.getInfo()), e);
            }
        }
    }
    super.startInternal();
}
 

import org.apache.catalina.Lifecycle; //導入依賴的package包/類
@Override
public final synchronized void init() throws LifecycleException {

    /**
     * 檢查當前狀態是否為New,避免重複初始化,注意state為volatile
     */
    if (!state.equals(LifecycleState.NEW)) {
        invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
    }

    try {
        setStateInternal(LifecycleState.INITIALIZING, null, false);
        initInternal();
        setStateInternal(LifecycleState.INITIALIZED, null, false);
    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        setStateInternal(LifecycleState.FAILED, null, false);
        throw new LifecycleException(
                sm.getString("lifecycleBase.initFail",toString()), t);
    }
}
 

import org.apache.catalina.Lifecycle; //導入依賴的package包/類
/**
 * Primary entry point for startup and shutdown events.
 *
 * @param event The event that has occurred
 */
@Override
public void lifecycleEvent(LifecycleEvent event) {

    if (Lifecycle.BEFORE_INIT_EVENT.equals(event.getType())) {
        try {
            // Set JSP factory
            Class.forName("org.apache.jasper.compiler.JspRuntimeContext",
                          true,
                          this.getClass().getClassLoader());
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
            // Should not occur, obviously
            log.warn("Couldn't initialize Jasper", t);
        }
        // Another possibility is to do directly:
        // JspFactory.setDefaultFactory(new JspFactoryImpl());
    }

}
 

import org.apache.catalina.Lifecycle; //導入依賴的package包/類
/**
 * Process the START event for an associated Host.
 *
 * @param event
 *            The lifecycle event that has occurred
 */
@Override
public void lifecycleEvent(LifecycleEvent event) {

	// Identify the host we are associated with
	try {
		host = (Host) event.getLifecycle();
	} catch (ClassCastException e) {
		log.error(sm.getString("hostConfig.cce", event.getLifecycle()), e);
		return;
	}

	// Process the event that has occurred
	if (event.getType().equals(Lifecycle.START_EVENT))
		start();
	else if (event.getType().equals(Lifecycle.STOP_EVENT))
		stop();

}
 

import org.apache.catalina.Lifecycle; //導入依賴的package包/類
/**
 * <p>Add a new Valve to the end of the pipeline associated with this
 * Container.  Prior to adding the Valve, the Valve's
 * <code>setContainer()</code> method will be called, if it implements
 * <code>Contained</code>, with the owning Container as an argument.
 * The method may throw an
 * <code>IllegalArgumentException</code> if this Valve chooses not to
 * be associated with this Container, or <code>IllegalStateException</code>
 * if it is already associated with a different Container.</p>
 *
 * @param valve Valve to be added
 *
 * @exception IllegalArgumentException if this Container refused to
 *  accept the specified Valve
 * @exception IllegalArgumentException if the specifie Valve refuses to be
 *  associated with this Container
 * @exception IllegalStateException if the specified Valve is already
 *  associated with a different Container
 */
public void addValve(Valve valve) {

    // Validate that we can add this Valve
    if (valve instanceof Contained)
        ((Contained) valve).setContainer(this.container);

    // Start the new component if necessary
    if (started && (valve instanceof Lifecycle)) {
        try {
            ((Lifecycle) valve).start();
        } catch (LifecycleException e) {
            log("StandardPipeline.addValve: start: ", e);
        }
    }

    // Add this Valve to the set associated with this Pipeline
    synchronized (valves) {
        Valve results[] = new Valve[valves.length +1];
        System.arraycopy(valves, 0, results, 0, valves.length);
        results[valves.length] = valve;
        valves = results;
    }

}
 

import org.apache.catalina.Lifecycle; //導入依賴的package包/類
/**
 * Create and return a new processor suitable for processing HTTP
 * requests and returning the corresponding responses.
 */
private HttpProcessor newProcessor() {

    HttpProcessor processor = new HttpProcessor(this, curProcessors++);
    if (processor instanceof Lifecycle) {
        try {
            ((Lifecycle) processor).start();
        } catch (LifecycleException e) {
            log("newProcessor", e);
            return (null);
        }
    }
    created.addElement(processor);
    return (processor);

}
 

import org.apache.catalina.Lifecycle; //導入依賴的package包/類
/**
 * Stop {@link Valve}s) in this pipeline and implement the requirements of
 * {@link LifecycleBase#stopInternal()}.
 *
 * @exception LifecycleException
 *                if this component detects a fatal error that prevents this
 *                component from being used
 */
@Override
protected synchronized void stopInternal() throws LifecycleException {

	setState(LifecycleState.STOPPING);

	// Stop the Valves in our pipeline (including the basic), if any
	Valve current = first;
	if (current == null) {
		current = basic;
	}
	while (current != null) {
		if (current instanceof Lifecycle)
			((Lifecycle) current).stop();
		current = current.getNext();
	}
}
 

import org.apache.catalina.Lifecycle; //導入依賴的package包/類
/**
 * Stop an existing server instance.
 */
public void stop() {

    try {
        // Remove the ShutdownHook first so that server.stop() 
        // doesn't get invoked twice
        if (useShutdownHook) {
            Runtime.getRuntime().removeShutdownHook(shutdownHook);
        }
    } catch (Throwable t) {
        // This will fail on JDK 1.2. Ignoring, as Tomcat can run
        // fine without the shutdown hook.
    }

    // Shut down the server
    if (server instanceof Lifecycle) {
        try {
            ((Lifecycle) server).stop();
        } catch (LifecycleException e) {
            log.error("Catalina.stop", e);
        }
    }

}
 

import org.apache.catalina.Lifecycle; //導入依賴的package包/類
/**
 * Process the START event for an associated Engine.
 *
 * @param event The lifecycle event that has occurred
 */
public void lifecycleEvent(LifecycleEvent event) {

    // Identify the engine we are associated with
    try {
        engine = (Engine) event.getLifecycle();
    } catch (ClassCastException e) {
        log.error(sm.getString("engineConfig.cce", event.getLifecycle()), e);
        return;
    }

    // Process the event that has occurred
    if (event.getType().equals(Lifecycle.START_EVENT))
        start();
    else if (event.getType().equals(Lifecycle.STOP_EVENT))
        stop();

}