A Sinatra-inspired micro web framework for Java

http://www.sparkjava.com/

by codenut • 13 years ago

121 93 13 years ago

film42• 13 years ago

This looks really cool, I can't wait to hack around with this!

Question for the community: I don't have enough experience to know how this stacks up against other servers out there. Also, how do the people HN enjoy using java as a webserver (lang-wise, scaling-wise, etc)?

Any feedback would be much appreciated!!

mugenx86• 13 years ago

I've never enjoyed using Java.

If you have time look at Scala (Scalatra/Play Framework) or Clojure (Ring). You can reduce the size of your codebase dramatically.

codenut• 13 years ago

Ive enjoyed writing code in scala, not until I compile it. It takes a long to compile. I agree with you, java is not enjoyable but we cannot deny the fact it still gets the job done.

pjmlp2• 13 years ago

I enjoy using it, except when we are forced to target Websphere.

JBoss, Jetty and Tomcat are pretty good in terms of taking care of load in heavy sites.

Most JVMs (Oracle, IBM, Azul, Aonix, ...) are able to achieve very good performance levels.

There is the tooling one gets, not only in terms of IDE support, but also for monitoring the state of the server processes and how load is being affected.

Finally if Java the language, doesn't appeal you, there are plenty of languages that target the JVM as well.

fauigerzigerk2• 13 years ago

Java scales well as long as memory is not the issue. Java's problem is memory usage and above all a deeply ingrained culture of complexity.

trailfox2• 13 years ago

On modern server hardware memory is seldom an issue, but I would agree about the culture of complexity BeanSingletonProxyAbstractWorkerListener

johnyzee• 13 years ago

I would use Java for GWT, if nothing else. Being able to write a huge and complex application for the web, using Java both for the client and server code is something I would not want to live without (links in my profile for examples).

But besides that, Java is extremely mature, has great tooling, huge community and of course an enormous ecosystem with all the third party tools and libraries that come with it. The language is a bit primitive (but improving with each release), and the 'enterprise consultant' mindset of complexity for its own sake can be a turn-off, but overall, yeah, I like using Java.

mindcrime2• 13 years ago

Also, how do the people HN enjoy using java as a webserver (lang-wise, scaling-wise, etc)?

I mostly like Java, and find a lot of the criticisms to be somewhat misguided, or reducing to quibbling over minutiae. But the Java ecosystem has a lot going for it, and despite how some people think "enterprise-y" is a pejorative, a lot of those "enterprise" features are actually very handy when you're, well, building a serious enterprise solution. Sure, if you're building the n thousandth MVP of a new cat-picture-sharing site, you don't need Java. But if you're building Amazon.com (the ecommerce side, not AWS) you might just find that JTA, JMS, JMX, JAX-RS, and some of the other "enterprise-y" stuff in Java is pretty fucking useful.

From a scalability standpoint, using modern appservers, Java scales horizontally just fine. And since Java runs on just about everything from watches to IBM zSeries mainframes, it also scales vertically pretty well.

All of that said, I prefer to do my actual coding in Groovy, as opposed to "pure" Java, but Groovy is almost a strict superset of Java, just with nicer syntax and some new features. But whether you're using Groovy or Java, everything I said above still applies, since you're still part of that overall JVM ecosystem.

vorg2• 13 years ago

Groovy's much slower than Java. The statically typed mode shipped in Groovy 2 a year ago was written by one lone programmer they brougt in, is still buggy, and isn't even used in the Grails codebase afaik.

stevvooe• 13 years ago

Where does this stand against dropwizard?

mbell4• 13 years ago

Personally, I would use dropwizard. Spark's key point seems to be avoiding annotation based constructs.

Compare (Spark):

  public class HelloWorld {
     public static void main(String[] args) {      
        get(new Route("/hello") {
           @Override
           public Object handle(Request request, Response response) {
              return "Hello World!";
           }
        });
     }
  }

to (JAX-RS, which dropwizard uses)

  @Path("/hello")
  public class HelloWorld {
    @GET
    public String get() {
      return "Hello World";
    }
  }

newobj• 13 years ago

Annotations are great until you want to do ANYTHING dynamic. "It's a trap!" Everytime without fail I want to do this kind of thing I end up ripping it all out later when I need more flexibility.

If Dropwizard lets me fall back to non-annotations, then awesome.

Really, five minutes ago I didn't know either of these projects existed, so right now I'm feeling a little giddy either way you slice it!

swah• 13 years ago

Dropwizard is very well implemented and uses annotations for achieving a very concise syntax as far as Java goes. No XML too, which is a big plus for me.

