Version: 9.4.12.v20180830 |

Embedded Examples
Previous | Chapter 21. Embedding Home | Next

##### Contact the core Jetty developers at www.webtide.com

private support for your internal/customer projects ... custom extensions and distributions ... versioned snapshots for indefinite support ... scalability guidance for your apps and Ajax/Comet projects ... development services for sponsored feature development

## Embedded Examples

Jetty has a rich history of being embedded into a wide variety of applications. In this section we will walk you through a number of our simple examples under our embedded-jetty-examples project in our git repository.

> ### Important

> These files are pulled directly from our git repository when this document is generated. If the line numbers do not line up feel free to fix this documentation in github and give us a pull request, or at least open an issue to notify us of the discrepancy.

### Simple File Server

This example shows how to create a simple file server in Jetty. It is perfectly suitable for test cases where you need an actual web server to obtain a file from, it could easily be configured to serve files from a directory under `src/test/resources`. Note that this does not have any logic for caching of files, either within the server or setting the appropriate headers on the response. It is simply a few lines that illustrate how easy it is to serve out some files.

    //
    //  ========================================================================
    //  Copyright (c) 1995-2018 Mort Bay Consulting Pty. Ltd.
    //  ------------------------------------------------------------------------
    //  All rights reserved. This program and the accompanying materials
    //  are made available under the terms of the Eclipse Public License v1.0
    //  and Apache License v2.0 which accompanies this distribution.
    //
    //      The Eclipse Public License is available at
    //      http://www.eclipse.org/legal/epl-v10.html
    //
    //      The Apache License v2.0 is available at
    //      http://www.opensource.org/licenses/apache2.0.php
    //
    //  You may elect to redistribute this code under either of these licenses.
    //  ========================================================================
    //

    package org.eclipse.jetty.embedded;

    import org.eclipse.jetty.server.Handler;
    import org.eclipse.jetty.server.Server;
    import org.eclipse.jetty.server.handler.DefaultHandler;
    import org.eclipse.jetty.server.handler.HandlerList;
    import org.eclipse.jetty.server.handler.ResourceHandler;

    /**
     * Simple Jetty FileServer.
     * This is a simple example of Jetty configured as a FileServer.
     */
    public class FileServer
    {
        public static void main(String[] args) throws Exception
        {
            // Create a basic Jetty server object that will listen on port 8080.  Note that if you set this to port 0
            // then a randomly available port will be assigned that you can either look in the logs for the port,
            // or programmatically obtain it for use in test cases.
            Server server = new Server(8080);

            // Create the ResourceHandler. It is the object that will actually handle the request for a given file. It is
            // a Jetty Handler object so it is suitable for chaining with other handlers as you will see in other examples.
            ResourceHandler resource_handler = new ResourceHandler();

            // Configure the ResourceHandler. Setting the resource base indicates where the files should be served out of.
            // In this example it is the current directory but it can be configured to anything that the jvm has access to.
            resource_handler.setDirectoriesListed(true);
            resource_handler.setWelcomeFiles(new String[]{ "index.html" });
            resource_handler.setResourceBase(".");

            // Add the ResourceHandler to the server.
            HandlerList handlers = new HandlerList();
            handlers.setHandlers(new Handler[] { resource_handler, new DefaultHandler() });
            server.setHandler(handlers);

            // Start things up! By using the server.join() the server thread will join with the current thread.
            // See "http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Thread.html#join()" for more details.
            server.start();
            server.join();
        }
    }

#### Run it!

After you have started things up you should be able to navigate to http://localhost:8080/index.html (assuming one is in the resource base directory) and you are good to go.

#### Maven Coordinates

To use this example in your project you will need the following Maven dependencies declared.

    <dependency>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-server</artifactId>
      <version>${project.version}</version>
    </dependency>

### Split File Server

