- Assemble framework libraries using Maven.
- Create a POJO interface and an implementation.
- Write a JAX-RS resoure to use Guice constructor injection and JAX-RS annotations.
- Write the Guice bootstrap code.
- Write the embedded Jetty start up code.
- Run and test.
7.4.1.v20110513 1.7 3.0 org.eclipse.jetty jetty-servlet ${jetty.version} com.google.inject guice ${guice.verion} com.sun.jersey jersey-server ${jersey.version} com.sun.jersey.contribs jersey-guice ${jersey.version} junit junit ${junit.version} test maven2-repository.java.net Java.net Repository for Maven http://download.java.net/maven/2/ default
We start with a simple POJO interface:
public interface GuicyInterface {
String get();
}
And a simple implementation:
public class GuicyInterfaceImpl implements GuicyInterface {
public String get() {
return GuicyInterfaceImpl.class.getName();
}
}
Now, write a JAX-RS resource to use both Guice and JAX-RS annotated injections:
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import com.google.inject.Inject;@Path("/helloguice")
public class HelloGuice {
private final GuicyInterface gi;
@Inject
public HelloGuice(final GuicyInterface gi) {
this.gi = gi;
}
@GET
@Produces("text/plain")
public String get(@QueryParam("x") String x) {
return "Howdy Guice. " + "Injected impl " + gi.toString() + ". Injected query parameter "+ (x != null ? "x = " + x : "x is not injected");
}
}
Next, compose POJO bindins in a JerseyServletModule. This module will setup the Jersey-based JAX-RS framework for use with Guide injection. The GuiceServletContextListener is used to bootstrap Guice when the servet context is initialized.
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.servlet.GuiceServletContextListener;
import com.sun.jersey.guice.JerseyServletModule;
import com.sun.jersey.guice.spi.container.servlet.GuiceContainer;
public class HelloGuiceServletConfig extends GuiceServletContextListener {
@Override
protected Injector getInjector() {
return Guice.createInjector(new JerseyServletModule() {
@Override
protected void configureServlets() {
// Must configure at least one JAX-RS resource or the
// server will fail to start.
bind(HelloGuice.class);
bind(GuicyInterface.class).to(GuicyInterfaceImpl.class);
// Route all requests through GuiceContainer
serve("/*").with(GuiceContainer.class);
}
});
}
}
Finally, write the main method using embedded Jersey to start Guice and Jersey together.
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.servlet.DefaultServlet;
import org.eclipse.jetty.servlet.ServletContextHandler;
import com.google.inject.servlet.GuiceFilter;
public class GuiceLauncher {
public static void main(String[] args) throws Exception {
// Create the server.
Server server = new Server(8080);
// Create a servlet context and add the jersey servlet.
ServletContextHandler sch = new ServletContextHandler(server, "/");
// Add our Guice listener that includes our bindings
sch.addEventListener(new HelloGuiceServletConfig());
// Then add GuiceFilter and configure the server to
// reroute all requests through this filter.
sch.addFilter(GuiceFilter.class, "/*", null);
// Must add DefaultServlet for embedded Jetty.
// Failing to do this will cause 404 errors.
// This is not needed if web.xml is used instead.
sch.addServlet(DefaultServlet.class, "/");
// Start the server
server.start();
server.join();
}
}
If you run the main program on your local host, you can test the servlet using this URL:
http://localhost:8080/helloguice?x=q
Then, you should see a response like this:
Howdy Guice. Injected impl GuicyInterfaceImpl@3aaa3518. Injected query parameter x = qCongratulations! You have now mastered the three most popular IoC frameworks for programming RESTful servlets!
