DailyJavaTips

Database Transactions With Google Guice AOP

2011-10-24T00:00:00+02:00

Today I’m going to show you a simple way of implementing transactional class methods with Google Guice Aspect Oriented Programming.

The endgame would be to annotate methods as transactional and automatically handle the JDBC transactions boilerplate code:

 @Transaction
  public void executeStatements(Connection conn, String[] statements) throws SQLException {
    /* run db queries here */
  }

Transaction Annotation

We need to declare a Transaction annotation class. Only methods can be annotated with Transaction and annotations can be intercepted at runtime.

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD)
public @interface Transaction {
}

Method Intercepter

We’re going to intercept methods annotated with Transaction. Executing SQL queries using JDBC requires either a DataSource or a Connection. In this example, I’m assuming that all transactional methods receive a Connection object as the first parameter.

import java.lang.reflect.Method;
import java.sql.Connection;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class TransactionIntercepter implements MethodInterceptor {
  @Override
  public Object invoke(MethodInvocation invocation) throws Throwable {
    Method method = invocation.getMethod();
    Transaction annotation = method.getAnnotation(Transaction.class);
    // Make sure the intercepter was called for a transaction method
    if (annotation == null) {
      return invocation.proceed();
    }
    if (invocation.getArguments().length == 0 ||
        !(invocation.getArguments()[0] instanceof Connection)) {
      throw new Exception("First parameter must be a Connection instance: " + method.getName());
      
    }
    Connection conn = (Connection)invocation.getArguments()[0];
   try {
     conn.setAutoCommit(false);
     // Proceed with the original method's invocation.
     Object returnObj = invocation.proceed();
     // Commit if successful.
     conn.commit();
     conn.setAutoCommit(true);
     return returnObj;
   } catch (Throwable ex) {
     // Rollback on error.
     conn.rollback();
     conn.setAutoCommit(true);
     throw ex;
   }
  }
}

Binding the Method Intercepter With Guice

We need to bind the MethodIntercepter in the Guice module. Here’s the code for a dedicated module that can be installed in other modules:

import com.google.inject.AbstractModule;
import com.google.inject.matcher.Matchers;
public class TransactionModule extends AbstractModule {
  @Override
  protected void configure() {
    TransactionIntercepter intercepter = new TransactionIntercepter();
    requestInjection(intercepter);
    bindInterceptor(Matchers.any(), Matchers.annotatedWith(Transaction.class), intercepter);
  }
}

Transactional Method Example

Now you can annotated methods that receive the Connection object as parameter:

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
public class Manager {
  @Transaction
  public void executeStatements(Connection conn, String[] statements) throws SQLException {
    if (statements == null || conn == null) {
      throw new IllegalArgumentException();
    }
    Statement stmt = conn.createStatement();
    for (int i = 0; i < statements.length; i++) {
      stmt.execute(statements[i]);
    }
  }
}

Some Demo Code

Let’s wrap the above code in a simple example using PostgreSQL:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

import com.google.inject.Guice;

public class Main {

  public static void main(String[] args) throws SQLException {
    System.out.println("Checking if Driver is registered with DriverManager.");
    
    try {
      Class.forName("org.postgresql.Driver");
    } catch (ClassNotFoundException cnfe) {
      System.out.println("Couldn't find the driver!");
      cnfe.printStackTrace();
      System.exit(1);
    }
    
    TransactionModule module = new TransactionModule();
    Connection conn = null;
    try {
      conn = DriverManager.getConnection("jdbc:postgresql://localhost/demo",
                                      "demo", "demo");
      // Get an instance from Guice, to intercept the methods annotated with @Transaction
      Manager manager = Guice.createInjector(module).getInstance(Manager.class);
      String[] stmts = {"CREATE TABLE a(a int);", 
          "CREATE TABLE b(b int);", 
          "INSERT INTO a(a) values(1);", 
          "INSERT INTO b(b) values(1)"
          };
      manager.executeStatements(conn, stmts);

      String[] stmts_bad = {"CREATE TABLE c(c int);", 
          "CREATE TABLE d(b int;", // a mistake in the SQL statement
          "INSERT INTO c(a) values(1);", 
          "INSERT INTO d(b) values(1)"
          };
      manager.executeStatements(conn, stmts_bad);
     } finally {
       if (conn != null && !conn.isClosed()) {
         conn.close();
       }
     }
  }
}

Conclusion

Guice is a lightweight library that makes it easy to deal with dependency injection but also implement aspect oriented programming paradigms. I’ve used and implemented database transactions programatically with Spring and I have to say that the pattern above is much more flexible and lightweight.

A Flexible J2EE Setup - Case Study on Jira, Confluence and Crowd

2011-10-23T00:00:00+02:00

In a previous post I showed you how to setup an Apache front-end to proxy to J2EE servers listening on localhost safe ports.

In this post I’m going to show you a flexible setup that allows me to host any number of applications on any number of server instances, proxy-ed not only from relative paths in your domain but from subdomains as well.