This example builds on the Simple File Server to show how chaining multiple `ResourceHandlers` together can let you aggregate multiple directories to serve content on a single path and how you can link these together with `ContextHandlers`.

    //
    //  ========================================================================
    //  Copyright (c) 1995-2018 Mort Bay Consulting Pty. Ltd.
    //  ------------------------------------------------------------------------
    //  All rights reserved. This program and the accompanying materials
    //  are made available under the terms of the Eclipse Public License v1.0
    //  and Apache License v2.0 which accompanies this distribution.
    //
    //      The Eclipse Public License is available at
    //      http://www.eclipse.org/legal/epl-v10.html
    //
    //      The Apache License v2.0 is available at
    //      http://www.opensource.org/licenses/apache2.0.php
    //
    //  You may elect to redistribute this code under either of these licenses.
    //  ========================================================================
    //

    package org.eclipse.jetty.embedded;

    import java.io.File;

    import org.eclipse.jetty.server.Connector;
    import org.eclipse.jetty.server.Handler;
    import org.eclipse.jetty.server.Server;
    import org.eclipse.jetty.server.ServerConnector;
    import org.eclipse.jetty.server.handler.ContextHandler;
    import org.eclipse.jetty.server.handler.ContextHandlerCollection;
    import org.eclipse.jetty.server.handler.ResourceHandler;
    import org.eclipse.jetty.toolchain.test.MavenTestingUtils;
    import org.eclipse.jetty.util.resource.Resource;

    /**
     * A {@link ContextHandlerCollection} handler may be used to direct a request to
     * a specific Context. The URI path prefix and optional virtual host is used to
     * select the context.
     */
    public class SplitFileServer
    {
        public static void main( String[] args ) throws Exception
        {
            // Create the Server object and a corresponding ServerConnector and then
            // set the port for the connector. In this example the server will
            // listen on port 8090. If you set this to port 0 then when the server
            // has been started you can called connector.getLocalPort() to
            // programmatically get the port the server started on.
            Server server = new Server();
            ServerConnector connector = new ServerConnector(server);
            connector.setPort(8090);
            server.setConnectors(new Connector[] { connector });

            // Create a Context Handler and ResourceHandler. The ContextHandler is
            // getting set to "/" path but this could be anything you like for
            // builing out your url. Note how we are setting the ResourceBase using
            // our jetty maven testing utilities to get the proper resource
            // directory, you needn't use these, you simply need to supply the paths
            // you are looking to serve content from.
            ResourceHandler rh0 = new ResourceHandler();

            ContextHandler context0 = new ContextHandler();
            context0.setContextPath("/");
            File dir0 = MavenTestingUtils.getTestResourceDir("dir0");
            context0.setBaseResource(Resource.newResource(dir0));
            context0.setHandler(rh0);

            // Rinse and repeat the previous item, only specifying a different
            // resource base.
            ResourceHandler rh1 = new ResourceHandler();

            ContextHandler context1 = new ContextHandler();
            context1.setContextPath("/");
            File dir1 = MavenTestingUtils.getTestResourceDir("dir1");
            context1.setBaseResource(Resource.newResource(dir1));
            context1.setHandler(rh1);

            // Create a ContextHandlerCollection and set the context handlers to it.
            // This will let jetty process urls against the declared contexts in
            // order to match up content.
            ContextHandlerCollection contexts = new ContextHandlerCollection();
            contexts.setHandlers(new Handler[] { context0, context1 });

            server.setHandler(contexts);

            // Start things up!
            server.start();

            // Dump the server state
            System.out.println(server.dump());

            // The use of server.join() the will make the current thread join and
            // wait until the server is done executing.
            // See http://docs.oracle.com/javase/7/docs/api/java/lang/Thread.html#join()
            server.join();
        }
    }

#### Run it!

After you have started things up you should be able to navigate to http://localhost:8090/index.html (assuming one is in the resource base directory) and you are good to go. Any requests for files will be looked for in the first resource handler, then the second, and so on and so forth.

#### Maven Coordinates

To use this example as is in your project you will need the following maven dependencies declared. We would recommend not using the toolchain dependency in your actual application.

    <dependency>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-server</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>org.eclipse.jetty.toolchain</groupId>
      <artifactId>jetty-test-helper</artifactId>
      <version>2.2</version>
    </dependency>

