Skip to content

April 7, 2010

22

OSGi & Servlets: A Happy Marriage

A marriage made in heaven

In this post, I'll show you how to create a simple OSGI-based servlet. Later, we will deploy this servlet to an Amazon EC 2 instance - this should be fun!

Update: I updated the code sample to use Declarative Services, as suggested by Jeff and Scott in the comments of this post. After reading this article, please refer to this other post to learn about the changes.

First of all, some preliminary steps. We need to create a new OSGi project and add some dependencies:

  1. Create a new plug-in project, naming it simple.servlet. Make sure to select Equinox as the target OSGI framework on the first page of the wizard. Also make sure you've got an activator (that option is on by default).
  2. Open the manifest editor and add the following packages to the Imported Packages section on the Dependencies tab:
    • javax.servlet
    • javax.servlet.http
    • org.osgi.framework
    • org.osgi.service.http
    • org.osgi.util.tracker

Next, let's create the servlet. Servlets are plain Java classes that implement the javax.servlet.Servlet interface. As we want to serve information over HTTP, we can just create a subclass of javax.servlet.http.HttpServlet which already does some of the heavy lifting for us. All we need to do is override the doGet() method. This method does not have a return value. Instead, we need to fill its second parameter, HttpServletResponse resp with the text we want the web browser to display. We could return HTML, but for simplicity's sake, let's just return plain text (so make sure to set the content type to text/plain):

package simple.servlet;
import java.io.IOException;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
public class SimpleServlet extends HttpServlet {
  private static final long serialVersionUID = 1L;
 
  protected void doGet(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException {
    resp.setContentType("text/plain");
    resp.getWriter().write("Hello from the cloud!");
  }
}

In order for the servlet to be accessible via HTTP, we need to register it. If you have done some JEE/J2EE development, you know that servlets are registered using the web.xml servlet descriptor. As we're not in the JEE world any longer, we can't go down this road. Instead, we will register the servlet using a org.osgi.util.tracker.ServiceTracker. It's a little bit more code to write, but let me tell you: it's worth it as you'll see very soon.

The service tracker will be registered for a specific class - in our case that's org.osgi.service.http.HttpService: 

package simple.servlet;
 
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
import org.osgi.service.http.HttpService;
import org.osgi.util.tracker.ServiceTracker;
 
public class HttpServiceTracker extends ServiceTracker {
 
  public HttpServiceTracker(BundleContext context) {
    super(context, HttpService.class.getName(), null);
  }
  // ...

When the service tracker is asked to return the HttpService, we can register our servlet:

  // ...
  public Object addingService(ServiceReference reference) {
    HttpService httpService = (HttpService) super.addingService(reference);
    if (httpService == null)
      return null;
 
    try {
      System.out.println("Registering servlet at /simple");
      httpService.registerServlet("/simple", new SimpleServlet(), null, null);
    } catch (Exception e) {
      e.printStackTrace();
    }
 
    return httpService;
  }
  /...

Likewise, we must make sure to unregister the servlet when the service tracker is asked to shut down the HttpService

  // ..
  public void removedService(ServiceReference reference, Object service) {
    HttpService httpService = (HttpService) service;
 
    System.out.println("Unregistering /simple");
    httpService.unregister("/simple");
 
    super.removedService(reference, service);
  }
 
}

Now that we've got the servlet in place, we need to make sure the service tracker is started and stopped when our bundle is started and stopped. Those of you familiar with OSGi know where we're heading now: we need to implement the start() and stop() methods of our activator:

package simple.servlet;
 
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
 
public class Activator implements BundleActivator {
 
  private HttpServiceTracker serviceTracker;
 
  public void start(BundleContext context) throws Exception {
    serviceTracker = new HttpServiceTracker(context);
    serviceTracker.open();
  }
 
  public void stop(BundleContext context) throws Exception {
    serviceTracker.close();
    serviceTracker = null;
  }
 
}

To test your servlet locally, create a new launch config:

  1. In the main menu, select Run -> Run Configurations...
  2. Double click on OSGi Framework in the tree on the left hand side to create a new OSGi-based launch config

    3. and name it Simple Servlet (OSGi)

