Using Java for a web application in 2023

I highly recommend either Grails, Spring Boot or Micronaut. There are several others, but they lack documentation, has confusing documentation or is over-engineered. Of these 3, Grails is convention over configuration, and the two others configuration over convention. Micronaut is the most performant and use least memory.

Grails has GSP templates, while Spring Boot and Micronaut supports several, but I prefer either Thymeleaf or JTE templates.

Grails and Spring uses Hibernate, which is fantastic to work with. Micronaut has its own orm, which is really fast. In Grails Hibernate is abstracted into something named GORM, Spring Boot's Hibernate abstraction is named Spring Data. Spring Data is more polished than GORM. They're both very well documented and easy to use.

They are all very easy to use with other excellent Java tools/libraries, Kafka, Pulsar, Neo4j and so on.

If time to market is your thing, pick Grails. (This is what I care most about)

If performance (web scale) is your thing, pick Micronaut.

If best documented is most important, pick Spring Boot.

Grails is an abstraction of Spring Boot, basically you can do everything Spring Boot can. But Grails makes Spring Boot a lot easier, especially for inexperienced developers.

Honestly hacker news is the wrong place to ask questions about Java. There is lots of biased opinions with little experience using Java.

Java web applications I’d describe as “boring technology” if you want typical rest applications with SPA frontend or a full stack server side rendered (SSR) app. By boring I mean it works with little fuss or churn.

Depending on your scale/budget they’re a bit more expensive to host due to JVM memory requirements but performance is good. Not a Java issue but a issue if you choose a language other than JavaScript for the frontend is you need to up skill frontend devs with the Java build tools/templating libraries and most frontend devs will have a bias against Java as it’s been bashed by lots of people who haven’t used it, it’s not sexy and they think of Java aplets from the 2000s.

Everything is already running on Java in 2023.

Many of the applications you use day to day, are backed by a Java backend. Netflix/Much of AWS/Zillow/LinkedIn/Indeed/Much of Google

By many metrics it's an excellent choice, but I kind of loathe working with it. However, if you don't mind living in IntelliJ it's significantly better. For example, there's a ton of stuff that doesn't exist, except in IDEland like basic formatting support (this blows my mind). You'll also want an IDE to help you refactor since there's a ton of boilerplate cruft and footguns to avoid. Nonetheless, library support for most business use cases is nearly unparalleled, performance is strong if you can deal with GC and there's a million Java developers to hire from.

Hacker News is very biased towards the cool new thang. But if you look on StackOverflow Developer Survey 2022, Java is one of the top languages that professional devs actually use in their day to day — far more than Go, Rust, Zig, Elixir, and so on, the more trendy languages that get talked about a lot.

The main advantage of Java in my mind is how old, mature, and stable the ecosystem is. Everything has a library for it.

Also, if you later decide to use a cooler/more expressive language, you can actually keep your Java code and use one of the other popular JVM languages with interop. (Scala, Kotlin, Clojure)

Unlike many others here, I would highly recommend writing backend services/APIs on the JVM, with the caveat that you use Kotlin, not Java. Every server project I've started in the past 3-4 years has been Kotlin, and I have never been more productive. Last year I switched from JS SPA (I preferred Vue to React) to HTMX and Jte templates and it was like adding a turbo boost to an already-humming engine.

Second point, while the frameworks can be helpful (Spring, VertX, Micronaut, Quarkus, etc) you don't actually need one. Ktor or http4k as your http/routing engine (& client), jooQ for DB access, H2 as a caching database if necessary -- these will take you a long way.

The only downside I experience is fewer deployment options -- can't natively deploy to Fly.io, Railway, etc except via Docker. With that said, setting up a simple VPS with Adoptium JVM is pretty easy. Hope this helps -- good luck!

The Java frameworks are "modern". They're common to use in new projects, and the Javascript frameworks often mimic them.

That said, I'd honestly start by ignoring the common frameworks and just use something like Jetty embedded to create some API endpoints.

There's a lot of learning required for the common frameworks like Spring Boot. Browse the documentation and you'll see there's a lot there. Plus, they tend to be a debugging challenge for new people due to use of reflection and the like.

While I love Java for backend, API, DB integration, and a bunch of other stuff, it's not a full stack technology.

What's your web front end going to be? Do you have something in mind which can make clean calls to a Java backend?

If so then Java remains a safe, trustworthy choice, and is relatively productive once you know it reasonably well. As per other commentors, Spring Boot is a good framework.

Unless you want a job, there are more lightweight/interesting frameworks than Spring/Boot. e.g. Javalin+JDBI, Quarkus, Micronaut.

It's 2023, it still just works and much of the internet/world runs on top of it. Take it as you wish :)

Spring Boot/Spring MVC/Thymeleaf/htmx. Use the spring dev tools for autoreload.

If you're looking at Java, I highly recommend taking a look at Kotlin. I've worked with Java for far too long and my main project now is Kotlin with Spring Boot. It's a fairly powerful combination and a joy to write in.

I am preparing to return to the JVM, this time experimenting with Eclipse Vert.x

Recently there is a trend back from SPA to server side rendering to avoid complexity, which isn't needed for most kind of apps. Htmx is a good addition in this scenario, which describes ajax calls as html attributes. You may have a look at bootify.io for generating such an application setup. Every language has it's pros and cons, Java has some overhead here and there but very mature and lots of libraries.