Here’s the case study:

Jira, Confluence, Crowd hosted on a single Tomcat instance;
External war directories, single server.xml configuration file;
Apache front-end with separate subdomains for each application: jira.example.com, wiki.example.com, proxy without SSL;

Server.xml

The server.xml configures all applications in multiple services:

<Server port="8005" shutdown="SHUTDOWN">

<Service name="CrowdIdService">
    <Connector port="8086" proxyPort="80" proxyName="crowdid.example.com"
      maxHttpHeaderSize="8192" maxThreads="150" minSpareThreads="25" maxSpareThreads="75" useBodyEncodingForURI="true"
      enableLookups="false" redirectPort="8446" acceptCount="100" connectionTimeout="20000" disableUploadTimeout="true" />

    <Engine name="CrowdIdEngine" defaultHost="localhost">
      <Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true">
        <Context path="" docBase="/path/to/crowd-openid-2.0.2-war" reloadable="false">
                <Logger className="org.apache.catalina.logger.FileLogger" prefix="atlassian-crowdid." suffix=".log" timestamp="true"/>
       <Resource name="jdbc/CrowdIDDS" auth="Container" type="javax.sql.DataSource" username="your_crowd_db_user" password="your_password" driverClassName="org.postgresql.Driver" url="jdbc:postgresql://127.0.0.1:5432/crowdiddb"/>
        <Manager className="org.apache.catalina.session.PersistentManager" saveOnRestart="false"/>
         </Context>
     </Host>
</Engine>
</Service>

<Service name="CrowdService">
<Connector port="8085" proxyPort="80" proxyName="crowd.example.com"
      maxHttpHeaderSize="8192" maxThreads="150" minSpareThreads="25" maxSpareThreads="75" useBodyEncodingForURI="true"
      enableLookups="false" redirectPort="8445" acceptCount="100" connectionTimeout="20000" disableUploadTimeout="true" />

<Engine name="CrowdEngine" defaultHost="localhost">
      <Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true">
        <Context path="" docBase="/path/to/crowd-2.0.2-war" reloadable="false">
                <Logger className="org.apache.catalina.logger.FileLogger" prefix="atlassian-crowd." suffix=".log" timestamp="true"/>
        </Context>
     </Host>
</Engine>
</Service>


<Service name="WikiService">
    <Connector port="8083" proxyPort="80" proxyName="wiki.example.com"
      maxHttpHeaderSize="8192" maxThreads="150" minSpareThreads="25" maxSpareThreads="75" useBodyEncodingForURI="true"
      enableLookups="false" redirectPort="8443" acceptCount="100" connectionTimeout="20000" disableUploadTimeout="true" />
    <Engine name="WikiEngine" defaultHost="localhost">
      <Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true">
        <Context path="" docBase="/path/to/confluence-3.0.2-war/confluence" reloadable="false">
                <Logger className="org.apache.catalina.logger.FileLogger" prefix="atlassian-confluence." suffix=".log" timestamp="true"/>
        </Context>
     </Host>
</Engine>
</Service>

<Service name="JiraService">

    <Connector port="8082" proxyPort="80" proxyName="jira.erbix.com"
      maxHttpHeaderSize="8192" maxThreads="150" minSpareThreads="25" maxSpareThreads="75" useBodyEncodingForURI="true"
      enableLookups="false" redirectPort="8442" acceptCount="100" connectionTimeout="20000" disableUploadTimeout="true" />

    <Engine name="JiraEngine" defaultHost="localhost">
     <Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true">
        <Context path="" docBase="/path/to/jira-4.0.1-war" reloadable="false">
          <Resource name="jdbc/JiraDS" auth="Container" type="javax.sql.DataSource"
            username="your_jira_user"
            password="your_jira_password"
            driverClassName="org.postgresql.Driver"
            url="jdbc:postgresql://127.0.0.1:5432/jiradb"
            />
          <Resource name="UserTransaction" auth="Container" type="javax.transaction.UserTransaction"
            factory="org.objectweb.jotm.UserTransactionFactory" jotm.timeout="60"/>
          <Manager pathname=""/>
        </Context>
      </Host>

   <Valve className="org.apache.catalina.valves.AccessLogValve" resolveHosts="false"
              pattern="%a %{jira.request.id}r %{jira.request.username}r %t &quot;%m %U%q %H&quot; %s %b %D &quot;%{Referer}i&quot; &quot;%{User-Agent}i&quot; &quot;%{jira.request.assession.id}r&quot;"/>

    </Engine>
 </Service>

  <Listener className="org.apache.catalina.mbeans.ServerLifecycleListener" />
  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
  <Listener className="org.apache.catalina.storeconfig.StoreConfigLifecycleListener"/>

</Server>

For each application there’s a configured Service that listens to a safe-port. You can now configure the Connector proxyName and Context path to either host the apps on different subdomains (e.g. jira.example.com and wiki.example.com) or on relative paths (e.g. example.com/jira and example.com/wiki).