### Multiple Connectors

This example shows how to configure Jetty to use multiple connectors, specifically so it can process both http and https requests. Since the meat of this example is the server and connector configuration it only uses a simple HelloHandler but this example should be easily merged with other examples like those deploying servlets or webapps.

    //
    //  ========================================================================
    //  Copyright (c) 1995-2018 Mort Bay Consulting Pty. Ltd.
    //  ------------------------------------------------------------------------
    //  All rights reserved. This program and the accompanying materials
    //  are made available under the terms of the Eclipse Public License v1.0
    //  and Apache License v2.0 which accompanies this distribution.
    //
    //      The Eclipse Public License is available at
    //      http://www.eclipse.org/legal/epl-v10.html
    //
    //      The Apache License v2.0 is available at
    //      http://www.opensource.org/licenses/apache2.0.php
    //
    //  You may elect to redistribute this code under either of these licenses.
    //  ========================================================================
    //

    package org.eclipse.jetty.embedded;

    import java.io.File;
    import java.io.FileNotFoundException;
    import java.security.Security;

    import org.conscrypt.OpenSSLProvider;
    import org.eclipse.jetty.http.HttpVersion;
    import org.eclipse.jetty.server.Connector;
    import org.eclipse.jetty.server.HttpConfiguration;
    import org.eclipse.jetty.server.HttpConnectionFactory;
    import org.eclipse.jetty.server.SecureRequestCustomizer;
    import org.eclipse.jetty.server.Server;
    import org.eclipse.jetty.server.ServerConnector;
    import org.eclipse.jetty.server.SslConnectionFactory;
    import org.eclipse.jetty.util.ssl.SslContextFactory;

    /**
     * A Jetty server with multiple connectors.
     */
    public class ManyConnectors
    {
        public static void main( String[] args ) throws Exception
        {
            // Since this example shows off SSL configuration, we need a keystore
            // with the appropriate key. These lookup of jetty.home is purely a hack
            // to get access to a keystore that we use in many unit tests and should
            // probably be a direct path to your own keystore.

            String jettyDistKeystore = "../../jetty-distribution/target/distribution/demo-base/etc/keystore";
            String keystorePath = System.getProperty("example.keystore", jettyDistKeystore);
            File keystoreFile = new File(keystorePath);
            if (!keystoreFile.exists())
            {
                keystorePath = "jetty-distribution/target/distribution/demo-base/etc/keystore";
                keystoreFile = new File(keystorePath);
                if (!keystoreFile.exists())
                    throw new FileNotFoundException(keystoreFile.getAbsolutePath());
            }

            // Create a basic jetty server object without declaring the port. Since
            // we are configuring connectors directly we'll be setting ports on
            // those connectors.
            Server server = new Server();

            // HTTP Configuration
            // HttpConfiguration is a collection of configuration information
            // appropriate for http and https. The default scheme for http is
            // <code>http</code> of course, as the default for secured http is
            // <code>https</code> but we show setting the scheme to show it can be
            // done. The port for secured communication is also set here.
            HttpConfiguration http_config = new HttpConfiguration();
            http_config.setSecureScheme("https");
            http_config.setSecurePort(8443);
            http_config.setOutputBufferSize(32768);

            // HTTP connector
            // The first server connector we create is the one for http, passing in
            // the http configuration we configured above so it can get things like
            // the output buffer size, etc. We also set the port (8080) and
            // configure an idle timeout.
            ServerConnector http = new ServerConnector(server,
                    new HttpConnectionFactory(http_config));
            http.setPort(8080);
            http.setIdleTimeout(30000);

            // SSL Context Factory for HTTPS
            // SSL requires a certificate so we configure a factory for ssl contents
            // with information pointing to what keystore the ssl connection needs
            // to know about. Much more configuration is available the ssl context,
            // including things like choosing the particular certificate out of a
            // keystore to be used.

            SslContextFactory sslContextFactory = new SslContextFactory();
            sslContextFactory.setKeyStorePath(keystoreFile.getAbsolutePath());
            sslContextFactory.setKeyStorePassword("OBF:1vny1zlo1x8e1vnw1vn61x8g1zlu1vn4");
            sslContextFactory.setKeyManagerPassword("OBF:1u2u1wml1z7s1z7a1wnl1u2g");

            // OPTIONAL: Un-comment the following to use Conscrypt for SSL instead of
            // the native JSSE implementation.

            //Security.addProvider(new OpenSSLProvider());
            //sslContextFactory.setProvider("Conscrypt");

            // HTTPS Configuration
            // A new HttpConfiguration object is needed for the next connector and
            // you can pass the old one as an argument to effectively clone the
            // contents. On this HttpConfiguration object we add a
            // SecureRequestCustomizer which is how a new connector is able to
            // resolve the https connection before handing control over to the Jetty
            // Server.
            HttpConfiguration https_config = new HttpConfiguration(http_config);
            SecureRequestCustomizer src = new SecureRequestCustomizer();
            src.setStsMaxAge(2000);
            src.setStsIncludeSubDomains(true);
            https_config.addCustomizer(src);

            // HTTPS connector
            // We create a second ServerConnector, passing in the http configuration
            // we just made along with the previously created ssl context factory.
            // Next we set the port and a longer idle timeout.
            ServerConnector https = new ServerConnector(server,
                new SslConnectionFactory(sslContextFactory,HttpVersion.HTTP_1_1.asString()),
                    new HttpConnectionFactory(https_config));
            https.setPort(8443);
            https.setIdleTimeout(500000);

            // Here you see the server having multiple connectors registered with
            // it, now requests can flow into the server from both http and https
            // urls to their respective ports and be processed accordingly by jetty.
            // A simple handler is also registered with the server so the example
            // has something to pass requests off to.

            // Set the connectors
            server.setConnectors(new Connector[] { http, https });

            // Set a handler
            server.setHandler(new HelloHandler());

            // Start the server
            server.start();

            server.join();
        }
    }

