Containerless Spring MVC

By James Ward | Published: August 13, 2012

Many of the new JVM-based web frameworks are ditching containers and WAR files and instead using a WAR-less / Containerless approach. But that doesn’t mean you have to ditch your favorite Java web framework. A while back I posted about going containerless with Tapestry. Now lets do the same with Spring MVC. You can grab the full source code from GitHub.

First we need a build that defines the dependencies. Here is the build.gradle file for my Gradle build:

apply plugin:'java'
apply plugin:'application'
 
version = '0.0.1-SNAPSHOT'
 
mainClassName = "com.jamesward.Webapp"
applicationName = "webapp"
 
repositories {
    mavenCentral()
}
 
dependencies {
    compile 'org.springframework:spring-webmvc:3.1.2.RELEASE'
    compile 'cglib:cglib:2.2.2'
    compile 'org.eclipse.jetty:jetty-webapp:8.1.5.v20120716'
}

There isn’t much to this build except a few dependencies: Spring MVC, CGLib, and Jetty.

The src/main/resources/assets/index.html file just contains simple HTML:

<!doctype html>
<html>
<body>
hello, world
</body>
</html>

The src/main/java/com/jamesward/WebConfig.java file uses Spring annotations to configure Spring MVC:

package com.jamesward;
 
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.*;
 
@Configuration
@EnableWebMvc
public class WebConfig extends WebMvcConfigurerAdapter {
 
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/**").addResourceLocations("classpath:/assets/");
    }
 
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("redirect:index.html");
    }
 
}

Finally, a simple “static void main” Java class is used to start Jetty. The src/main/java/com/jamesward/Webapp.java file just sets up the HTTP listener and starts it:

package com.jamesward;
 
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
 
 
public class Webapp {
 
    public static void main(String[] args) throws Exception {
 
        final AnnotationConfigWebApplicationContext applicationContext = new AnnotationConfigWebApplicationContext();
        applicationContext.register(WebConfig.class);
 
        final ServletHolder servletHolder = new ServletHolder(new DispatcherServlet(applicationContext));
        final ServletContextHandler context = new ServletContextHandler();
        context.setContextPath("/");
        context.addServlet(servletHolder, "/*");
 
        String webPort = System.getenv("PORT");
        if (webPort == null || webPort.isEmpty()) {
            webPort = "8080";
        }
 
        final Server server = new Server(Integer.valueOf(webPort));
 
        server.setHandler(context);
 
        server.start();
        server.join();
    }
 
}

That’s it! To build and run this project locally you can simple run:

./gradlew run

(Note: Run “gradlew.bat” on Windows.)

So simple it’s hard to believe it works. :) Let me know if you have any questions.

This entry was posted in Spring. Bookmark the permalink. Post a comment or leave a trackback: Trackback URL.
  • http://www.discursive.com Tim O’Brien

    Look at you, Mr. here’s my sinatra equivalent for Java. That’s pretty fancy.

    • http://twitter.com/mikkelbd Mikkel Dan-Rognlie

      Nice and simple. You can get even closer to Sinatra for Java with http://www.sparkjava.com

  • http://twitter.com/sourcedelica Eric Pederson

    WAR-less, yes, but isn’t Jetty a container?

    • http://www.jamesward.com James Ward

      I guess it depends on how you define “container”. I usually think of a container as something you deploy into. In this case Jetty is part of the application, not an external thing.

  • ugo

    we can do that with Netty for example ?

    • http://www.jamesward.com James Ward

      I haven’t tried doing this with Netty because Spring MVC uses the Servlet API which doesn’t work well with NIO.

  • nhwind

    Awesome! Thanks. Would love to see a development set up in Eclipse using jrebel or alike..

  • arhan

    This is not really “containerless”, isn’t it? :) That’s just an embedded Jetty, which is still a container

    • http://www.jamesward.com James Ward

      It depends on how you define “containerless”. See the comment below. How would you define “containerless”?

      • arhan

        “Containerless”, in this context, I’d define as the “one that doesn’t implement JEE spec, i.e. not a servlet container. For instance, a netty/mina/vert.x based implementation would qualify as “containerless”

        • http://www.jamesward.com James Ward

          I definitely agree that Play, Vert.x, etc are containerless. But I wouldn’t say that if an app uses the Servlet API that it can’t be containerless. This example may not be 100% containerless, but it’s probably as close as you can get with the Servlet API.

          • arhan

            OK! I agree :)

  • Ian Durkan

    A nice demo, but interestingly enough this did not build on my system without further tweaking due to an issue in Gradle that prevents a dependency org.eclipse.jetty.orbit from downloading. See here for more information about a work-around. http://issues.gradle.org/browse/GRADLE-2076

    • http://www.jamesward.com James Ward

      That is odd. I wonder why it worked for me. Are you using Gradle 1.1 or the gradlew from my source?

      • Ian Durkan

        As it turns out, I still had Gradle 1.0 on the VM where I was trying to build. Oops!

        • http://www.jamesward.com James Ward

          Cool. Glad it was something simple. :)

  • Pingback: Breaking Free From Containers | Dynacron Group

  • Jason

    I’ve been deploying spring mvc like this for a while now. But JSPs are always a problem, and they are somewhat core to spring mvc.

  • Pingback: SpringMVC with Embedded Jetty | jasonish

  • Pingback: SpringMVC with Embedded Jetty « jasonish