But when I though how many lines some webapp I was writing would take in Clojure, I went to the corner of the room and cried.

My conclusion for now is that "first versions" should be written in dynamic languages.

pron6• 13 years ago

Right. This project should be compared to Jersey (the JAX-RS implementation Dropwizard uses). Dropwizard has other components as well (for monitoring, DB etc.).

nahname• 13 years ago

Have people dropped the 'com' from java projects now? Not arguing in favor, the whole thing is ridiculous to me (src/main/com/actual_files). Just curious.

mbell4• 13 years ago

Depends on the dependency management they want to support. If you want to get your package into maven central making it easy to use, you seem to still have to own the domain in reverse order. aka if you want to publish a package with a com.foo.* you need to actually own foo.com.

brazzy• 13 years ago

It would actually be src/main/com/organization/project/actual_files

And there are good reasons for that - naming packages after internet domains prevents namespace clashes and is consistently used by most Java projects.

It's actually projects that diverge from this convention that stand out like a sore thumb, and many that did have adopted it eventually, like JUnit.

Zolomon• 13 years ago

I wrote a semi-realtime implementation of the planning poker estimation technique at [1] using Spark and some template engine I found.

This was for a course in software project management with some time restraints, so only focused on getting it done.

[1] https://github.com/Zolomon/PlanningPoker

trailfox2• 13 years ago

Speaking of Sinatra-inspired web frameworks on the JVM have a look at Scalatra:

http://scalatra.org/

https://github.com/scalatra/scalatra

k__3• 13 years ago

I liked most of it. But when it came to this atmosphere stuff, it was vietnam all over again!

What's wrong with those Scala developers?

They could make beautiful frameworks and APIs, always start to create crazy method names.

"org.scalatra" %% "scalatra-atmosphere" % "2.2.1",
send(("author" -> "system") ~ ("message" -> "Only json is allowed") ~ ("time" -> (new Date().getTime.toString )))

What's wrong with them?!

dscrd• 13 years ago

Same symptom is shown in Haskell circles. I suspect it might be due to the enthusiasts of these languages often being mathematicians. And mathematicians love crazy sigils, as we know.

the13• 13 years ago

yah they should've done something like:

    send(JSONSerialization.with(StringSerializer.class, DateTimeSerializer.class).serialize(JSONObjectFactory.put(PairFactory.of(String.class, String.class).getInstance("author", "system"), PairFactory.of(String.class, String.class).getInstance("message", "Only json is allowed"), PairFactory.of(String.class, DateTime.class).getInstance("time", new Date())).getInstance()))