#### Walkthrough

Start things up! By using the `server.join()` the server thread will join with the current thread. See `Thread.join()` for more details.

#### Maven Coordinates

To use this example in your project you will need the following Maven dependencies declared.

    <dependency>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-server</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-security</artifactId>
      <version>${project.version}</version>
    </dependency>

### Secured Hello Handler

This example shows how to wrap one handler with another one that handles security. We have a simple Hello Handler that just return a greeting but add on the restriction that to get this greeting you must authenticate. Another thing to remember is that this example uses the `ConstraintSecurityHandler` which is what supports the security mappings inside of the servlet api, it could be easier to show just the `SecurityHandler` usage, but the constraint provides more configuration power. If you don’t need that you can drop the Constraint bits and use just the `SecurityHandler`.

    //
    //  ========================================================================
    //  Copyright (c) 1995-2018 Mort Bay Consulting Pty. Ltd.
    //  ------------------------------------------------------------------------
    //  All rights reserved. This program and the accompanying materials
    //  are made available under the terms of the Eclipse Public License v1.0
    //  and Apache License v2.0 which accompanies this distribution.
    //
    //      The Eclipse Public License is available at
    //      http://www.eclipse.org/legal/epl-v10.html
    //
    //      The Apache License v2.0 is available at
    //      http://www.opensource.org/licenses/apache2.0.php
    //
    //  You may elect to redistribute this code under either of these licenses.
    //  ========================================================================
    //

    package org.eclipse.jetty.embedded;

    import java.util.Collections;

    import org.eclipse.jetty.security.ConstraintMapping;
    import org.eclipse.jetty.security.ConstraintSecurityHandler;
    import org.eclipse.jetty.security.HashLoginService;
    import org.eclipse.jetty.security.LoginService;
    import org.eclipse.jetty.security.authentication.BasicAuthenticator;
    import org.eclipse.jetty.server.Server;
    import org.eclipse.jetty.util.security.Constraint;

    public class SecuredHelloHandler
    {
        public static void main( String[] args ) throws Exception
        {
            // Create a basic jetty server object that will listen on port 8080.
            // Note that if you set this to port 0 then a randomly available port
            // will be assigned that you can either look in the logs for the port,
            // or programmatically obtain it for use in test cases.
            Server server = new Server(8080);

            // Since this example is for our test webapp, we need to setup a
            // LoginService so this shows how to create a very simple hashmap based
            // one. The name of the LoginService needs to correspond to what is
            // configured a webapp's web.xml and since it has a lifecycle of its own
            // we register it as a bean with the Jetty server object so it can be
            // started and stopped according to the lifecycle of the server itself.
            // In this example the name can be whatever you like since we are not
            // dealing with webapp realms.
            LoginService loginService = new HashLoginService("MyRealm",
                    "src/test/resources/realm.properties");
            server.addBean(loginService);

            // A security handler is a jetty handler that secures content behind a
            // particular portion of a url space. The ConstraintSecurityHandler is a
            // more specialized handler that allows matching of urls to different
            // constraints. The server sets this as the first handler in the chain,
            // effectively applying these constraints to all subsequent handlers in
            // the chain.
            ConstraintSecurityHandler security = new ConstraintSecurityHandler();
            server.setHandler(security);

            // This constraint requires authentication and in addition that an
            // authenticated user be a member of a given set of roles for
            // authorization purposes.
            Constraint constraint = new Constraint();
            constraint.setName("auth");
            constraint.setAuthenticate(true);
            constraint.setRoles(new String[] { "user", "admin" });

            // Binds a url pattern with the previously created constraint. The roles
            // for this constraing mapping are mined from the Constraint itself
            // although methods exist to declare and bind roles separately as well.
            ConstraintMapping mapping = new ConstraintMapping();
            mapping.setPathSpec("/*");
            mapping.setConstraint(constraint);

            // First you see the constraint mapping being applied to the handler as
            // a singleton list, however you can passing in as many security
            // constraint mappings as you like so long as they follow the mapping
            // requirements of the servlet api. Next we set a BasicAuthenticator
            // instance which is the object that actually checks the credentials
            // followed by the LoginService which is the store of known users, etc.
            security.setConstraintMappings(Collections.singletonList(mapping));
            security.setAuthenticator(new BasicAuthenticator());
            security.setLoginService(loginService);

            // The Hello Handler is the handler we are securing so we create one,
            // and then set it as the handler on the
            // security handler to complain the simple handler chain.
            HelloHandler hh = new HelloHandler();

            // chain the hello handler into the security handler
            security.setHandler(hh);

            // Start things up!
            server.start();

            // The use of server.join() the will make the current thread join and
            // wait until the server is done executing.
            // See
            // http://docs.oracle.com/javase/7/docs/api/java/lang/Thread.html#join()
            server.join();
        }
    }