Apache Virtual Hosts

Now we configure a virtual host for each subdomain we’re hosting:

</VirtualHost>
  <VirtualHost 127.0.0.1:80>
    ServerName wiki.example.com
    ProxyRequests Off
    ProxyPreserveHost On
    <Proxy *>
      Order deny,allow
      Allow from all
    </Proxy>
    ProxyPass /  http://localhost:8083/
    ProxyPassReverse /  http://localhost:8083/
    <Location // >
      Order deny,allow
      Deny from all
      Allow from 127.0.0.1
    </Location>
</VirtualHost>

If you are hosting multiple apps on the same subdomain, add multiple ProxyPass lines with the relative paths.

Conclusions

These configurations provide the most flexible way of setting your apps and server instances with an Apache front-end. I would also recommend having a single server.xml configuration file and external folders for apps. Self-extracting wars and per-application configuration files don’t offer the big-picture perspective.

The Attlassian instructions on integrating Jira and Confluence with Apache restricted the setup to relative paths on a domain: http://confluence.atlassian.com/display/JIRA/Integrating+JIRA+with+Apache.

Apache Front-End for Java EE Application Servers Using mod_proxy and mod_ssl

2011-10-22T00:00:00+02:00

The following setup is appropriate if:

you want to run your Java EE Application Server (e.g. JBoss) or servlet container (e.g. Apache Tomcat) with non-root privileges (which is recommended);
run multiple application server instances on the same domain/IP address.

Software

Apache web server with mod_ssl and mod_proxy
Java EE application server or servlet container (e.g. Apache Tomcat 6+, JBoss)

Proxy Without SSL:

You need to setup a virtual host in httpd.conf (or in a file included with an #include directive). Replace 127.0.0.1 with your public IP address.

<VirtualHost 127.0.0.1:80>
    ServerName example.com
    ServerAlias www.example.com
    ProxyRequests Off
    ProxyPreserveHost On

    <Proxy *>
      Order deny,allow
      Allow from all
    </Proxy>

    ProxyPass /  http://localhost:8090/
    ProxyPassReverse /  http://localhost:8090/

    <Location // >
      Order deny,allow
      Deny from all
      Allow from 127.0.0.1
    </Location>
</VirtualHost>

Apache will proxy from your public IP on port 80, preserving the hostname, to localhost (127.0.0.1) on port 8090. Your J2EE server will listen on port 8090.

The corresponding connector in the XML configuration file (e.g. conf/server.xml) looks like this:

 <Connector port="8090" proxyPort="80"
      maxHttpHeaderSize="8192" maxThreads="150" minSpareThreads="25" maxSpareThreads="75" useBodyEncodingForURI="true"
      enableLookups="false" redirectPort="8446" acceptCount="100" connectionTimeout="20000" disableUploadTimeout="true" />

Proxy With SSL:

When using a SSL connection, you need to turn on mod_ssl and configure the virtual host with the SSL certificates and key:

<VirtualHost 127.0.0.1:443>
    ServerName secure.example.com:443
    ServerAdmin webmaster@example.com

    ProxyRequests off
    ProxyPreserveHost off
    SSLProxyEngine on
    
    SSLEngine on
    SSLCipherSuite ALL:!ADH:!EXPORT56:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv2:+EXP:+eNULL
    SSLCACertificateFile /path/to/ca-bundle/Your-SSL.ca-bundle
    SSLCertificateFile /path/to/secure.example.com.crt
    SSLCertificateKeyFile /path/to/secure.example.com.key

    <Location /  >
      SSLRequireSSL
      ProxyPass  https://localhost:8091/
      ProxyPassReverse https://localhost:8091/
    </Location>
</VirtualHost>

The corresponding connector in the J2EE server XML configuration file (e.g. conf/server.xml) look like this:

<Connector port="8091" protocol="HTTP/1.1" SSLEnabled="true"
               maxThreads="150" scheme="https" secure="true"
               clientAuth="false" sslProtocol="SSL"
               keystorePass="changeit"
               keystoreFile="/path/to/self/signed/localhost.keystore"
               proxyName="secure.example.com"
               proxyPort="443"
/>

Customizations

You can customize this setup to proxy from subdomains or from relative paths on your domain. You can also host multiple applications (war files) on the same server instance and proxy to them through an Apache front-end.

JAX-RS (Jersey) Configured With Google Guice

2011-10-21T00:00:00+02:00

JAX-RS is an API for RESTful web services in Java. I’ve started with Jersey implementation and as I was using Guice I needed a way to configure Jersey servlets to inject dependencies with Guice.

You can find the boilerplate code for a Guice application in a previous post so I’m just going to show you the details for adding JAX-RS servlets.

JAX-RS Servlets Extend `GuiceContainer`

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Singleton;
import com.sun.jersey.guice.spi.container.servlet.GuiceContainer;

@Singleton
public class MyServlet extends GuiceContainer {
  private static final long serialVersionUID = -5088704754634598007L;
  @Inject
  MyServlet(Injector injector) {
    super(injector);
  }
  @Override
  public void service(ServletRequest request, ServletResponse response)
      throws ServletException, IOException {
    super.service(request, response);
  }
}

Just Serve

In your ServletModule you can just serve with your guiced Jersey servlet:

import java.util.HashMap;
import java.util.Map;
import com.google.inject.servlet.ServletModule;
public class JaxServletModule extends ServletModule {

  protected void configureServlets() {
    // Bind beans.
    bind(MyAction.class);
    bind(MySecondAction.class);
    // Bind other dependencies
    bind(MyDependency.class).to(MyDependencyImpl.class);
    // Serve with MyServlet
    Map<String, String> params = new HashMap<String, String>();
    serve("/*").with(MyServlet.class, params);
  }
}

Define Applications

You can also split your code into applications. Each application will only load the set classes associated with it. However, because of a Jersey issue, you will not be able to assign identical paths to beans from different applications.

import java.util.HashSet;
import java.util.Set;
import javax.ws.rs.core.Application;
import com.google.inject.Singleton;
@Singleton
public class MyApplication extends Application {
    @Override
    public Set<Class<?>> getClasses() {
        Set<Class<?>> classes = new HashSet<Class<?>>();
        classes.add(MyAction.class);
        classes.add(MySecondAction.class);
        return classes;
    }
}

Now you have to add an extra parameter to the servlet:

    Map<String, String> params = new HashMap<String, String>();
    params.put("javax.ws.rs.Application", "com.example.MyApplication");
    serve("/*").with(MyServlet.class, params);

Beans Are Injected by Guice

Now all beans will be injected by Guice. Don’t forget to bind them in your ServletModule.

import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.UnknownHostException;
import java.util.HashMap;
import java.util.Map;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.StreamingOutput;

import com.google.inject.Inject;
import com.google.inject.Singleton;

@Path("/{lang : [a-z]{2}}/app/")
@Singleton
public class MyAction {
  private final MyDependency dependency;

  @Inject
  MyAction(MyDependency dependency) {
    this.dependency = dependency;
  }
  @GET
  @Produces("text/html")
  @Path("/")
  public StreamingOutput getHome() throws UnknownHostException, MongoException {
    return new StreamingOutput() {
        @Override
        public void write(OutputStream stream) throws IOException,
           /* stream output here*/
        }
      };
  }
}

