Ask HN: What's your Go-to web stack for Java?

It would be https://quarkus.io for me

1. The low memory footprint.

2. Hot reloading (in dev mode) is awesome.

3. Plenty of modules. (https://code.quarkus.io)

4. Compile-time wiring, (unlike Spring's runtime wiring).

5. Fast startup (Kubectl deploy restart comes out in less than a sec).

6. Qute template engine is really nice, (Yes we use template engines to render UI).

7. 'Sponsored by Redhat' is icing on the cake. (Make it easy to convince senior mgmnt)

8. Dev-ui,

9. Shallow stack traces (Compared to Spring's)

10. Sane standard api's

etc. all deserve a praise and makes development a walk in the park. Our devs couldn't be happier with choosing Quarkus as go-to framework for all our new projects.

When I was in college (~2009), I built a blog engine[0] on Java EE. It's still running[1], and here's what I built it with:

Payara[2]: I tried Glassfish, JBoss (Wildfly), and possibly others back in the day, and I found Glassfish the easiest to work with. It was still kinda buggy, but was good enough. When I saw that someone forked it, I gave it a go, and liked it better.

Postgres: Because it's Postgres. In the past few years, I've been loving its full text search and trigram features.

As for actual frameworks, servlets and JSPs run like bats out of hell. I've used Struts and Spring at some jobs over the years, but I don't have any particular attachment, and wasn't at those places for any appreciable amount of time.

[0]: https://github.com/theandrewbailey/toilet

[1]: https://theandrewbailey.com/

[2]: https://www.payara.fish/

Relevant: "Ask HN: What stack would you use to build a CRUD web app on the JVM today?"

2015: https://news.ycombinator.com/item?id=10302879

2021: https://news.ycombinator.com/item?id=27004728

1) Vert.x (https://github.com/eclipse-vertx/vert.x) - Reactive framework (think Node.js on steroids) built on top of Netty with awesome HTTP and JDBC support. I use this to build anything that's performance sensitive or cost to serve is important.

2) Spring IoC / spring-context / spring-beans (https://docs.spring.io/spring-framework/docs/current/referen...): Spring is still pretty awesome for dependency injection. You only have to import what you need. Also a fan of Spring Boot but you need to be pretty opinionated about disabling auto-configuration or just pulling in what you need. Injecting whatever Spring library you need becomes pretty straightforward after that.

If you're going to adopt any of these technologies though, your team needs to be able to look under the covers when things go wrong or you need to do something sufficiently custom.

https://micronaut.io/ - low memory foot print, AOT first approach, catch most of the errors at compile time and highly productive.

Spring Boot: is my go to for REST APIs or workers

https://spring.io/projects/spring-boot

Spring Batch: for async/batch work

https://spring.io/projects/spring-batch

I really prefer Bootique as an alternative to Spring Boot: https://bootique.io/ Simpler, smarter, very easy to customize.

For higher loads I pick Vert.x.

Other than that, it's almost always 3 J's: Jetty, Jersey, Jackson.

I’d probably use Wicket unless the FE had to be latest flavor JavaScript framework.

Springboot (batch, web, rest) / Angular(at work) and React(personal)