#### Run it!

After you have started things up you should be able to navigate to http://localhost:8080/index.html (assuming one is in the resource base directory) and you are good to go.

#### The Realm Properties File

    #
    # This file defines users passwords and roles for a HashUserRealm
    #
    # The format is
    #  <username>: <password>[,<rolename> ...]
    #
    # Passwords may be clear text, obfuscated or checksummed.  The class
    # org.eclipse.jetty.util.security.Password should be used to generate obfuscated
    # passwords or password checksums
    #
    # If DIGEST Authentication is used, the password must be in a recoverable
    # format, either plain text or OBF:.
    #
    jetty: MD5:164c88b302622e17050af52c89945d44,user
    admin: CRYPT:adpexzg3FUZAk,server-administrator,content-administrator,admin,user
    other: OBF:1xmk1w261u9r1w1c1xmq,user
    plain: plain,user
    user: password,user

    # This entry is for digest auth.  The credential is a MD5 hash of username:realmname:password
    digest: MD5:6e120743ad67abfbc385bc2bb754e297,user

#### Maven Coordinates

To use this example in your project you will need the following Maven dependencies declared.

    <dependency>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-server</artifactId>
      <version>${project.version}</version>
    </dependency>

### Minimal Servlet

This example shows the bare minimum required for deploying a servlet into Jetty. Note that this is strictly a servlet, not a servlet in the context of a web application, that example comes later. This is purely just a servlet deployed and mounted on a context and able to process requests. This example is excellent for situations where you have a simple servlet that you need to unit test, just mount it on a context and issue requests using your favorite http client library (like our Jetty client found in Chapter 22, HTTP Client).

    //
    //  ========================================================================
    //  Copyright (c) 1995-2018 Mort Bay Consulting Pty. Ltd.
    //  ------------------------------------------------------------------------
    //  All rights reserved. This program and the accompanying materials
    //  are made available under the terms of the Eclipse Public License v1.0
    //  and Apache License v2.0 which accompanies this distribution.
    //
    //      The Eclipse Public License is available at
    //      http://www.eclipse.org/legal/epl-v10.html
    //
    //      The Apache License v2.0 is available at
    //      http://www.opensource.org/licenses/apache2.0.php
    //
    //  You may elect to redistribute this code under either of these licenses.
    //  ========================================================================
    //

    package org.eclipse.jetty.embedded;

    import java.io.IOException;

    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;

    import org.eclipse.jetty.server.Server;
    import org.eclipse.jetty.servlet.ServletHandler;

    public class MinimalServlets
    {
        public static void main( String[] args ) throws Exception
        {
            // Create a basic jetty server object that will listen on port 8080.
            // Note that if you set this to port 0 then a randomly available port
            // will be assigned that you can either look in the logs for the port,
            // or programmatically obtain it for use in test cases.
            Server server = new Server(8080);

            // The ServletHandler is a dead simple way to create a context handler
            // that is backed by an instance of a Servlet.
            // This handler then needs to be registered with the Server object.
            ServletHandler handler = new ServletHandler();
            server.setHandler(handler);

            // Passing in the class for the Servlet allows jetty to instantiate an
            // instance of that Servlet and mount it on a given context path.

            // IMPORTANT:
            // This is a raw Servlet, not a Servlet that has been configured
            // through a web.xml @WebServlet annotation, or anything similar.
            handler.addServletWithMapping(HelloServlet.class, "/*");

            // Start things up!
            server.start();

            // The use of server.join() the will make the current thread join and
            // wait until the server is done executing.
            // See
            // http://docs.oracle.com/javase/7/docs/api/java/lang/Thread.html#join()
            server.join();
        }

        @SuppressWarnings("serial")
        public static class HelloServlet extends HttpServlet
        {
            @Override
            protected void doGet( HttpServletRequest request,
                                  HttpServletResponse response ) throws ServletException,
                                                                IOException
            {
                response.setContentType("text/html");
                response.setStatus(HttpServletResponse.SC_OK);
                response.getWriter().println("<h1>Hello from HelloServlet</h1>");
            }
        }
    }