no, it's just json4s dsl for constructing json. If you wanted, you could've used constructors yourself:

    send(pretty(render(JObject(List(JField("author", JString("system")), JField("message", JString("Only json allowed")), JField("time", JString(new DateTime().getTime().toString()))))

usually scala libraries come with an easy to read/write DSL version of the API along with a more verbose java-style API shown above. Many libraries don't document with a plenty of examples. But, it really takes 10 minutes to learn DSL version in many cases. And, it gives you wings. There are plenty of benefits of DSL. You can research online about them.

noelherrick• 13 years ago

Scalatra had some good features, but the installation instructions required an entirely new build or package system, giter8, which in turn requires another package, conscript. Two packages to install another package? This is just an unnecessary barrier to entry.

hackerboos• 13 years ago

The problem I have with Scalatra is that they seemed to be more focused on their Manning book than getting the core docs up to a good standard.

the13• 13 years ago

yah, it required me to install a JVM. And JVM required me to purchase a personal computer that can host the JVM. And electricity and stuff. Such an unnecessary barrier to entry.

drawkbox• 13 years ago

Definitely something that was needed, microframeworks are great. Restlet I used long ago but still very Java enterprisey. Play! is like Java's Django/Rails and now Spark is the Sinatra, simple and minimal. Scalatra mentioned here looks great as well, all these wonderful minimal Java toys.

Shank• 13 years ago

It really bugs me that they decided to clone the Sinatra README page, keeping most of the docs on one giant list instead of a more traditional multi-page doc approach. See here: http://www.sparkjava.com/readme.html

In addition, some of their docs link to a Google Code page, which keeps some examples on its index too: https://code.google.com/p/spark-java/

Lastly, it appears they're using GitHub for actual code, and, while they have a Github wiki created, it has no information.

I wish I could stress just how important it is to have all of the docs in one centralized location. Somewhere along the line, one of the five places they have examples will get out of date, and it'll be difficult to play spot the differences when it's replicated everywhere.

waffenklang2• 13 years ago

would love to see such a mf for c/c++...

papaf• 13 years ago

https://github.com/d5/node.native

waffenklang2• 13 years ago

not exactly a microframework, but an interesting approach to build a basis for it, like rack for sinatra.

kitd• 13 years ago

Very nice! Had a look at this a year or so ago and it would be a great base for mocking up backends IMHO.

In a similar vein is Google SiteBricks: http://sitebricks.org/#home

Slightly heavier weight but with more features (templating, annotations, etc). Depends on Guice.

6ren2• 13 years ago

I think it's simpler to tribute Sinatra in Java by annotating methods:

  @get('/hi')
  String myMethod() {
    return "Hello World!";
  }

I made a prototype of this (including extracting arguments Sinatra-style, which I think is its coolest bit), and didn't encounter any serious problems with this approach.

jebblue4• 13 years ago

I like reducing the number of annotations which is one reason I like the SparkJava approach.

6ren2• 13 years ago

Java 8 lambdas might shorten their approach too.

scorchin• 13 years ago

There's also webbit-rest: https://github.com/webbit/webbit-rest

f4stjack• 13 years ago

Okay. I am holding the idiot ball here: How can we deploy an app developed with spark? What are our options? Heroku? AWS? I haven't seen anything regarding to deployment in the documentation.

msluyter• 13 years ago

Well, there's a howto on running on tomcat:

http://www.sparkjava.com/readme.html#title17

As for Heroku, I found this:

https://gist.github.com/Fitzsimmons/2490382

Generally, for a lot of apps the embedded Jetty webserver might be sufficient.

pwendel• 13 years ago

Check Running Spark on a Web Server, e.g. Tomcat in Readme section.

quicksilver03• 13 years ago

At the bottom of http://www.sparkjava.com/readme.html there are 2 options, an embedded web server (Jetty) and a configuration snippet for a standard web.xml file.

chotachetan• 13 years ago

It is a nice one. I use Jelastic(www.jelastic.com) for my startup. What if we can have the same functionality there integrated. But this is needed at least the microframeworks are nice. Thinking that the same kind of thing can be also achieved with he framework integration in Jelastic.

Oculus• 13 years ago

Finally a web framework I can use. All the Java web frameworks I tried to use are way too enterprise-y.

edwinnathaniel• 13 years ago

You should expand your horizon once in a while. JAX-RS has ben her for a while. Ditto with Spring MVC.

pron6• 13 years ago

This project is nice but it's important to mention that there is actually a "Java micro web framework" standard called JAX-RS that is pretty widely adopted (with solid open-source implementations by JBoss, Apache, Oracle and others). Here's a rather old comparison of JAX-RS implementations: http://www.infoq.com/news/2008/10/jaxrs-comparison

Its most notable implementation is perhaps Jersey (https://jersey.java.net/documentation/latest/getting-started...), which is used, for example, by Dropwizard (mentioned in another comment).

Some of these implementations include important features like health and performance monitoring.

hawleyal4• 13 years ago

JAX-RS still has the same problem with nesting and redundancy, doesn't fit the word "micro" or draw parallels with Sinatra.

pron6• 13 years ago

To quote another commenter, here's JAX-RS code:

  @Path("/hello")
  public class HelloWorld {
    @GET
    public String get() {
      return "Hello World";
    }
  }

Seems very Sinatra-like to me.

hawleyal4• 13 years ago

Somehow having that much nesting and redundancy doesn't fit the word "micro" or draw parallels with Sinatra.

Sinatra:

  get '/hi' do
    "Hello World!"
  end

Spark:

  public class HelloWorld {
     public static void main(String[] args) {      
        get(new Route("/hello") {
           @Override
           public Object handle(Request request, Response response) {
              return "Hello World!";
           }
        });
     }
  }

tga2• 13 years ago

All the nesting and redundancy come from Java itself. Verbose as it may be, after you use any language for a while you will see right through the syntax and it will not add (much) cognitive load to your work.

I think the value here is in having a micro framework that allows you to put together a web app without having to juggle a horribly complex abstraction hierarchy for even the simplest of tasks.

hawleyal4• 13 years ago

Syntax is what makes the framework micro.

Following your point about the cruft being from the language, Spring MVC is as "micro" as Spark. In fact, it is shorter.

Spring MVC:

  @Controller
  public class HelloController {
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public @ResponseBody String hello() {
      return "Hello World!";
    }
  }

Spark:

  public class HelloWorld {
     public static void main(String[] args) {      
        get(new Route("/hello") {
           @Override
           public Object handle(Request request, Response response) {
              return "Hello World!";
           }
        });
     }
  }

crucini• 13 years ago

All the nesting and redundancy come from Java itself

Hmm. How about:

    public String GET_hello(Request req) {
      return "Hello World";
    }

The framework would use reflection to build the routing map.

ShabbyDoo• 13 years ago

I had looked at Spark a couple of weeks ago. I'm looking for a lightweight service-y sort of framework which just happens to have a good HTTP service available out-of-the-box. My application does back-end processing and coordinates a bunch of data feeds, thick-client HTTP requests, background processing, etc. all together. Spark was too web-centric (not a bad thing, just not what I need). OSGi was an attempt to be what I want, but its requirement of classpath isolation (a good idea conceptually) is onerous in practice. Right now, I'm using a homespun amalgam of Grizzly, Guice, and java.util.concurrent (for thread pooling), and other stuff. I really didn't want to build my own container. I'm intrigued by Apache Karaf, but OSGi is a huge pill to swallow (If you haven't debugged OSGi classloading issues, you'd be in for a treat).

In a nutshell, I want a service lifecycle container which allows me to write small, lightweight, modular services which depend on each other. The container should provide for cross-cutting concerns like monitoring, management, configuration, logging, auditability (I have concrete definitions for these things -- they're not just abstract biz-speak to me). HTTP should be an out-of-the-box, optional module. A service which exposes another service via a RESTful interface and depends upon the HTTP service should be another. For my application, services which listen to multicast data streams are just as important interfaces to the world as JSON-over-HTTP-via-REST. I want to write the HelloWorld method body and be able to do stuff like: expose it via a RESTful interface, invoke it every N seconds, inject an interface exposing the HelloWorld contract into other services, etc. When I want to know how my HelloWorld service is performing, there's a pre-built web interface which provides New Relic-esque views. I'd like to capture audit trails of the transactional flows through my services from an origination point (HTTP call, scheduled job, etc.) so I can translate failures, poor performance, usage rates, etc. into meaningful information (I wrote a poor man's version of this myself, and it's been quite useful).

Does anything like this exist? I sure can't find it. Modern JBoss (now Wildfly) might actually be closer to my requirements than I think. Perhaps I should look at the work they're doing on Version 8.

pron6• 13 years ago

Using Grizzly/Netty as the core comm component seems like a good idea. Jersey integrates will with Grizzly, I think.

Dropwizard packages together Jersey on top of Jetty with good monitoring, but doesn't take care of other stuff like multicast. Nothing prevents you from adding Netty/Grizzly into the mix, though.

Actually, the modularity, composability and cross-cutting concerns you mention suggest Spring – not lightweight by any means, but neither are your requirements :)

I think you can even use Jersey with Spring: http://www.infoq.com/articles/springmvc_jsx-rs

cgh2• 13 years ago

Hate to say it but Karaf does fit the bill. Use the right mvn plugins and it's mostly just boilerplate. I work with it every day and it's generally not the painful experience you think it is.

Xorlev2• 13 years ago

I've been using Dropwizard. It provides a nice way to lifecycle manage other objects, so I've used it as a platform for Thrift services with Jersey resources serving debugging information.

It's kind of a bastardization, but we have a pretty good mix of HTTP and not, so it's nice to standardize.

bhauer• 13 years ago

For what it's worth, Spark performs quite well in terms of request routing when compared to other JVM frameworks of various sizes [1].

[1] http://www.techempower.com/benchmarks/#section=data-r6&hw=ec...

habosa• 13 years ago

This is fantastic. I know a lot of programming languages and I love them all for different reasons, but I think I am most productive and most likely to produce error-free programs in Java. All the verbosity that people hate is a feature to me, I know exactly what my program is doing.

However, I have done 95% of my web development in Ruby due to the Sinatra and Rails frameworks. The developer experience is too good to ignore. I'm hoping this can replace my Sinatra use case ... I don't think the magic of Rails could ever be replicated in Java.

rubiquity• 13 years ago

I feel like Keurig would be a no brainer as a name for a Java micro Web framework.

matt__ring• 13 years ago

I love it! Just whipped up a couple of toy web services in 15 mins using Spark. They will be part of a technical interview coding task.

True, Spark may not be better/more concise than JAX-RS, but fun to try anyway.

msgilligan• 13 years ago

Ratpack Framework is a Sinatra-inspired framework for the JVM worth noting: http://www.ratpack-framework.org

Groovy:

  ratpack {
    handlers {
      get('hello') {
        response.send "Hello world!"
      }
    }
  }

It can also be used (with somewhat less brevity) in good, old-fashioned Java.

An 0.9.0 release is expected in a few weeks and the project is undergoing rapid (and sometimes API-changing) development, but it looks very promising.

A Sinatra-inspired micro web framework for Java

Related Stories