Using TwitterServer from Java

It’s possible to use TwitterServer’s features in Java by extending the abstract class AbstractTwitterServer (a Java-friendly version of the TwitterServer trait).

In the following example, we define a JavaServer that simply prints a log message while initializing.

import com.twitter.server.AbstractTwitterServer

public class JavaServer extends AbstractTwitterServer {

  public static class Main {
    public static void main(String[] args) {
      new JavaServer().main(args);
    }
  }

  @Override
  public void onInit() {
    log().info("Java Server initialization...");
  }
}

Main Method

The primary difference between Scala’s TwitterServer and Java’s AbstractTwitterServer is that in Java you have to explicitly define a main method in a separate class (i.e., an inner class JavaServer$Main) and manually launch the server as shown below.

public static class Main {
  public static void main(String[] args) {
    new JavaServer().main(args);
  }
}

Lifecycle Methods

In order to make the API more Java-friendly, the AbstractTwitterServer provides methods that handle application lifecycle. So, you can easily override them in the concrete instance instead of calling the high-order functions premain, postmain, etc., which is still possible but quite painful to do in Java. For example, the following code shows how to override the onInit method, which will be executed on application initialization.

@Override
public void onInit() {
  log().info("Java Server initialization...");
}

Here is the full list of the lifecycle methods provided by AbstractTwitterServer:

  • onInit - called prior to application initialization
  • preMain - called before the main method
  • postMain - called after the main method
  • onExit - called prior to application exiting

Within an AbstractTwitterSever, it’s also possible to define a custom main method that will be called automatically after the preMain method and before the postMain method. To do so, simply override an instance method void main() throws Throwable with no args.

Reusing Scala Traits

AbstractTwitterServer‘s behaviour may be customized by mixing in Scala traits. The usage pattern is similar to how TwitterServer does it but with one restriction: it’s not possible to define/use Scala traits in Java, so we have to do it Scala.

To reuse Scala traits in Java (via trait mixing), in a separate Scala file define an abstract Scala class (e.g., StackServer) that extends all the traits you want to reuse.

import com.twitter.server.AbstractTwitterServer
import com.twitter.server.{Lifecycle, Deciderable}

abstract class StackServer extends AbstractTwitterServer
  with Lifecycle.Warmup
  with Deciderable

Now you can extend this abstract class in Java and inherit the behaviour defined by Scala traits.

public class JavaStackServer extends StackServer {
  public static class Main {
    public static void main(String[] args) {
      new JavaStackServer().main(args);
    }
  }
}