#### Walkthrough

Start things up! By using the `server.join()` the server thread will join with the current thread. See `Thread.join()` for more details.

It is really simple to create useful servlets for testing behaviors. Sometimes you need a http server to run a unit test against that will return test content and wiring up a servlet like this makes it trivial.

After you have started things up you should be able to navigate to http://localhost:8080/ and you are good to go.

#### Maven Coordinates

To use this example in your project you will need the following Maven dependencies declared.

    <dependency>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-servlet</artifactId>
      <version>${project.version}</version>
    </dependency>

### Web Application

This example shows how to deploy a simple webapp with an embedded instance of Jetty. This is useful when you want to manage the lifecycle of a server programmatically, either within a production application or as a simple way to deploying and debugging a full scale application deployment. In many ways it is easier then traditional deployment since you control the classpath yourself, making this easy to wire up in a test case in Maven and issue requests using your favorite http client library (like our Jetty client found in Chapter 22, HTTP Client).

    //
    //  ========================================================================
    //  Copyright (c) 1995-2018 Mort Bay Consulting Pty. Ltd.
    //  ------------------------------------------------------------------------
    //  All rights reserved. This program and the accompanying materials
    //  are made available under the terms of the Eclipse Public License v1.0
    //  and Apache License v2.0 which accompanies this distribution.
    //
    //      The Eclipse Public License is available at
    //      http://www.eclipse.org/legal/epl-v10.html
    //
    //      The Apache License v2.0 is available at
    //      http://www.opensource.org/licenses/apache2.0.php
    //
    //  You may elect to redistribute this code under either of these licenses.
    //  ========================================================================
    //

    package org.eclipse.jetty.embedded;

    import java.io.File;
    import java.lang.management.ManagementFactory;

    import org.eclipse.jetty.jmx.MBeanContainer;
    import org.eclipse.jetty.server.Server;
    import org.eclipse.jetty.server.handler.AllowSymLinkAliasChecker;
    import org.eclipse.jetty.webapp.WebAppContext;

    public class OneWebApp
    {
        public static void main( String[] args ) throws Exception
        {
            // Create a basic jetty server object that will listen on port 8080.
            // Note that if you set this to port 0 then a randomly available port
            // will be assigned that you can either look in the logs for the port,
            // or programmatically obtain it for use in test cases.
            Server server = new Server(8080);

            // Setup JMX
            MBeanContainer mbContainer = new MBeanContainer(
                    ManagementFactory.getPlatformMBeanServer());
            server.addBean(mbContainer);

            // The WebAppContext is the entity that controls the environment in
            // which a web application lives and breathes. In this example the
            // context path is being set to "/" so it is suitable for serving root
            // context requests and then we see it setting the location of the war.
            // A whole host of other configurations are available, ranging from
            // configuring to support annotation scanning in the webapp (through
            // PlusConfiguration) to choosing where the webapp will unpack itself.
            WebAppContext webapp = new WebAppContext();
            webapp.setContextPath("/");
            File warFile = new File(
                    "../../tests/test-jmx/jmx-webapp/target/jmx-webapp");
            webapp.setWar(warFile.getAbsolutePath());

            // A WebAppContext is a ContextHandler as well so it needs to be set to
            // the server so it is aware of where to send the appropriate requests.
            server.setHandler(webapp);

            // Start things up!
            server.start();

            server.dumpStdErr();

            // The use of server.join() the will make the current thread join and
            // wait until the server is done executing.
            // See http://docs.oracle.com/javase/7/docs/api/java/lang/Thread.html#join()
            server.join();
        }
    }

