Java StandardEngine类代码示例

import org.apache.catalina.core.StandardEngine; //导入依赖的package包/类
/**
 * Creates a new StandardService and StandardEngine.
 *
 * @param domain       Domain name for the container instance
 * @param defaultHost  Name of the default host to be used in the Engine
 * @param baseDir      Base directory value for Engine 
 *
 * @exception Exception if an MBean cannot be created or registered
 */
public String createStandardServiceEngine(String domain,
        String defaultHost, String baseDir) throws Exception{

    if (!(container instanceof Server)) {
        throw new Exception("Container not Server");
    }
    
    StandardEngine engine = new StandardEngine();
    engine.setDomain(domain);
    engine.setName(domain);
    engine.setDefaultHost(defaultHost);
    engine.setBaseDir(baseDir);

    Service service = new StandardService();
    service.setContainer(engine);
    service.setName(domain);
    
    ((Server) container).addService(service);
    
    return engine.getObjectName().toString();
}
 

import org.apache.catalina.core.StandardEngine; //导入依赖的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();
        if (engine instanceof StandardEngine) {
            int engineDebug = ((StandardEngine) engine).getDebug();
            if (engineDebug > this.debug)
                this.debug = engineDebug;
        }
    } catch (ClassCastException e) {
        log(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();

}
 

import org.apache.catalina.core.StandardEngine; //导入依赖的package包/类
/**
 * Create a new StandardEngine.
 *
 * @param parent MBean Name of the associated parent component
 * @param name Unique name of this Engine
 * @param defaultHost Default hostname of this Engine
 *
 * @exception Exception if an MBean cannot be created or registered
 */
public String createStandardEngine(String parent, String name,
                                   String defaultHost)
    throws Exception {

    // Create a new StandardEngine instance
    StandardEngine engine = new StandardEngine();
    engine.setName(name);
    engine.setDefaultHost(defaultHost);

    // Add the new instance to its parent component
    ObjectName pname = new ObjectName(parent);
    Server server = ServerFactory.getServer();
    Service service = server.findService(pname.getKeyProperty("name"));
    service.setContainer(engine);

    // Return the corresponding MBean name
    ManagedBean managed = registry.findManagedBean("StandardEngine");
    ObjectName oname =
        MBeanUtils.createObjectName(managed.getDomain(), engine);
    return (oname.toString());

}
 

import org.apache.catalina.core.StandardEngine; //导入依赖的package包/类
/**
 * Creates a new StandardService and StandardEngine.
 *
 * @param domain
 *            Domain name for the container instance
 * @param defaultHost
 *            Name of the default host to be used in the Engine
 * @param baseDir
 *            Base directory value for Engine
 *
 * @exception Exception
 *                if an MBean cannot be created or registered
 */
public String createStandardServiceEngine(String domain, String defaultHost, String baseDir) throws Exception {

	if (!(container instanceof Server)) {
		throw new Exception("Container not Server");
	}

	StandardEngine engine = new StandardEngine();
	engine.setDomain(domain);
	engine.setName(domain);
	engine.setDefaultHost(defaultHost);
	engine.setBaseDir(baseDir);

	Service service = new StandardService();
	service.setContainer(engine);
	service.setName(domain);

	((Server) container).addService(service);

	// engine.setService(service);

	return engine.getObjectName().toString();
}
 

import org.apache.catalina.core.StandardEngine; //导入依赖的package包/类
public static int getPort(Host h) {
	int port = -1;
	StandardHost host = (StandardHost) h;
	CatalinaUtil.host = (StandardHost) h;

	StandardEngine se = (StandardEngine) host.getParent();
	StandardService ss = (StandardService) se.getService();

	Connector[] cs = ss.findConnectors();
	for (Connector c : cs) {

		if (c.getProtocolHandlerClassName().contains("Http11Protocol"))
			port = c.getPort();
	}
	return port;
}
 

import org.apache.catalina.core.StandardEngine; //导入依赖的package包/类
@Test(description = "Tests the construction of Application Server URL for a sample request")
public void testConstructionOfApplicationServerURL() {
    Request request = new Request();

    Connector connector = new Connector();
    connector.setProtocol(TestConstants.SSL_PROTOCOL);
    connector.setPort(TestConstants.SSL_PORT);
    connector.setScheme(TestConstants.SSL_PROTOCOL);

    Engine engine = new StandardEngine();
    Service service = new StandardService();
    engine.setService(service);
    engine.getService().addConnector(connector);

    Host host = new StandardHost();
    host.setName(TestConstants.DEFAULT_TOMCAT_HOST);
    request.getMappingData().host = host;
    host.setParent(engine);

    Optional<String> actual = SSOUtils.constructApplicationServerURL(request);
    if (actual.isPresent()) {
        Assert.assertEquals(actual.get(), TestConstants.DEFAULT_APPLICATION_SERVER_URL);
    } else {
        Assert.fail();
    }
}
 

import org.apache.catalina.core.StandardEngine; //导入依赖的package包/类
@Test(description = "Tests the construction of Application Server URL for no SSL/TLS Connector")
public void testConstructionOfApplicationServerURLWithNoConnector() {
    Request request = new Request();

    Engine engine = new StandardEngine();
    Service service = new StandardService();
    engine.setService(service);

    Host host = new StandardHost();
    host.setName(TestConstants.DEFAULT_TOMCAT_HOST);
    request.getMappingData().host = host;
    host.setParent(engine);

    Optional<String> actual = SSOUtils.constructApplicationServerURL(request);
    Assert.assertTrue(!actual.isPresent());
}
 

import org.apache.catalina.core.StandardEngine; //导入依赖的package包/类
private void prepareCatalinaComponents() {
    engine = new StandardEngine();
    host = new StandardHost();
    fooContext = new StandardContext();
    barContext = new StandardContext();

    Connector connector = new Connector();
    connector.setProtocol(TestConstants.SSL_PROTOCOL);
    connector.setPort(TestConstants.SSL_PORT);
    connector.setScheme(TestConstants.SSL_PROTOCOL);

    Service service = new StandardService();
    engine.setService(service);
    engine.getService().addConnector(connector);

    host.setAppBase(TestConstants.WEB_APP_BASE);
    host.setName(TestConstants.DEFAULT_TOMCAT_HOST);
    host.setParent(engine);

    fooContext.setParent(host);
    fooContext.setDocBase(TestConstants.FOO_CONTEXT);
    barContext.setParent(host);
    barContext.setDocBase(TestConstants.BAR_CONTEXT);
}
 

import org.apache.catalina.core.StandardEngine; //导入依赖的package包/类
StandardEngine build()
{
	StandardEngine engine = new StandardEngine();
	engine.setName(name);
	engine.setDefaultHost(defaultHost);
	engine.setBaseDir(baseDir);
	engine.setBackgroundProcessorDelay(backgroundProcessorDelay);
	engine.setStartStopThreads(startStopThreads);
	engine.setJvmRoute(jvmRoute);

	for (HostConfiguration hostConfiguration : hosts)
	{
		Host host = hostConfiguration.build();
		engine.addChild(host);
	}

	return engine;
}
 

import org.apache.catalina.core.StandardEngine; //导入依赖的package包/类
private static ObjectName getDefaultClusterName(SimpleTcpCluster cluster) throws Exception {
    String domain = getMBeanServer().getDefaultDomain();
    String type = ":type=";
    String clusterType= type+"Cluster";
    if (cluster.getContainer() instanceof StandardHost) {
        domain = ((StandardHost) cluster.getContainer()).getDomain();
        clusterType += ",host=" + cluster.getContainer().getName();
    } else {
        if (cluster.getContainer() instanceof StandardEngine) {
            domain = ((StandardEngine) cluster.getContainer()).getDomain();
        }
    }
    ObjectName clusterName = new ObjectName(domain + clusterType);
    return clusterName;
}
 

import org.apache.catalina.core.StandardEngine; //导入依赖的package包/类
protected String getBaseDir() {
    Container engineC=context.getParent().getParent();
    if( engineC instanceof StandardEngine ) {
        return ((StandardEngine)engineC).getBaseDir();
    }
    return System.getProperty(Globals.CATALINA_BASE_PROP);
}
 

import org.apache.catalina.core.StandardEngine; //导入依赖的package包/类
protected String getBaseDir() {
    Container engineC=context.getParent().getParent();
    if( engineC instanceof StandardEngine ) {
        return ((StandardEngine)engineC).getBaseDir();
    }
    return System.getProperty("catalina.base");
}
 

import org.apache.catalina.core.StandardEngine; //导入依赖的package包/类
/**
 * Create the MBeans for the specified Engine and its nested components.
 *
 * @param engine Engine for which to create MBeans
 *
 * @exception Exception if an exception is thrown during MBean creation
 */
protected void createMBeans(Engine engine) throws Exception {

    // Create the MBean for the Engine itself
    if (log.isDebugEnabled()) {
        log.debug("Creating MBean for Engine " + engine);
    }
    //MBeanUtils.createMBean(engine);
    engine.addContainerListener(this);
    if (engine instanceof StandardEngine) {
        ((StandardEngine) engine).addPropertyChangeListener(this);
    }

    // Create the MBeans for the associated nested components
    Realm eRealm = engine.getRealm();
    if (eRealm != null) {
        if (log.isDebugEnabled())
            log.debug("Creating MBean for Realm " + eRealm);
        //MBeanUtils.createMBean(eRealm);
    }

    // Create the MBeans for each child Host
    Container hosts[] = engine.findChildren();
    for (int j = 0; j < hosts.length; j++) {
        createMBeans((Host) hosts[j]);
    }

}
 

import org.apache.catalina.core.StandardEngine; //导入依赖的package包/类
/**
 * Create a new StandardEngine.
 *
 * @param parent MBean Name of the associated parent component
 * @param engineName Unique name of this Engine
 * @param defaultHost Default hostname of this Engine
 * @param serviceName Unique name of this Service
 *
 * @exception Exception if an MBean cannot be created or registered
 */

public Vector createStandardEngineService(String parent, 
        String engineName, String defaultHost, String serviceName)
    throws Exception {

    // Create a new StandardService instance
    StandardService service = new StandardService();
    service.setName(serviceName);
    // Create a new StandardEngine instance
    StandardEngine engine = new StandardEngine();
    engine.setName(engineName);
    engine.setDefaultHost(defaultHost);
    // Need to set engine before adding it to server in order to set domain
    service.setContainer(engine);
    // Add the new instance to its parent component
    Server server = ServerFactory.getServer();
    server.addService(service);
    Vector onames = new Vector();
    // FIXME service & engine.getObjectName
    //ObjectName oname = engine.getObjectName();
    ObjectName oname = 
        MBeanUtils.createObjectName(engineName, engine);
    onames.add(0, oname);
    //oname = service.getObjectName();
    oname = 
        MBeanUtils.createObjectName(engineName, service);
    onames.add(1, oname);
    return (onames);

}
 

import org.apache.catalina.core.StandardEngine; //导入依赖的package包/类
@Test
public void test() throws Exception {
	StandardContext context = new StandardContext();
	context.setName("foo");
	WebappLoader loader = new WebappLoader() {
		@Override
		public ClassLoader getClassLoader() {
			return WebappLoader.class.getClassLoader();
		}
	};
	context.setLoader(loader);
	StandardHost host = new StandardHost();
	StandardEngine engine = new StandardEngine();
	engine.setService(new StandardService());
	host.setParent(engine);
	context.setParent(host);
	loader.setContext(context);

	RedisSessionManager manager = new RedisSessionManager();
	manager.setSessionIdGenerator(new StandardSessionIdGenerator());
	manager.setContext(context);
	manager.initializeSerializer();
	manager.initializeDatabaseConnection();
	manager.clear();
	
	StandardSession session = manager.createSession(null);
	session.setAttribute("foo", "test");
	
	manager.afterRequest();
	
	StandardSession loaded = manager.findSession(session.getId());
	Assert.assertEquals(session.getAttribute("foo"), loaded.getAttribute("foo"));
	
	Assert.assertEquals(1, manager.getSize());
	Assert.assertArrayEquals(new String[] { session.getId() }, manager.keys());
	
	manager.processExpires();

}