A functional reactive alternative to Spring

Ravi Chodavarapu

Options Just Ahead sign image via Shutterstock

Modern-day Spring allows you to be pretty concise. You can get an elaborate web service up and running using very little code. But when you write idiomatic Spring, you find yourself strewing your code with lots of magic annotations whose function and behavior are hidden within complex framework code and documentation.

When you want to stray away slightly from what the magic annotations allow, you suddenly hit a wall: you start debugging through hundreds of lines of framework code to figure out what it’s doing, and how you can convince the framework to do what you want instead.

datamill is a Java web framework that is a reaction to that approach. Unlike other modern Java frameworks, it makes the flow and manipulation of data through your application highly visible. How does it do that? It uses a functional reactive style built on RxJava. This allows you to be explicit about how data flows through your application, and how to modify that data as it does. At the same time, if you use Java 8 lambdas (datamill and RxJava are intended to be used with lambdas), you can still keep your code concise and simple.

Let’s take a look at some datamill code to illustrate the difference:

public static void main(String[] args) {
    OutlineBuilder outlineBuilder = new OutlineBuilder();
    Server server = new Server(
        rb -> rb.ifMethodAndUriMatch(Method.GET, "/status", r -> r.respond(b -> b.ok()))
            .elseIfMatchesBeanMethod(outlineBuilder.wrap(new TokenController()))
            .elseIfMatchesBeanMethod(outlineBuilder.wrap(new UserController()))
            .orElse(r -> r.respond(b -> b.notFound())),
        (request, throwable) -> handleException(throwable));

A few important things to note:

  • datamill applications are primarily intended to be started as standalone Java applications – you explicitly create the HTTP server, specify how requests are handled, and have the server start listening on a port. Unlike traditional JEE deployments where you have to worry about configuring a servlet container or an application server, you have control of when the server itself is started. This also makes creating a Docker container for your server dead simple. Package up an executable JAR using Maven and stick it in a standard Java container.
  • When a HTTP request arrives at your server, it is obvious how it flows through your application. The line
rb.ifMethodAndUriMatch(Method.GET, "/status", r -> r.respond(b -> b.ok()))

says that the server should first check if the request is a HTTP GET request for the URI /status, and if it is, return a HTTP OK response.

  • The next two lines show how you can organize your request handlers while still maintaining an understanding of what happens to the request.For example, the line
.elseIfMatchesBeanMethod(outlineBuilder.wrap(new UserController()))

says that we will see if the request matches a handler method on the UserControllerinstance we passed in. To understand how this matching works, take a look at the UserController class, and one of the request handling methods:

public class UserController {
public Observable<Response> getUser(ServerRequest request) {
    return userRepository.getByUserName(request.uriParameter("userName").asString())
        .map(u -> new JsonObject()
            .put(userOutlineCamelCased.member(m -> m.getId()), u.getId())
            .put(userOutlineCamelCased.member(m -> m.getEmail()), u.getEmail())
            .put(userOutlineCamelCased.member(m -> m.getUserName()), u.getUserName()))
        .flatMap(json -> request.respond(b -> b.ok(json.asString())))
        .switchIfEmpty(request.respond(b -> b.notFound()));

You can see that we use @Path and @GET annotations to mark request handlers. But the difference is that you can pin-point where the attempt to match the HTTP request to an annotated method was made. It was within your application code – you did not have to go digging through hundreds of lines of framework code to figure out how the framework is routing requests to your code.

  • Finally, in the code from the UserController, notice how the response is created – and how explicit the composition of the JSON is within datamill:
.map(u -> new JsonObject()
    .put(userOutlineCamelCased.member(m -> m.getId()), u.getId())
    .put(userOutlineCamelCased.member(m -> m.getEmail()), u.getEmail())
    .put(userOutlineCamelCased.member(m -> m.getUserName()), u.getUserName()))
.flatMap(json -> request.respond(b -> b.ok(json.asString())))

You have full control of what goes into the JSON. For those who have ever tried to customize the JSON output by Jackson to omit properties, or for the poor souls who have tried to customize responses when using Spring Data REST, you will appreciate the clarity and simplicity.

Just one more example from an application using datamill – consider the way we perform a basic select query:

public class UserRepository extends Repository<User> {
public Observable<User> getByUserName(String userName) {
    return executeQuery(
        (client, outline) ->
                .where().eq(outline.member(m -> m.getUserName()), userName)
                .map(r -> outline.wrap(new User())
                    .set(m -> m.getId(), r.column(outline.member(m -> m.getId())))
                    .set(m -> m.getUserName(), r.column(outline.member(m -> m.getUserName())))
                    .set(m -> m.getEmail(), r.column(outline.member(m -> m.getEmail())))
                    .set(m -> m.getPassword(), r.column(outline.member(m -> m.getPassword())))

A few things to note in this example:

  • Notice the visibility into the exact SQL query that is composed. For those of you who have ever tried to customize the queries generated by annotations, you will again appreciate the clarity. While in any single application, a very small percentage of the queries need to be customized outside of what a JPA implementation allows, almost all applications will have at least one of these queries. And this is usually when you get the sinking feeling before delving into framework code.
  • Take note of the visibility into how data is extracted from the result and placed into entity beans.
  • Finally, take note of how concise the code remains, with the use of lambdas and RxJava Observable operators.

Hopefully that gives you a taste of what datamill offers. What we wanted to highlight was the clarity you get on how requests and data flows through your application, and the clarity into how data is transformed.

datamill is still in an early stage of development but we’ve used it to build several large web applications. We find it a joy to work with.

We hope you’ll give it a try – we are looking for feedback. Go check it out.

This post was originally published on Stacks and Foundations


Ravi Chodavarapu

Software Consultant based in Dublin, Ireland

Inline Feedbacks
View all comments