#### Run it!

After you have started things up you should be able to navigate to http://localhost:8080/ and you are good to go.

#### Maven Coordinates

To use this example in your project you will need the following Maven dependencies declared.

    <dependency>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-webapp</artifactId>
      <version>${project.version}</version>
    </dependency>

### Web Application with JSP

This example is very similar to the one in the previous section, although it enables the embedded webapp to use JSPs. As of jetty-9.2, we use the JSP engine from Apache, which relies on a Servlet Specification 3.1 style `ServletContainerInitializer` to initialize itself. To get this to work with Jetty, you need to enable annotations processing, as shown in this example code:

    //
    //  ========================================================================
    //  Copyright (c) 1995-2018 Mort Bay Consulting Pty. Ltd.
    //  ------------------------------------------------------------------------
    //  All rights reserved. This program and the accompanying materials
    //  are made available under the terms of the Eclipse Public License v1.0
    //  and Apache License v2.0 which accompanies this distribution.
    //
    //      The Eclipse Public License is available at
    //      http://www.eclipse.org/legal/epl-v10.html
    //
    //      The Apache License v2.0 is available at
    //      http://www.opensource.org/licenses/apache2.0.php
    //
    //  You may elect to redistribute this code under either of these licenses.
    //  ========================================================================
    //

    package org.eclipse.jetty.embedded;

    import java.io.File;
    import java.lang.management.ManagementFactory;

    import org.eclipse.jetty.jmx.MBeanContainer;
    import org.eclipse.jetty.security.HashLoginService;
    import org.eclipse.jetty.server.Server;
    import org.eclipse.jetty.webapp.Configuration;
    import org.eclipse.jetty.webapp.WebAppContext;

    public class OneWebAppWithJsp
    {
        public static void main( String[] args ) throws Exception
        {
            // Create a basic jetty server object that will listen on port 8080.
            // Note that if you set this to port 0 then
            // a randomly available port will be assigned that you can either look
            // in the logs for the port,
            // or programmatically obtain it for use in test cases.
            Server server = new Server( 8080 );

            // Setup JMX
            MBeanContainer mbContainer = new MBeanContainer(
                    ManagementFactory.getPlatformMBeanServer() );
            server.addBean( mbContainer );

            // The WebAppContext is the entity that controls the environment in
            // which a web application lives and
            // breathes. In this example the context path is being set to "/" so it
            // is suitable for serving root context
            // requests and then we see it setting the location of the war. A whole
            // host of other configurations are
            // available, ranging from configuring to support annotation scanning in
            // the webapp (through
            // PlusConfiguration) to choosing where the webapp will unpack itself.
            WebAppContext webapp = new WebAppContext();
            webapp.setContextPath( "/" );
            File warFile = new File(
                    "../../jetty-distribution/target/distribution/demo-base/webapps/test.war" );
            if (!warFile.exists())
            {
                throw new RuntimeException( "Unable to find WAR File: "
                        + warFile.getAbsolutePath() );
            }
            webapp.setWar( warFile.getAbsolutePath() );
            webapp.setExtractWAR(true);

            // This webapp will use jsps and jstl. We need to enable the
            // AnnotationConfiguration in order to correctly
            // set up the jsp container
            Configuration.ClassList classlist = Configuration.ClassList
                    .setServerDefault( server );
            classlist.addBefore(
                    "org.eclipse.jetty.webapp.JettyWebXmlConfiguration",
                    "org.eclipse.jetty.annotations.AnnotationConfiguration" );

            // Set the ContainerIncludeJarPattern so that jetty examines these
            // container-path jars for tlds, web-fragments etc.
            // If you omit the jar that contains the jstl .tlds, the jsp engine will
            // scan for them instead.
            webapp.setAttribute(
                    "org.eclipse.jetty.server.webapp.ContainerIncludeJarPattern",
                    ".*/[^/]*servlet-api-[^/]*\\.jar$|.*/javax.servlet.jsp.jstl-.*\\.jar$|.*/[^/]*taglibs.*\\.jar$" );

            // A WebAppContext is a ContextHandler as well so it needs to be set to
            // the server so it is aware of where to
            // send the appropriate requests.
            server.setHandler( webapp );

            // Configure a LoginService.
            // Since this example is for our test webapp, we need to setup a
            // LoginService so this shows how to create a very simple hashmap based
            // one. The name of the LoginService needs to correspond to what is
            // configured in the webapp's web.xml and since it has a lifecycle of
            // its own we register it as a bean with the Jetty server object so it
            // can be started and stopped according to the lifecycle of the server
            // itself.
            HashLoginService loginService = new HashLoginService();
            loginService.setName( "Test Realm" );
            loginService.setConfig( "src/test/resources/realm.properties" );
            server.addBean( loginService );

            // Start things up!
            server.start();

            server.dumpStdErr();

            // The use of server.join() the will make the current thread join and
            // wait until the server is done executing.
            // See http://docs.oracle.com/javase/7/docs/api/java/lang/Thread.html#join()
            server.join();
        }
    }

#### Run it!

After you have started things up you should be able to navigate to http://localhost:8080/jsp/ and click on any of the links to jsps.

#### Maven Coordinates

To use this example in your project, you will need the following Maven dependencies declared, in addition to those from the previous section:

    <dependency>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-annotations</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>apache-jsp</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>apache-jstl</artifactId>
      <version>${project.version}</version>
    </dependency>

### Adding Examples

If you would like to add an example to this list, fork the documentation project from github (see the blue bar at the bottom of this page) and add the new page. Feel free to add the example contents directly as a `[source.java]` and we will take it from there.

If you feel and example is missing, feel free to open a bug to ask for it. No guarantees, but the more helpful and demonstrative it is the better.

Previous | Top | Next
Embedding Jetty | Home | Chapter 22. HTTP Client

See an error or something missing? Contribute to this documentation at Github!(Generated: 2018-08-30)