by smorgusofborg on 3/29/22, 12:24 PM with 152 comments
I used Java a very long time ago, like 1.6, and I'm wondering what using Java at work in ~web backend looks like today.
What elements of your stack would you consider most important? Do most projects lean heavily on Spring Boot or something else? Which IDE? Pointers to refreshers or concise introductions you might give a new hire would be handy too.
by exabrial on 3/29/22, 3:54 PM
We're fans of CDI, it's a more polished Spring framework without the legacy weight. We're developing in Quarkus, MicroProfile, and bigger monoliths in Apache TomEE. We use ActiveMQ extensively for scaling. ( And I mean extensively... on a modest 512m server, we can push several thousand messages/s reliably to a _lot_ of topics and queues, all with delivered-exactly-once guarantees)
We avoid the fanfare of Docker, as really it's not needed for Java apps; they're somewhat self-contained anyway and it created more problems than it solved. For true isolation, we use systemd to create cgroups and chroots and prevent application escapes. For deployment, apps are one-jar'd down to a single executable, then packaged up in a .deb using the jdeb maven plugin. We stick with the unix philosohpy of using /etc/default for env variables that help the app locate their database or LDAP cluster.
by matsemann on 3/29/22, 1:54 PM
Which of course means all the old discussions: Jetty/Tomcat/JBoss/GlassFish, GSON/Jackson, Hikari/C3PO/etc, etc are now mostly moot, since most just use the Boot defaults until they need something else. Kinda nice, actually. Less bikeshedding, can get a project up and running without taking a stand on all these things.
Most clients use maven, a few gradle, some used gradle and moved back when no one could understand their config. Gradle might get a second chance now that it can be written using kotlin.
by davidjfelix on 3/29/22, 1:49 PM
* Try to use Kotlin where allowed (Maybe unpopular and bad faith response given that you asked about Java, but I don't care -- kotlin's Java interop is way more seamless than Scala or Clojure to the point that its often not even noticable) https://kotlinlang.org/
* IntelliJ
* Spring is pretty popular, I've seen a lot of people using Vertx
* Square libraries like Okio, okhttp, retrofit, wire https://github.com/square
* If you're not using spring, use Dagger for DI https://dagger.dev/dev-guide/
* Overlook netflix abandonware (another unpopular opinion, I'm sure)
* Use gradle, not maven. Use kotlinscript as the config language, not groovy
by ojhughes on 3/29/22, 3:33 PM
* Testcontainers - seamless support for using Docker in integration tests [1]
* Project Reactor - nice framework for reactive programming [2]
* Executable Jars - No need to deploy a War file to a servlet container anymore. Build an executable Jar with an embedded container. Spring Boot makes this very easy
by mooreds on 3/29/22, 1:48 PM
I don't write too much code nowadays, but read a lot. From what I can see, here's the stack:
* intellij for an ide (with tons of plugins)
* prime MVC (https://github.com/prime-framework/prime-mvc) for the framework
* mybatis for SQL/queries
* java 17
I've also used dropwizard and spring. If it was a greenfield development with emphasis on developer productivity, I'd go with spring any day. Big dev community, tons of doco, a solution for any problem if you can find it.
by kitd on 3/29/22, 2:12 PM
For something a bit lighter weight, Vert.x [3] is a good option (Quarkus is based on it).
[1] - https://quarkus.io/
[2] - https://micronaut.io/
[3] - https://vertx.io/
You'll need Java 1.8+, and Maven or Gradle for the toolchain (I prefer the former). Intellij is the best IDE but I get by with VSCode.
by splix on 3/29/22, 4:05 PM
The most common: - Kotlin for most of the backend code, but Java for shared libs. We still use Java 8 for some libs which may be used in Android, that's an unfortunate reality
- Gradle for build config
- Spring for application architecture
And few things that may significantly improve your dev process, but are not so common:
- Spring Reactor (and Webflux) for processing data and requests. Takes a time to learn, but it worth it
- Thymeleaf for UI
- Spock for testing. Highly recommended for designing tests
- Testcontainers for integration tests
- Micrometer to see what's going on with your app. I.e., to export all internal metrics to use with Prometheus/Grafana/etc
For the environment
- SDKMan to manager the environment
- Gradle Application plugin or Google's Jib to pacakge your app. First prepares a Zip with all binaries, second a Docker container
- IntelliJ IDEA
- Github Actions - turns out to be the most usable CI. Though the Jetbrains TeamCity may be better for a large team
by gavinray on 3/29/22, 6:37 PM
- API Layer: Quarkus (most projects https://github.com/quarkusio/quarkus), Vert.x (small projects https://vertx.io/)
- DB: Postgres, in-memory H2 for simple stuff
- Testing: JUnit 5, Testcontainers to automatically start + stop DB Docker containers with tests (https://www.testcontainers.org)
- Mocking: Mockito (https://github.com/mockito/mockito) or Mockk (Kotlin, https://mockk.io)
- Dependency Injection: CDI (built into Quarkus, for Vert.x you can initalize Weld when the app starts https://weld.cdi-spec.org)
- Build tool: Gradle with Kotlin DSL
- Other tools:
Kover: automatic code-coverage reports from JaCoCo/IntelliJ (https://github.com/Kotlin/kotlinx-kover)
Ktlint + Detekt: Kotlin linting/static analysis (https://ktlint.github.io, https://detekt.github.io/detekt)
PMD, Spotbugs, Nullaway: Java linting/static analysis (https://pmd.github.io, https://spotbugs.github.io, https://github.com/uber/NullAway)by stickfigure on 3/29/22, 4:18 PM
* IDEA
* Deploy on Google App Engine, Digital Ocean App Platform, Heroku, Elastic Beanstalk, etc - get out of the ops business entirely.
* Guice as the backbone, no Spring/Boot. I wrote a tiny dropwizard-like "framework" to make this easier: https://github.com/gwizard/gwizard but there's a laughable amount of code here, you could build it all from scratch with minimal effort. This is about as lightweight as "frameworks" get because Guice does the heavy lifting.
* JAX-RS (Resteasy) for the web API. IMO this is the best part of Java web development. HTTP endpoints are simple synchronous Java methods (with a few annotations) and you can test them like simple Java methods.
* Lombok. Use @Value heavily. Cuts most of the boilerplate out of Java.
* Junit5 + AssertJ. (Or Google Truth, which is almost identical to AssertJ).
* Use functional patterns. Try to make all variables and fields final. Use collection streams heavily. Consider vavr.io (I'll admit I haven't used it in anger yet, but I would in a new codebase).
* StreamEx. Adds a ton of useful stream behavior; I don't even use basic streams anymore.
* Guava. There's just a lot of useful stuff here.
* For the database, it really depends on what you're building. Most generic business apps, postgres/hibernate/guice-persist/flyway. Yeah, folks complain about hibernate a lot but it's a decent way to map to objects. Use SQL/native queries, don't bother with JPQL, criteria queries, etc.
* Hattery for making http requests (https://github.com/stickfigure/hattery). This is another one of mine. I make zillions of http requests, functional/immutable ergonomics really matter to me.
* Github actions for CI.
* Maven for the build. Yes, it's terrible, except for every other build system is worse. Gradle seems like it should be better but isn't. I'd really love some innovation here. Sigh.
by ta988 on 3/29/22, 2:42 PM
That would be a "modern" stack for me. If you can't use Kotlin, Java has improved a lot since 1.6 you will be pleasantly surprised.
I recommend you start an intellij (Free edition if you want to, even if I still recommend the paid one) and follow the springboot kotlin tutorial below. That will give you a good idea of what the ecosystem looks like these days.
by MockObject on 3/29/22, 3:00 PM
* IntelliJ
* Standard enterprise Java JEE 9.1 (JSP, JPA, EJB)
* Payara app server
* Twitter Bootstrap
* Maven
* Test driven development using TestNG + AssertJ
* Postgres + Liquibase for schema management
Code samples now come from https://www.baeldung.com/
by PaulHoule on 3/29/22, 1:13 PM
I haven’t been paid to work with Spring since 2013, every project I’ve worked on since has used Guice, maybe Dropwizard.
JAX-RS is the dominant paradigm for web back ends these days, particularly if you are writing single page applications.
by shaman1 on 3/29/22, 10:23 PM
Lombok
Gradle, Guava
JUnit 5, testcontainers, WireMock
Logback, Slf4j
Okhttp, Open Feign, RestTemplate
Micrometer
OpenApi, swagger
Liquidbase, jooq - db stuff
This is your run of the mill stack
Dropwizard, Vert.X seem to be less used nowadays, Spring has mostly won the show
Heard people using Kotlin, Quarkus, Micronaut but that's niche stuff
by AtlasBarfed on 3/29/22, 9:18 PM
IntelliJ for IDE (Community edition is free). #1 reason is it supports Kotlin and Groovy very well out of the box. Eclipse is still a plugin disaster, and the language support aside from Java is pretty bad, although I haven't bothered to check in a few years since IntelliJ CE was released.
Gradle for builds. It is still copy and paste setup, but at least you can do a lot more things than rigid Maven.
Groovy + CompileStatic (personally) for the actual JVM language but admittedly I haven't tried Kotlin yet. Even with closures and other improvements, base Java can't compete with either of those.
Spring Boot for your enterprisey stuff/REST services which you are likely using it for. It's such a standard at this point.
Unit tests: Spock. Spock is awesome. And very well supported by IntelliJ for autoformat, another BIG reason to use IntelliJ.
Man, web frameworks on Java that don't just use it for an AJAX service layer? Who knows.
by soco on 3/29/22, 2:30 PM
by AssertErNullNPE on 3/29/22, 2:16 PM
by biehl on 3/29/22, 1:18 PM
by mhaberl on 3/29/22, 1:53 PM
For context I do a lot of contract work mostly in banking, ecommerce and insurance.
- Spring Boot
- IntelliJ
- Gradle or Maven
- Java 8 features (for various reasons most of my clients do not use version > 8)by smallerfish on 3/29/22, 2:06 PM
If I was starting a new project I'd look at Jooby, which looks pleasant and does very well on TechEmpower benchmarks.
by jbellis on 3/29/22, 1:45 PM
ETA: actually if you haven't used it since 1.6 you'd want to find an article on Java 8 as well that covers Streams.
by vollmond on 3/29/22, 2:19 PM
* Latest JDK
* Spring Boot
* JQuery/Bootstrap
* Eclipse (with Vim keybindings plugin)
Caveats:
* If it was a personal project or only a very small team, I'd start with Kotlin
* I haven't tried IntelliJ in quite a while and would give it a shot to see if I wanted to switch off Eclipse now
by nigerian1981 on 3/29/22, 2:03 PM
by throwaway4good on 3/29/22, 2:02 PM
So maybe the frontend and deployment has changed. The rest probably not so much.
Java versions 8 and 11 are by far the most common.
Lambdas were introduced in version 8.
by cimi_ on 3/29/22, 4:08 PM
by fulafel on 3/31/22, 7:39 PM
The years long constant stream of deserialization vulnerabilities, like yesterday's Spring RCE, are also largely absent from other JVM languages.
by rvcdbn on 3/29/22, 3:44 PM
by KronisLV on 3/29/22, 1:53 PM
Nothing else seems to come close, they have a Community version, nowadays Eclipse and NetBeans both feel slow but Visual Studio Code with Java plugins lacks refactoring abilities one might expect in an IDE for non-trivial projects. Also, if you get the Ultimate package of their tools, you get all sorts of other useful tools, personally i also enjoy WebStorm and DataGrip for developing front end stuff and working with databases in a separate tool.
JDK: whatever the LTS release of JDK is at the time, based on the kind of work that i do (so JDK 17 now) https://adoptium.net/
As long as you're not stuck with JDK 8, you should be fine in regards to this. But you can definitely enjoy some speed improvements across the releases as well as new language features as well as things like helpful NullPointerException messages. Personally, i'd sometimes also look towards OpenJ9 as an alternate runtime (due to lower memory usage), but that project's future isn't very clear (at least in regards to available container images) last i checked.
As for frameworks, pick one of the following:
- Spring Boot: mainstay of the Java ecosystem, has a really large amount of integrations and the Boot version also simplifies getting up and running, about as safe of a bet as Rails for Ruby or Django for Python
- Dropwizard: probably the closest competitor to Spring Boot in my eyes, but is a more loose collection of a variety of pretty much "standard" libraries, has decent developer experience
- Eclipse Vert.X: pick this if you want to work with reactive programming, last i checked it didn't feel quite feature complete, but the performance numbers speak for themselves, even if it feels a bit niche
- Quarkus: another modern option that's tailored for the development of performant web services, got a lot of hype in conferences in the past few years
- Helidon: pretty similar to Quarkus as far as i'm aware (at least as far as the positioning in the market goes) so figured i'd also mention it
Here's a rough performance comparison if you care about that sort of stuff: https://www.techempower.com/benchmarks/#section=data-r20&hw=...
Build tools: personally, i just use whatever Docker images to base the apps on when available and something like Ansible when not. For the actual toolchain, Maven is still pretty dependable, i guess Gradle is also okay. You might occasionally run into tools like Bazel or Jib, experiences there might vary.
App servers: if you need an application server for some reason (e.g. deploy app as .war), Tomcat is still a good option. If you need the EE functionality (e.g. Java EE which is now Jakarta Java), you might need to reach for something like TomEE or Payara Server, though i haven't needed to do that for a few years at this point, since Spring Boot embeds Tomcat and that is good enough for almost all projects.
by mnkmnk on 3/29/22, 5:15 PM
by itpragmatik on 3/29/22, 3:40 PM
- Java 17
- SpringBoot 2.6.x
- Hibernate
- Maven
- MySQL or Postgres
- Liquibase
- Swagger/OpenAPI
- Docker
by seymon on 3/30/22, 6:28 AM
by omgmajk on 3/29/22, 1:24 PM
by darksaints on 3/29/22, 1:59 PM
by Hardik_Shah on 3/29/22, 1:24 PM
by ActorNightly on 3/29/22, 9:38 PM
The standard ecosystem setup is to use all the major 3p libraries for all your functionality (Jaxrs, swagger, log4j, jersey, e.t.c) While this generally works, the ecosystem is full of holes (like log4j), and crappy behavior. You get things like "javax.ws.rs.ProcessingException: Already connected", exceptions which mask underlying issues like not being able to find the endpoint, or SSL certificate error, mainstream clients for things like Redis having issues with multiple connections and unable to switch to master nodes, and so on.
The core language itself is very "dirty" (Integer vs int, requiring a class for the main function, e.t.c). The standard way annotation processors add functionality is to basically write out java files, (or in the case of the ever so popular Lombok, they hack the AST). Because of how annotation processors are run, often times an error during annotation processing with dependency injection will result in very cryptic errors, often about things that were working before that you didnt change.
And on top of everything, jdb debugger is pure garbage, forcing you to use bloated software like IntelliJ for any decent functionality.
Yes, you can learn the ecosystem and its idiosyncrasies, or you could just write the thing in Python or Node with a much more efficient workflow. Network latencies dominate the processing speed these days, and infrastructure is cheap compared to developer time.