SHA1/MD5 Encryption in Java

2011-10-20T00:00:00+02:00

A simple function I use when I need hash encryption in Java. You could catch the NoSuchAlgorithmException exception and log it inside the function or hardcode the algorithm parameter.

This function also shows a way of converting a byte array to hex character string.

  //Algorithm: "SHA1" or "MD5"
  public static String encrypt(String data, String algorithm) throws NoSuchAlgorithmException {
    if (data == null) return null;
    MessageDigest md = MessageDigest.getInstance(algorithm);
    md.update(data.getBytes());
    byte[] digest = md.digest();
    StringBuffer buf = new StringBuffer();
    for (byte b : digest) {
      buf.append((Character.forDigit((b & 0xF0) >> 4, 16)));
      buf.append((Character.forDigit((b & 0xF), 16)));
    }
    return buf.toString();
  }

Jetty 7 With Google Guice 3.0 on Heroku Cedar

2011-10-19T00:00:00+02:00

Intro

The purpose of this tutorial is to publish a Java web application on Heroku that’s using Guice servlets.

Google Guice is a great, lightweight dependency injection framework. I’ve been using it for more than a year now on Erbix and basically in all my current Java projects. I recommend reading the Guice documentation for an in-depth view of the library.

You can download the source code from here.

Prerequisites

JVM and Maven

You must install a JVM. Your application must run on OpenJDK 6.

Heroku uses Maven build system. If you don’t have Maven installed, you can download it from here.

Git

If you already have Git installed, you can skip this step.

Download the latest version of Git for your operating system and install it.

Heroku

If you have already deployed applications on Heroku, you can skip this step.

Sign-up for a free account.
Download and install the toolbelt.
Run Heroku. You must enter the email and password used to login to Heroku. Press enter or type “Y” to upload your ssh key. If you don’t have a ssh key, one will be created for you in /your/home/directory/.ssh/id_rsa.pub.

$ heroku login
Enter your Heroku credentials.
Email: you@yourdomain.com
Password: 
Could not find an existing public key.
Would you like to generate one? [Yn] 
Generating new SSH public key.
Uploading ssh public key /path/to/user/home/.ssh/id_rsa.pub

Build the Application

Files and Folders

You will need to create the following files and folders:

guice-on-heroku/
|_pom.xml
|_Procfile
|_src/
  |_main/
    |_java/
      |_com/
        |_dailyjavatips
	  |_JettyServer.java
	  |_ServletConfig.java
	  |_MainServlet.java
	  |_GuiceServletModule.java
	  |_Resource.java
	  |_ResourceImpl.java
	  |_ResourceModule.java


$ mkdir -p guice-on-heroku/src/main/java/com/dailyjavatips
$ cd guice-on-heroku
$ touch pom.xml Procfile
$ cd src/main/java/com/dailyjavatips
$ touch JettyServer.java ServletConfig.java MainServlet.java GuiceServletModule.java Resource.java ResourceImpl.java ResourceModule.java

Pom.xml

pom.xml is the Maven configuration file. It’s structure is pretty straightforward:

three dependencies: Jetty, Google Guice and Servlet API 2.5;
compile in target folder;
main class com.dailyjavatips.JettyServer.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" 
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.dailyjavatips</groupId>
    <version>0.1</version>
    <artifactId>guice-boilerplate</artifactId>
    <dependencies>
        <dependency>
          <groupId>org.eclipse.jetty</groupId>
          <artifactId>jetty-servlet</artifactId>
          <version>7.5.3.v20111011</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
          <groupId>com.google.inject</groupId>
          <artifactId>guice</artifactId>
         <version>3.0</version>
        </dependency>
        <dependency>
          <groupId>com.google.inject.extensions</groupId>
          <artifactId>guice-servlet</artifactId>
          <version>3.0</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>appassembler-maven-plugin</artifactId>
                <version>1.1.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals><goal>assemble</goal></goals>
                        <configuration>
                            <assembleDirectory>target</assembleDirectory>
                            <programs>
                                <program>
                                    <mainClass>com.dailyjavatips.JettyServer</mainClass>
                                    <name>webapp</name>
                                </program>
                            </programs>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Procfile

Procfile contains the command used to run the web application.

web: sh target/bin/webapp

The target/bin/webapp script file is automatically generated by the appassembler: plugin:

#!/bin/sh
[…]

CLASSPATH=$CLASSPATH_PREFIX:"$BASEDIR"/etc:"$REPO"/org/eclipse/jetty/jetty-servlet/7.5.3.v20111011/jetty-servlet-7.5.3.v20111011.jar:"$REPO"/org/eclipse/jetty/jetty-security/7.5.3.v20111011/jetty-security-7.5.3.v20111011.jar:"$REPO"/org/eclipse/jetty/jetty-server/7.5.3.v20111011/jetty-server-7.5.3.v20111011.jar:"$REPO"/org/eclipse/jetty/jetty-continuation/7.5.3.v20111011/jetty-continuation-7.5.3.v20111011.jar:"$REPO"/org/eclipse/jetty/jetty-http/7.5.3.v20111011/jetty-http-7.5.3.v20111011.jar:"$REPO"/org/eclipse/jetty/jetty-io/7.5.3.v20111011/jetty-io-7.5.3.v20111011.jar:"$REPO"/org/eclipse/jetty/jetty-util/7.5.3.v20111011/jetty-util-7.5.3.v20111011.jar:"$REPO"/javax/servlet/servlet-api/2.5/servlet-api-2.5.jar:"$REPO"/com/google/inject/guice/3.0/guice-3.0.jar:"$REPO"/javax/inject/javax.inject/1/javax.inject-1.jar:"$REPO"/aopalliance/aopalliance/1.0/aopalliance-1.0.jar:"$REPO"/com/google/inject/extensions/guice-servlet/3.0/guice-servlet-3.0.jar:"$REPO"/com/dailyjavatips/guice-boilerplate/0.1/guice-boilerplate-0.1.jar
EXTRA_JVM_ARGUMENTS=""

[…]
exec "$JAVACMD" $JAVA_OPTS \
  $EXTRA_JVM_ARGUMENTS \
  -classpath "$CLASSPATH" \
  -Dapp.name="webapp" \
  -Dapp.pid="$$" \
  -Dapp.repo="$REPO" \
  -Dbasedir="$BASEDIR" \
  com.dailyjavatips.JettyServer \
  "$@"

JettyServer.java

This is the main class contains the boilerplate code for programmatically configuring Jetty:

package com.dailyjavatips;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.*;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.servlet.*;
import com.google.inject.servlet.GuiceFilter;

public class JettyServer {
  public static void main(String[] args) throws Exception{
    Server server = new Server(Integer.valueOf(System.getenv("PORT")));    
    ServletContextHandler root = new ServletContextHandler(server, "/", ServletContextHandler.SESSIONS);

    root.addEventListener(new ServletConfig());
    root.addFilter(GuiceFilter.class, "/*", 0);
    root.addServlet(MainServlet.class, "/*");

    server.start();
    server.join();   
  }
}

The equivalent web.xml file would look like this:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
  <display-name>guicefilter</display-name>
  <filter>
    <filter-name>guiceFilter</filter-name>
    <filter-class>com.google.inject.servlet.GuiceFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>guiceFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <listener>
    <listener-class>com.dailyjavatips.ServletConfig</listener-class>
  </listener>
