In Chapter 4, Starting Examples , we briefly discussed how to run a Microcontainer application by loading the StandaloneBootstrap class, which in turn wraps the BasicBootstrap and BeanXMLDeployer utility classes. In this chapter, we will look into the source code of StandaloneBootstrap and see exactly how it works. While the StandaloneBootstrap class is sufficient for most use case scenarios, you do not have to use it. You can trivially write your own class that uses the BasicBootstrap and BeanXMLDeployer .

      package org.jboss.kernel.plugins.bootstrap.standalone;

      import java.net.URL;
      import java.util.Enumeration;
      import java.util.List;
      import java.util.ListIterator;

      import org.jboss.kernel.plugins.bootstrap.basic.BasicBootstrap;
      import org.jboss.kernel.plugins.deployment.xml.BeanXMLDeployer;
      import org.jboss.kernel.spi.deployment.KernelDeployment;
      import org.jboss.util.collection.CollectionsFactory;

      public class StandaloneBootstrap extends BasicBootstrap
      {
      /** The deployer */
      protected BeanXMLDeployer deployer;

      /** The deployments */
      protected List deployments = CollectionsFactory.createCopyOnWriteList();

      /** The arguments */
      protected String[] args;

      /**
      * Bootstrap the kernel from the command line
      *
      * @param args the command line arguments
      * @throws Exception for any error
      */
      public static void main(String[] args) throws Exception
      {
      StandaloneBootstrap bootstrap = new StandaloneBootstrap(args);
      bootstrap.run();
      }

      /**
      * Create a new bootstrap
      */
      public StandaloneBootstrap(String[] args) throws Exception
      {
      super();
      this.args = args;
      }

      public void bootstrap() throws Throwable
      {
      super.bootstrap();

      deployer = new BeanXMLDeployer(getKernel());

      Runtime.getRuntime().addShutdownHook(new Shutdown());

      ClassLoader cl = Thread.currentThread().getContextClassLoader();
      for (Enumeration e =
      cl.getResources(StandaloneKernelConstants.DEPLOYMENT_XML_NAME);
      e.hasMoreElements(); )
      {
      URL url = (URL) e.nextElement();
      deploy(url);
      }
      for (Enumeration e = cl.getResources("META-INF/" +
      StandaloneKernelConstants.DEPLOYMENT_XML_NAME);
      e.hasMoreElements(); )
      {
      URL url = (URL) e.nextElement();
      deploy(url);
      }

      // Validate that everything is ok
      deployer.validate();
      }

      /**
      * Deploy a url
      */
      protected void deploy(URL url) throws Throwable
      {
      log.debug("Deploying " + url);
      KernelDeployment deployment = deployer.deploy(url);
      deployments.add(deployment);
      log.debug("Deployed " + url);
      }

      /**
      * Undeploy a deployment
      */
      protected void undeploy(KernelDeployment deployment)
      {
      log.debug("Undeploying " + deployment.getName());
      deployments.remove(deployment);
      try
      {
      deployer.undeploy(deployment);
      log.debug("Undeployed " + deployment.getName());
      }
      catch (Throwable t)
      {
      log.warn("Error during undeployment: " + deployment.getName(), t);
      }
      }

      protected class Shutdown extends Thread
      {
      public void run()
      {
      log.info("Shutting down");
      ListIterator iterator =
      deployments.listIterator(deployments.size());
      while (iterator.hasPrevious())
      {
      KernelDeployment deployment =
      (KernelDeployment) iterator.previous();
      undeploy(deployment);
      }
      }
      }
      }
   

One way to use this class in your own applications would be:

      import org.jboss.kernel.plugins.bootstrap.standalone.StandaloneBootstrap

      public MyMainClass
      {
      public static void main(String[] args) throws Exception
      {
      StandaloneBootstrap.main(args);
      // Your stuff here...
      }
      }
   

So what does the standalone bootstrap do?

First it does the plain bootstrap to get the "kernel" ready. You can think of this a sophisticated form of ServerLocator implementation. It then creates a BeanXMLDeployer for deploying XML files. Next it adds a shutdown hook, such that deployments are correctly "undeployed" in reverse order to their deployment. Finally, it scans the classpath for META-INF/jboss-beans.xml and deploys every instance of that file it finds to populate the "kernel".

You can of course choose not to use this helper class and instead implement your own processing rules.