While I would highly highly recommend against it there is GWT, & Vaadin.

They transpile java code to JavaScript, HTML, and css. They are tightly coupled to their RPC apis.

I think Java is a solid choice for a data heavy application in 2023. As many have mentioned spring boot is a man excellent choice for the Java backend . You should also take a look at JHipster. It combines the strengths of Java with a modern front end like React or Vue or anything else of your choice to make a modern front end .

I can only offer sentiment, but I really like Spring Boot. It's not perfect but it does what I want it to.

It's boring tech but it gets the work done. Recently, I have found joy deploying Lambdas using only Dagger.

Personally, I'd say that either Kotlin or Java are okay language choices (and the JVM runtime is good too), not unlike something like modern .NET. The performance is good, the type system is passable, you have bits of FP and OOP to use at your leisure, there's a rich ecosystem of a variety of libraries out there.

== ARCHITECTURE

As for the architecture, I'm still a proponent of separate back end and front end components, say, using Java for your REST/GraphQL API, and something like Vue/React/Angular for your front end (with the latter packaged in a web server of your choice, like Caddy/Nginx/Apache). In my experience, it's just simpler that way, though YMMV.

== BACK END FRAMEWORKS / LIBRARIES

As for Java itself, I'd say that Spring Boot is the boring and dependable choice, it does basically everything you might need and is not too hard to configure. Admittedly, it feels inherently enterprisey and a bit cumbersome, even though it's leaps and bounds easier than regular Spring. This is probably a good starting point: https://start.spring.io/

It will generate starter projects that you can download and open in your IDE, maybe look at the getting started guides on the offical site: https://spring.io/quickstart

Personally, I'd also look at Dropwizard, which is smaller, simpler and still good enough for many use cases, because it combines a variety of "standard" (popular) packages for Java webdev: https://www.dropwizard.io/en/latest/

It won't be as smooth as Spring Boot, but I used recently for a small side project of mine: https://blog.kronis.dev/tutorials/2-4-pidgeot-a-system-for-m...

Some folks might also enjoy Quarkus, which got some hype in the recent years: https://quarkus.io/

Those who like reactive programming, might look into Vert.X: https://vertx.io/ (it doesn't quite feel like idiomatic Java, but is interesting nonetheless)

There's also Jakarta EE (formerly Java EE, formerly J2EE), which can be okay, but personally I'd avoid it in favor of one of the more popular options.

== FRONT END FRAMEWORKS / LIBRARIES (if you want to use Java for these)

For some basic templating, Thymeleaf should be okay: https://www.thymeleaf.org/

There's also Apache FreeMarker, Apache Velocity, JSP and JSF (I've seen it used with PrimeFaces). Those might also be viable, but I've had issues, especially with the latter ones. Regardless, here's an article about some of them (for Spring): https://www.baeldung.com/spring-template-engines

If you really want to do something more interactive but still in Java, you could use something like Vaadin: https://vaadin.com/

It's okay, but in my eyes still probably more suitable for internal admin panels, rather than that many client facing applications.

Personally I'd avoid GWT, my experiences with it were only negative.

== SUMMARY

I'd say that Java is an okay fit for a back end language - if you can get JetBrains tools (IntelliJ), you're going to have a really good time with writing code, thanks to code completion, refactoring and so on. The frameworks that are out there are reasonably stable, widely used and documented. You can also get whatever JDK distributions you want, like Eclipse Temurin. Oh, also JMX for debugging and instrumentation is great, you can see every single DB query that the app does, as well as aggregate that data, maybe get flame graphs, or just look at how GC works. Integration with things like Sentry or Apache Skywalking is also great.

Using it for anything regarding front end is more risky and might be a bit more problematic. Not saying it will, just that it might - serving packaged assets for a Vue/React/Angular app from a web server directly (or maybe through a container) would probably be more simple, especially with a reverse proxy configuration.

Of course you shouldn't ... instead you should look at PHP, or Elixir, or maybe we should move it to SQLite ... hmm, maybe TypeScript is the way to go? What about Terraforming all the things - wait, what was the question? /s

Use what you are comfortable with and get the app out there. Way more important than what stack you are using. Now excuse me while I go and look at all the shiny things on HN.

Would be interesting to see how far a J2EE app will take you on this!

kotlin can do js with react!

check that out if you want to be single lang but not use js/ts.

I wouldn't recommend JVM for web in 2023, but if you really want to use it, I would at least recommend Kotlin.

It has a better syntax, more up to date tools and is officially supported by JetBrains too. It also has the Ktor framework which is really fun to work with.

The JVM is very robust and the language has improved considerably if your prior experience was a while ago. By now there are robust libraries for most things, IDE support, etc. but you’ll find odd gaps around packaging, formatters, etc. because there are so many entrenched groups with different goals who haven’t coalesced on common answers the way, say, much of the Python community has settled on Black.

The two challenges I’ve encountered basically come back to there being two distinct communities: “Java that doesn’t suck” and “Enterprise Java™”. It is very easy to get people who learned enough Java 6 to get a CRUD job at a bank or government contractor, and they’ll give you an app with a ton of snarled, fragile code and a dependency stack deep enough to make a Node developer wince. It’s harder to find good developers since on paper both of them will look the same to HR — IT or CS degree, 10-15 years of experience, AWS experience, etc. — so you’ll have more work filtering than you would with non-default languages.