</web-app>

ServletConfig.java

ServletConfig creates an Injector based on a ServletModule:

package com.dailyjavatips;

import javax.servlet.ServletContextEvent;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.servlet.GuiceServletContextListener;

public class ServletConfig extends GuiceServletContextListener {  
  /**
   * @see com.google.inject.servlet.GuiceServletContextListener#getInjector()
   */
  @Override
  protected Injector getInjector() {
    return Guice.createInjector(new GuiceServletModule());
  }
}

GuiceServletModule

We need to implement a ServletModule with the configureServlets method that will be called by the context listener:

package com.dailyjavatips;
import com.google.inject.servlet.ServletModule;
import java.util.HashMap;
import java.util.Map;

public class GuiceServletModule extends ServletModule {
  /**
   * Configure servlets and filters. This function is called in the super class
   * in the configure() module method. Add here all the bindings for the module.
   * @see com.google.inject.servlet.ServletModule#configureServlets()
   */
  protected void configureServlets() {
    // Resources can be binded here or in a separate module.
    install(new ResourceModule());
    
    // Create the parameter map for the Main servlet.
    Map<String, String> params = new HashMap<String, String>();
    serve("/*").with(MainServlet.class, params);
  }
}

ResourceModule

We can create extra modules that can be installed by the ServletModule. This module binds an interface to an implementation:

package com.dailyjavatips;
import com.google.inject.AbstractModule;
public class ResourceModule extends AbstractModule {
  /**
   * @see com.google.inject.AbstractModule#configure()
   */
  @Override
  protected void configure() {
    // Bind Resources
    bind(Resource.class).to(ResourceImpl.class);
  }
}

Resource

Every time a Resource object is requested, the injector returns an instance of type ResourceImpl. Since ResourceImpl is in Singleton scope, the same instance will be injected every time.

package com.dailyjavatips;

public interface Resource {
  public String getResource();
}

ResourceImpl

package com.dailyjavatips;
import com.google.inject.Singleton;
@Singleton
public class ResourceImpl implements Resource {
  @Override
  public String getResource() {
    return "This resource was injected by Guice.";
  }
}

MainServlet

package com.dailyjavatips;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.google.inject.Inject;
import com.google.inject.Singleton;

@Singleton
public class MainServlet extends HttpServlet {
  private final Resource resource;
  /**
   * Constructor called by Guice.
   */
  @Inject
  MainServlet(Resource resource) {
    this.resource = resource;
  }
  /**
   * @see javax.servlet.http.HttpServlet#service(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
   */
  public void service(HttpServletRequest request, HttpServletResponse response)
                      throws ServletException, IOException {
    response.getWriter().print("Guice Demo Application\n");
    response.getWriter().print(resource.getResource());
  }
}

Testing With Foreman

Now it’s time to test your application (change directory to guice-on-heroku):

$ foreman start
16:42:46 web.1     | started with pid 7236
16:42:46 web.1     | 2011-10-20 16:42:46.946:INFO:oejs.Server:jetty-7.5.3.v20111011
16:42:47 web.1     | 2011-10-20 16:42:47.603:INFO:oejsh.ContextHandler:started o.e.j.s.ServletContextHandler{/,null}
16:42:47 web.1     | 2011-10-20 16:42:47.691:INFO:oejs.AbstractConnector:Started SelectChannelConnector@0.0.0.0:5000 STARTING

Your app runs on port 5000:

$ curl 127.0.0.1:5000
Guice Demo Application
This resource was injected by Guice.McSpeedy:guice-on-heroku mehi

Push Code to Heroku

Commands – Short List:

$ cd /path/to/guice-on-heroku/
$ echo target>.gitignore
$ git init
$ git add .
$ git commit -m "Initial commit."
$ heroku create --stack cedar
$ git push heroku master

Commands – With Response

$ cd /path/to/guice-on-heroku/
$ echo target>.gitignore
$ git init
Initialized empty Git repository in /path/to/guice-on-heroku/.git/
$ git add .
$ git commit -m "Initial commit."
[master (root-commit) e21d590] Initial commit.
 16 files changed, 200 insertions(+), 0 deletions(-)
 create mode 100644 .gitignore
 create mode 100644 Procfile
 create mode 100644 pom.xml
 create mode 100644 src/.DS_Store
 create mode 100644 src/main/.DS_Store
 create mode 100644 src/main/java/.DS_Store
 create mode 100644 src/main/java/com/.DS_Store
 create mode 100644 src/main/java/com/dailyjavatips/.DS_Store
 create mode 100644 src/main/java/com/dailyjavatips/GuiceServletModule.java
 create mode 100644 src/main/java/com/dailyjavatips/JettyServer.java
 create mode 100644 src/main/java/com/dailyjavatips/MainServlet.java
 create mode 100644 src/main/java/com/dailyjavatips/Resource.java
 create mode 100644 src/main/java/com/dailyjavatips/ResourceImpl.java
 create mode 100644 src/main/java/com/dailyjavatips/ResourceModule.java
 create mode 100644 src/main/java/com/dailyjavatips/ServletConfig.java