  3. Make sure you select the following eight (8) bundles on the Bundles tab:
    1. simple.servlet
    2. javax.servlet
    3. org.eclipse.equinox.http.jetty
    4. org.eclipse.equinox.http.servlet
    5. org.eclispe.osgi
    6. org.eclispe.osgi.services
    7. org.mortbay.jetty.server
    8. org.mortbay.jetty.util
  4. Head over to the Arguments tab, making sure the VM arguments text box reads -Declipse.ignoreApp=true -Dosgi.noShutdown=true -Dorg.osgi.service.http.port=8080

You can now start the server by executing the launch config. After a very short time, the text Registering servlet at /simple should appear in the console window, indicating your OSGi-based server and your servlet have been started up (a lot faster that it would have taken on Tomcat or any other JEE server, for that matter).

Open your web browser at http://localhost:8080/simple to observe your servlet in action:

OSGi SimpleServlet, local deployment

Congratulations, you've just built your first OSGi-enabled servlet. In the next post, I'll show you how to deploy this servlet in an Amazon EC2 instance. You can download the source code for this post from my SVN repository on Google code.

Thanks for reading this post. Follow me on twitter here to be notified about updates and other posts I write. Or, subscribe to my RSS feed here

Read more from Eclipse, OSGi
, , , ,

11 Tweets

22 Comments Post a comment
  1. Jeff McAffer
    Apr 7 2010

    Hey Peter, I highly recommend the use of Declarative Services here. That would eliminate ALL of the service tracker code and the vast majority of the OSGi related code (just leaving the HTTP service register and unregister calls). Interested folks might want to look at Chapter 18 in the OSGi and Equinox book (http://equinoxosgi.org) or at the various servlets in the Toast example (http://wiki.eclipse.org/Toast).

    Reply   More from author
  2. Thomas
    Apr 7 2010

    Hi Peter !

    thank you for this insight. I m not too deep into http and jetty inside of equinox. can you give me a point how to deploy a web app (with a web.xml, I have spring http exporters in it) on osgi ?

    So long and hoping for the next stammtisch ! Was a nice evening.

    Reply   More from author
    • Peter
      Apr 8 2010

      Thomas,
      I am not planing on going down the web.xml road any more as long as I can prevent it. The JEE world is dead to me. However, the book Jeff mentioned does contain material on how to embed OSGi apps in traditional web apps and have them deployed to a JEE web server. For your convenience, here a link to the book on Amazon: http://bit.ly/bMa0xa

      Reply   More from author
  3. Scott Lewis
    Apr 7 2010

    Hi Peter,

    Nice post. One thought: Instead of service tracker you might consider using declarative services…e.g. to inject HttpService into your component (and make the servlet registration even easier). The source code in my amazon cloud image does this, incidently…i.e. one here http://ec2-75-101-228-69.compute-1.amazonaws.com:8080/hello

    Actually, if you are game perhaps we can jointly propose and contribute some examples for the eclipsert project. I would be happy to contribute the example that’s out there as well as others.

    Also…I hope that you will be able to use the Amazon image in your next post…along with feature-based export and p2 install. I think that would/will make a great follow up post. I’ve been intending to do that myself (since originally making the AMI available) but haven’t been able to do so. If you want/need any assistance in that please just let me know.

    Reply
    • Peter
      Apr 8 2010

      Hi Scott,
      I’m definitely planing on using your AMI for my next post – really glad you made it available! Will get back to you regarding this topic by mail.
      I’m open for contributing examples to Eclipse RT, let’s discuss this by mail.

      Reply   More from author
  4. Lars Vogel
    Apr 8 2010

    Excellent post. Thank you Peter.

    Reply   More from author
  5. Derrick
    Apr 9 2010

    Wow, very cool! I’ve actually done something similar, although I used the Spring framework.

    Reply   More from author
  6. Luis Carlos Moreira da Costa
    Apr 16 2010

    Excellent tutorial Peter!

    Reply

Trackbacks & Pingbacks

  1. OSGi & Servlets: Deploying on Amazon EC2 - Peter Friese
  2. OSGi & Servlets: Flexibility by Simplicity - Peter Friese

Share your thoughts, post a comment.

(required)
(required)

Note: HTML is allowed. Your email address will never be published.

Subscribe to comments

Additional comments powered by BackType