$heroku create --stack cedar
Creating electric-snow-2485... done, stack is cedar
http://electric-snow-2485.herokuapp.com/ | git@heroku.com:electric-snow-2485.git
Git remote heroku added

$ git push heroku master
Counting objects: 23, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (21/21), done.
Writing objects: 100% (23/23), 4.14 KiB, done.
Total 23 (delta 5), reused 0 (delta 0)

-----> Heroku receiving push
-----> Removing .DS_Store files
-----> Java app detected
-----> Installing Maven 3.0.3..... done
-----> Installing settings.xml..... done
-----> executing /app/tmp/repo.git/.cache/.maven/bin/mvn -B -Duser.home=/tmp/build_1s08fyb3dse5f -Dmaven.repo.local=/app/tmp/repo.git/.cache/.m2/repository -s /app/tmp/repo.git/.cache/.m2/settings.xml -DskipTests=true clean install
       [INFO] Scanning for projects...
       [INFO]                                                                         
       [INFO] ------------------------------------------------------------------------
       [INFO] Building guice-boilerplate 0.1
       [INFO] ------------------------------------------------------------------------
   […]
       [INFO] BUILD SUCCESS
       [INFO] ------------------------------------------------------------------------
       [INFO] Total time: 7.053s
       [INFO] Finished at: Thu Oct 20 13:55:32 UTC 2011
       [INFO] Final Memory: 10M/490M
       [INFO] ------------------------------------------------------------------------
-----> Discovering process types
       Procfile declares types -> web
-----> Compiled slug size is 1.6MB
-----> Launching... done, v4
       http://electric-snow-2485.herokuapp.com deployed to Heroku

To git@heroku.com:electric-snow-2485.git
 * [new branch]      master -> master

See it in Action

You can check my result on http://electric-snow-2485.herokuapp.com/. You should get a similar response on your domain.

Reading:

http://devcenter.heroku.com/articles/java
http://code.google.com/p/google-guice/

Web Server With Thread Pooling - Part 4

2011-10-18T00:00:00+02:00

The tutorial source code can be downloaded from here. The only dependency is Log4j.

Tutorial parts:

Web Server With Thread Pooling – Part 1
Web Server With Thread Pooling – Part 2
Web Server With Thread Pooling – Part 3

Use Ant to build the project. and run the server:

java -classpath bin:lib/log4j-1.2.12.jar com.foo.TPWebServer 127.0.0.1:8080 "path/to/files/" > log.out

Lightweight open source web servers:

Jetty
Simple Framework
Jigsaw
Web Server tutorial

Web Server With Thread Pooling - Part 3

2011-10-17T00:00:00+02:00

A HTTP Handler

The Handler object handles, in a thread-safe manner, the socket connections.

public interface Handler {
  public boolean handle(Socket socket) throws Exception;
  public void setServer(Server server);
  public Server getServer();
}

The HTTP handler reads data from the open socket and streams back data to the client. This tutorial implementation does not handle all the HTTP specs, instead decodes GET HTTP requests and streams back files found on the server.

You can find the simple HTTP implementation here.

The full RFC 2616 can be found here.

You can understand better the code HTTP handler code reading this.

Wrapping Things Up

Finally, let’s see how we assemble the components described:

Create and initialize a Connector :

    
// Socket connector with 3 acceptor threads.
Connector connector = new SocketConnectorImpl(3);
// Configure port and hostname.
connector.setHost(host);
connector.setPort(port);

Create and initialize a Handler :

 
Handler handler = new HttpFilesHandlerImpl(base);

Create and initialize an external ThreadPool :

 
// Keep 10 threads, maximum 25, 60 seconds timeout.
ThreadPoolImpl tp = new ThreadPoolImpl(10, 25, 60, TimeUnit.SECONDS);

Create and initialize the Server :

 
Server server = new TPWebServerImpl(tp);
server.setConnectors(connectors);
server.setHandler(handler);

Remember to set the server back to the connectors and handler:

 
connector.setServer(server);
handler.setServer(server);

Finally start the server:

 
server.start();

Web Server With Thread Pooling - Part 2

2011-10-16T00:00:00+02:00

This is the second part of a tutorial describing how to build a multithreaded web server. Here is the first part.

The `Connector` Interface

A Connector listens on a socket (IP address and port number) and dispatches requests to the Server.

public interface Connector {
  public void setPort(int port);
  public int getPort();

  public void setHost(String host);
  public String getHost();

  public void setServer(Server server);
  public Server getServer();

  public void start() throws Exception;
  public void stop() throws Exception;
}

The `Connector` Implementation

The Connector implementation is the most tricky part in this small project. We declare two member classes that implement the Runnable interface: Connection and Acceptor.

The Acceptor object listens (blocking) to socket connections on the connector’s port and host in a continuous loop. When connections are established, it dispatches a new Connection job and loops back waiting for other connections.

The Connection object calls the thread-safe handle method in the server.

When the server starts, a number of Acceptor jobs are dispatched. When the server is stopped, all connections are closed.

Acceptor class:

private class Acceptor implements Runnable {
    private final int index;
    public Acceptor(int index) {
      this.index = index;
    }
    @Override
    public void run() {
      try {
        while(true) {
          Socket socket = serverSocket.accept();
          configure(socket);
          server.dispatch(new Connection(socket));
        }
      } catch (Exception e) {
	/* log error */        
      }
    }
  }

Connection class:

private class Connection implements Runnable {
    private final Socket socket;
    public Connection(Socket socket) {
      this.socket = socket;
    }
    public void close() throws IOException {
      if (socket != null) {
        socket.close();
        removeConnection(this);
      }
    }
    /**
     * @see java.lang.Runnable#run()
     */
    @Override
    public void run() {
      // Register open connection.
      connections.add(this);
      try {
        server.handle(socket);
      } catch (Exception e) {
         /* log error */
      } finally {
        try {
          // Close connections 
          close();
        } catch (IOException e) {
          /* log error */
        }
      }
    }
  }

Web Server With Thread Pooling - Part 1

2011-10-15T00:00:00+02:00

This is the first part of a tutorial describing how to build a multithreaded web server. The web server implements a thread pool for listening for socket connections and processing HTTP requests.

The (web) server has 4 components:

Connector – accepts connections (blocking);
Handler – handles open connections;
ThreadPool – thread pool that runs jobs;
Server – a thread pool that dispatches acceptor and connection handling jobs.

This structure can be used to deploy any type of server over TCP/IP, not just HTTP servers. The structure is similar/inspired by Jetty Web Server
http://docs.codehaus.org/display/JETTY/Architecture

The `ThreadPool` Interface

Thread creation is costly and multithreaded applications can benefit from creating threads at start and reusing them with multiple jobs. The ThreadPool class must dispatch jobs on available threads.

The ThreadPool uses a Runnable object to start threads. The run method will be called when the thread is created or reused.

public interface ThreadPool {
  /**
   * Dispatch job.
   * @param job 
   * @return true if job executed successfully.
   * @throws Exception
   */
  public boolean dispatch(Runnable job) throws Exception;

 /* other methods here */
}

The `ThreadPool` Implementation

The ThreadPoolExecutor class makes it very easy to implement the ThreadPool interface.

public class ThreadPoolImpl extends ThreadPoolExecutor implements ThreadPool {

   /* constructors here */

  /**
   * @see com.foo.tpws.ThreadPool#dispatch(java.lang.Runnable)
   */
  @Override
  public boolean dispatch(Runnable job) throws Exception {
    try {
        super.execute(job);
        return true;
    } catch (RejectedExecutionException e) {
       logger.warn(e);
       return false;
    }
  }

 /* other methods from ThreadPool interface here */
}

The `Server` Interface

The (web) server is ThreadPool that uses a Connector to listen for requests and dispatches them to be handled by a Handler .

import java.net.Socket;

public interface Server extends ThreadPool {
  // Requests are processed by a Handler
  public void setHandler(Handler handler);
  public Handler getHandler();
  // The server starts a number of connectors.
  public void setConnectors(Connector[] connectors);
  public Connector[] getConnectors();
  // Start/Stop methods for the server.
  public void start() throws Exception;
  public void stop() throws Exception;
  // Method called by the connector threads with the open Socket.
  public void handle(Socket socket) throws Exception;
}

The `Server` Implementation

The Server implementation is focused in start(), stop() and handle(Socket socket) methods:

  @Override
  public void start() throws Exception {
    if (connectors != null) {
      for (Connector connector: connectors) {
        if (connector != null) {
          connector.start();
        }
      }
    }
  }
  @Override
  public void stop() throws Exception {
    if (connectors != null) {
      for (Connector connector: connectors) {
        if (connector != null) {
          connector.stop();
        }
      }
    }
  }
  @Override
  public void handle(Socket socket) throws Exception {
    if (handler != null)
      handler.handle(socket);
  }

External `ThreadPool`

The Server implementation, rather than implementing the ThreadPool methods directly, it extends a ThreadPool wrapper class. This way, an external ThreadPool implementation can be injected in the server.

public class ThreadPoolWrapperImpl implements ThreadPool {
  protected final ThreadPool threadPool;
  
  public ThreadPoolWrapperImpl(ThreadPool threadPool) {
    this.threadPool = threadPool;
  }
  /* wrap methods here */
}

public class TPWebServerImpl extends ThreadPoolWrapperImpl implements Server {
  /* methods here */
}