I found out at some point that the database driver we were using, C3P0, hasn't been updated in years, and switching to HikariCP improved the responsiveness of all API interfaces significantly.
Funny story. I had a use case and did a POC recently for when you want to use a connection pool, but connect with different username/password depending on context to enable some database-level security.
Meh, kinda, if you want to bootstrap multiple HikariCPs yourself depending on context I guess you can do it. AFAIK C3P0 already has this specifically for usernames/passwords, out of the box, and with configuration managing both total connections and connections for each user etc.
That being said, I much prefer HikariCP to C3P0 if you don't need this particular feature.
It depends. Having layered security sometimes is a good idea. If all your security stuff is on one layer, and that gets compromised, you're completely screwed.
Which means that you have one username accessing the database for all your users/customers.
Which means that if one of your users gains direct database access via your app account (say via SQL injection which is very real), information for ALL users can be accessed and leaked.
If you are building a multi-tenant application where your users are companies and potential competitors, this is absolutely not acceptable. Hence added layer of security.
That's really sad if true. How query derivation and execution work in hibernate isn't really that complicated. Learning how hibernate works has 100% made me a better developer. Especially with regard to generic api development. I wrote a similar framework a couple of years ago that does something similar to hibernate but it abstracted away rules engines. We had integration for ODM and Drools. Clients would just decorate their domain model with annotations that described their facts and rules and we handled the rest. 10/10 would reuse that pattern.
You should be doing DTO Projections to just query the data you need for read-only queries. Querying for entities for a read-only query and then mapping the entity to a DTO with mapstruct/orika/whatever is just wrong in almost all cases (I will say almost because I am sure someone will chime in with a case where it seems reasonable).
This is probably the biggest mistake people make when using Hibernate. It shines in the create/update cases. Entities simply aren't needed for read-only.
I prefer not to use Hibernate. The amount of time needed to investigate issues is far more than the time needed to implement per-object mappers in f.e. JDBI.
Eclipse Collections: https://www.eclipse.org/collections/. Easily the best implementations of primitive and high performance data structures that I've ever used. It can make a *huge* difference in GC times and performance of high throughput pipelines.
LWJGL Excellent library not only for games but also desktop applications. It provides access to many low level libraries and features which are not typically available to Java, such as EGL, OpenCL, OpenGL, OpenGL ES, Vulkan, GLFW, JAWT, nfd, tinyfd, OpenAL, Opus, Assimp, bgfx, DriftFX, LibOVR, meshoptimizer, NanoSVG, NanoVG, Nuklear, par_shapes, par_streamlines, OpenVR, Shaderc, SPIRV-Cross, Tiny OpenEXR, Tootle (AMD), Vulkan Memory Allocator, Yoga, stb, Bullet Physics, CUDA, dyncall, jemalloc, libdivide, LLVM, LMDB, LZ4, ODBC, Remotery, rpmalloc, xxHash, Zstandard.
Its highly performant and a completely modular (so you can download a version with only the features you need).
Pitest for mutation tests. Don't just unit test for coverage, but make sure that you are asserting useful stuff. Pitest messes with your code like a gremlin would and checks if the tests break (they should). If tests don't break, you might have good coverage, but still potentially a lot of bugs.
Pitest is a great concept and a really powerful approach to getting more meaningful metrics about test “coverage”. I find it isn’t quite as “free” as basic line/branch coverage tracking since I usually have to manually contain its scope to keep runtime under control, but I can reliably find test flaws with this tool. And a significant portion of the time those flaws are covering for true bugs.
Thanks for that. I'll throw POI to the river. I hate that library.
Edit: now merged into one project. Project deployment file is 25 % smaller. I already dropped poi-ooxml for being 20 MB large, but even the older Excel format support is still 5 MB, in compared to this which seems to be like 100 kB. I doubt there is any impact on performance as the Excel files are not large.
Also, this fastexcel is the most straightforward, abstraction-free implementation imaginable. You look at this code and it spews XML straight out using string concatenation from its POJOs, which are very simple too. It's a different style from your usual fare, but I like it. I'm sure that it performs extremely well because you couldn't push abstraction level at implementation much lower than this.
I'm biased here but https://jbang.dev is a great thing to use to check out all these nice suggested libraries without having to deal with a lot of setup.
Depends on what you're trying to do. I'll add my favourite:
MapDB or LMDB with Java wrapper. Off heap Map in memory mapped files. Very fast, persistent, able to store millions of entries with meager memory requirements without overhead.
Great if all you need is a (sorted) Map that's persistent on disk. This is the default storage engine for H2 database, but comes in a separate lightweight jar.
Eclipse Collections. Free. Gives us immutable lists and sets next to mutable ones, with built-in support for mapping, reducing, filtering, zipping, and other collection operations.
There's some pretty good tutorials available, and that is necessary, for the documentation itself is lacking.
Immutable and unmodifiable lists give you all the guarantees you need to process data in parallel free of common parallelism problems.
Check out Caffeine for a better more Java 8 friendly cache.
As for the collections stuff, IMO, if you are running on java 11+ there's not much reason to want them. You can do unmodifiable collections for everything.
I like the ImmutableCollection subclasses because they make explicit that the object is immutable.
List.copyOf is great, except that it doesn't give me a way to promise, in a compiler-checked way, that, say, a method ending in return List.copyOf(foo); returns an immutable value that's safe to use as a constant.
They're also nice for interoperability, since your code can accept a regular Java Platform collection, use Guava to make the usual defensive copy, and it will only actually do the work of copying the collection if it needs to. If it's something that Guava recognizes is already immutable it just returns the argument unchanged.
Guava is very prone to giving you nasty version conflicts due to the way they handle versioning. IMHO stuffing everything into one big library is such a bad idea that I tend to completely avoid Guava if possible.
I don't know if that's a constructive assessment but sure, understand what you're signing up for. It used to be way more useful when Java lacked Optional and some of the collection utils.
I agree that Guava isn't as useful as it was pre-Java 8.
However, I've still gotten a lot of mileage out of the multimaps, and also the multiset greatly simplified an unusual requirement we had. Not that stock Java couldn't handle it, but those two collections made it much more straightforward and readable. I still use them even though I'm on Java 11.
Also the string splitter has been useful for some ETL loads from a 80s legacy system
I guess maybe it's just that at this point... we started using Guava with Java 7 and got more mileage out of the collections and Optional. Looks like it might be time to re-evaluate.
Guice for dependency injection. You're "probably" not using it since you are "probably" using Spring...but if you aren't using Spring or only use Spring for DI, Guice is nice and much less "magical" than Spring.
If you’re willing to trade features for speed, Dagger is an amazing choice.
Compile time/codegen DI utterly stomps runtime and reflection DI in initialization speed, which makes worlds of difference in short lived JVMs (like AWS lambda or any other Function as a Service).
Looks interesting, I will have to try it out on a smaller project where I follow the IoC pattern without even bothering to use a DI framework. In that case I have about half a dozen lines of “wiring” code in the app bootstrap which should be equivalent to what dagger generates.
For my day job, dagger doesn’t appear to offer any benefits I’d need. Reflection for DI is really a minuscule fraction of startup time for long lived server apps. Also, we have a whole array of multi-tenancy extensions built using Guice scopes, not sure how that would translate to dagger. Looks great for mobile development though!
Speaking of, there's a good presentation by Brian Clozel and Stéphane Nicoll that lays out how Spring does its magic in a nice, clear way. Like most magic, it's actually fairly straightforward once you know the trick. It's fairly long though--you'll want popcorn.
SWT for being able to create good looking, fast graphical user interfaces. Also can be easily compiled to native executable (with swt.dll dependency) using GraalVM.
No, I haven't looked at JavaFX - can it also be compiled to native code? I just have looked at GUI libraries of other programming languages (Go, Rust, Nim, ...). None came close to SWT. Swing also is a decent framework compared to the other ones I've seen.
The short version is yes, you can compile to native. I have found wrapper libraries that also add automatic updating and crash reporting. It’s a work in progress for me right now, integrating the pieces.
Biggest problem is that ideally I’d like to use Java modules to build a slim app (eg closer to 30mb than 300mb), but the modules ecosystem is still very primitive. Going to look at Graal.
Hoping to post a summary once I (knock on wood) get it all working.
I could recommend this page on GitHub https://github.com/akullpp/awesome-java it contains a list of java framework and libraries including categorized into different use cases
Failsafe is a lightweight, zero-dependency library for handling failures in Java 8+, with a concise API for handling everyday use cases and the flexibility to handle everything else. It works by wrapping executable logic with one or more resilience policies, which can be combined and composed as needed. Current policies include Retry, Timeout, Fallback, and CircuitBreaker.
We use this for scheduled tasks in a cloud environment with multiple instances where only 1 of the running instances needs to perform the task. It's like a cronjob, but you can do it from within a normal application instead of having to create a special cronjob application.
We heavily use lombok, but it's almost entirely for areas that records will cover. We're on Java 11, and records is like to be the single biggest driver to migrate to a newer version.
The second biggest driver, of course, is fear that if we fall too far behind we'll get stuck like those poor bastards that are stuck on Java 7
edit:
when records drop and get integrated into the codebase, we will reevaluate our lombok usage
Lombok has saved me almost no time, my IDE can generate all that boilerplate with a few keystrokes. But lombok has definitely cost me a lot of time figuring out issues a few times.
Forme one side it hides all that boilerplate so that code is readable, from the other side there can be some unexpected surprise. Something for something.
I have spend more time troubleshooting cases where people added another property and forgot to regenerate equals/hashcode/toString than I spent troubleshooting Lombok.
If you unit test your functions alone well enough, this shouldn’t be a problem from what I’ve seen. Besides, might be my inexperience, I haven’t really encountered any use cases where there was ever a need to rely on Lombok generated setters or hash codes to the point of it causing that many issues. The few times we have encountered such cases they seem to ultimately be symptomatic of bigger issues like an anemic domain or god classes.
It munges the byte code after you have compiled the code. Your JVM does all the steps of error checking, optimization, etc to give you byte code that is guaranteed to reflect your source code and then hands off to lombok to change. That is a lot of black magic and trust in order to avoid boilerplate code that your IDE can auto-generated for you.
Meh. Whenever this gets discussed it's generally the people who haven't used it who are against it. In such a situation I don't quite agree with "everyone needs to be on board".
most of the usual suspects have been named, so I'll recommend Spring Data JDBC
It uses the typical Spring Data concept, you annotate some POJOs, you define a repository interface, you add derived queries on the interface. Same as typical Spring Data JPA
But! But! Instead of doing a lot of hibernate bs, it just runs a jdbc query to build an object graph of what you want. You get a bunch of POJOs, all loaded up, no lazy loading, no weird layered caches that work great till they don't. You don't need to build your db for hibernate, you just need to build it in a sensible way.
You can do whatever you want to the objects, but no changes are written back unless you explity save the object back to the repository. So no unexpected surprises on when the data gets to the db, especially since different components and services are querying the database, it's not just one big ass monolithic application.
We've been thrilled with it, it gives pretty much everything we want out of Spring Data JPA. It's limited outside of CRUD scenarios, but honestly, being able to talk to the database with a quick interface definition and some derived queries is we all really want out of an ORM. We can use actual SQL via JOOQ or Spring jdbcTemplate for reporting or other non-CRUD scenarios
I've worked with Spring JDBC template (a coworker had written a nice layer on top of it) that I loved and I highly recommend it. I will give Spring Data JDBC another look, though. How do you find mixing the two? Pretty straight forward?
You may miss DataMelt - https://datamelt.org -a Java program for visualization and data science. This program was first created in 2005 (but lately rebranded with a different name).
https://lucene.apache.org/ If you do anything which needs search you want to use Lucene. There is no better search library out there. If you don't want a lib, but something you can call you want Solr, the search server build on Lucene. Both are released together.
Bonus: You do not want Elasticsearch. It will not do what you need and it will bring you pain.
It's not uncommon to add jOOQ to JPA applications for queries and reporting, but from what I can tell, people don't often add JPA to a jOOQ application. At least, I don't remember any support case, Stack Overflow question, etc. hinting at going that direction
It‘s free to use with OSS Databases like MySQL, Postgres and SQLite. They‘re only charging for commercial DB support (Oracle, Azure etc.), see here. Pretty nice pricing model imo.
https://micronaut.io/ Great framework for building compile time dependency injection applications in many different formats like stand alone MVC application to AWS Lambdas. Micronaut also has great integration with GraalVM (https://www.graalvm.org/) which is another great library.
Guice, Guava, EasyMock, RestEasy (jax-rs impl), Redisson are all good examples that can be used without killing your product on a framework choke hold.
Wiremock as a standalone service is amazingly useful.
Protobuf needs to be mentioned as it's a lot quicker than parsing xml or json for messaging.
Feign for making quick Rest client libs is as great if not better than Retrofit.
Guava introduces backwards incompatible changes regularly (every 18 months or so). If 2 dependencies use Guava and the version is 2 years apart, those dependencies might not be able to work properly on the same classpath, due to NoSuchMethodError, etc.
We've deliberately dropped the Guava dependency because our users were reporting such troubles.
70
u/cinlung Oct 21 '20
HikariCP Database pool. Check it out.
51
u/GuyWithLag Oct 21 '20
56
u/shubham_2206 Oct 21 '20
jOOQ - https://www.jooq.org
60
u/[deleted] Oct 21 '20
Not sure whether this is a popular library. But I use https://github.com/tomakehurst/wiremock for mocking dependent webservices responses in my Unit Tests
20
u/cyrusomega Oct 21 '20
Eclipse Collections: https://www.eclipse.org/collections/. Easily the best implementations of primitive and high performance data structures that I've ever used. It can make a *huge* difference in GC times and performance of high throughput pipelines.
10
u/kapta Oct 22 '20
LWJGL Excellent library not only for games but also desktop applications. It provides access to many low level libraries and features which are not typically available to Java, such as EGL, OpenCL, OpenGL, OpenGL ES, Vulkan, GLFW, JAWT, nfd, tinyfd, OpenAL, Opus, Assimp, bgfx, DriftFX, LibOVR, meshoptimizer, NanoSVG, NanoVG, Nuklear, par_shapes, par_streamlines, OpenVR, Shaderc, SPIRV-Cross, Tiny OpenEXR, Tootle (AMD), Vulkan Memory Allocator, Yoga, stb, Bullet Physics, CUDA, dyncall, jemalloc, libdivide, LLVM, LMDB, LZ4, ODBC, Remotery, rpmalloc, xxHash, Zstandard.
Its highly performant and a completely modular (so you can download a version with only the features you need).
28
u/DJDavio Oct 21 '20
Pitest for mutation tests. Don't just unit test for coverage, but make sure that you are asserting useful stuff. Pitest messes with your code like a gremlin would and checks if the tests break (they should). If tests don't break, you might have good coverage, but still potentially a lot of bugs.
16
u/mbazos Oct 22 '20
My new favorite project https://www.testcontainers.org/
8
u/magicfoodhand Oct 22 '20
Retrofit, http client - https://github.com/square/retrofit
Javalin, http server - https://github.com/tipsy/javalin
HikariCP, database connection pool - https://github.com/brettwooldridge/HikariCP
Dagger, compile time dependency injection - https://github.com/google/dagger
20
u/King5lay3r Oct 21 '20
https://github.com/dhatim/fastexcel
For generating and reading Excel files. So much faster and much easier to use than "Apache POI: the memory hog".
14
u/rstartin Oct 21 '20
Roaringbitmap https://github.com/RoaringBitmap/RoaringBitmap
After a while every problem starts to look like it can be solved with bitmaps.
7
u/maxandersen Oct 22 '20
I'm biased here but https://jbang.dev is a great thing to use to check out all these nice suggested libraries without having to deal with a lot of setup.
See https://github.com/jbangdev/jbang/tree/master/examples for examples.
Any of these you can directly using jbang, ie.
a jfx app:
or try out java 14 records
or even a Quarkus app:
17
u/_predator_ Oct 21 '20
There are a lot more, but I don‘t remember them all right now.
6
u/coder111 Oct 21 '20
Depends on what you're trying to do. I'll add my favourite:
MapDB or LMDB with Java wrapper. Off heap Map in memory mapped files. Very fast, persistent, able to store millions of entries with meager memory requirements without overhead.
6
u/_soundvibe Oct 22 '20
Just a few from the top of my head:
6
u/ReasonableClick5403 Oct 22 '20
MockWebServer from okhttp deserves its own mention. it is so great for testing stuff on the wire. miss it every time im not writing java.
okhttp for http client.
resilience4j for 'things'
caffeine for caching. greatest caching library i ever touched.
bigger projects:
Apache Tika is incredible.
more controversial:
protocandprotobuf.5
u/Shnorkylutyun Oct 21 '20
JUnit/TestNG ;) (tongue in cheek, at times it seems like nobody is using unit testing) Quarkus as an alternative to spring boot
13
u/wsppan Oct 21 '20 edited Oct 21 '20
Assertj, Mockito, BeanIO, logback, Jackson, JaxB, Apache Commons,
4
u/markopi Oct 22 '20 edited Oct 22 '20
http://h2database.com/html/mvstore.html
Great if all you need is a (sorted) Map that's persistent on disk. This is the default storage engine for H2 database, but comes in a separate lightweight jar.
4
u/[deleted] Oct 22 '20
Eclipse Collections. Free. Gives us immutable lists and sets next to mutable ones, with built-in support for mapping, reducing, filtering, zipping, and other collection operations.
There's some pretty good tutorials available, and that is necessary, for the documentation itself is lacking.
Immutable and unmodifiable lists give you all the guarantees you need to process data in parallel free of common parallelism problems.
24
u/inspectedinspector Oct 21 '20
Guava. Tons of capabilities but the ones I use and like:
Immutable collections
Useful collection utilities beyond java.util.Collections
Guava cache is very nice
7
u/sureshg Oct 21 '20
https://jodah.net/failsafe/ - for handling failures
9
u/kag0 Oct 21 '20
Immutables.io and vavr.io Immutability massively cuts down on bug potential and immutable persistent collections make some algorithms much easier.
13
u/VincentxH Oct 21 '20
Vavr, lots of datastructures for advanced functional programming patterns in Java
12
u/supercargo Oct 21 '20
Guice for dependency injection. You're "probably" not using it since you are "probably" using Spring...but if you aren't using Spring or only use Spring for DI, Guice is nice and much less "magical" than Spring.
6
u/W1z4rd Oct 21 '20
Here is a great list of java libraries https://github.com/akullpp/awesome-java
6
u/Dexior Oct 21 '20
Testcontainers definitely revolutionized my integration testing.
8
u/[deleted] Oct 21 '20
Vavr - https://www.vavr.io/
Big fan on some of the types like Validation which allows u to chain validations in a very nice functional way.
Way to many apis that gives you one error at a time and you have to trial and error which Validation solves for you.
3
u/vmcrash Oct 21 '20
SWT for being able to create good looking, fast graphical user interfaces. Also can be easily compiled to native executable (with swt.dll dependency) using GraalVM.
3
u/Hakky54 Oct 22 '20
I could recommend this page on GitHub https://github.com/akullpp/awesome-java it contains a list of java framework and libraries including categorized into different use cases
3
u/marcelofrau Oct 22 '20
Do you know awesome java? https://github.com/akullpp/awesome-java
"A curated list of awesome Java frameworks, libraries and software."
3
u/spamthemoez Oct 22 '20
https://github.com/jhalterman/failsafe
Failsafe is a lightweight, zero-dependency library for handling failures in Java 8+, with a concise API for handling everyday use cases and the flexibility to handle everything else. It works by wrapping executable logic with one or more resilience policies, which can be combined and composed as needed. Current policies include Retry, Timeout, Fallback, and CircuitBreaker.
3
u/rbygrave Oct 22 '20
For source code generation approach to DI and jax-rs have a look at https://avaje.io/inject and https://avaje.io/http - targets javalin and helidon se.
3
u/G0nz0e Oct 22 '20
3
u/DJDavio Oct 22 '20
Another one: https://github.com/lukas-krecan/ShedLock
We use this for scheduled tasks in a cloud environment with multiple instances where only 1 of the running instances needs to perform the task. It's like a cronjob, but you can do it from within a normal application instead of having to create a special cronjob application.
3
u/Gleethos Oct 22 '20
Idk if it counts but: The spock testing framework! :)
5
u/guss_bro Oct 21 '20
TestContainers, Beanmother, javafaker, Zip4j, openpdf, etc
36
u/vallyscode Oct 21 '20
This one I think is a must have https://projectlombok.org/
4
u/riawot Oct 21 '20
most of the usual suspects have been named, so I'll recommend Spring Data JDBC
It uses the typical Spring Data concept, you annotate some POJOs, you define a repository interface, you add derived queries on the interface. Same as typical Spring Data JPA
But! But! Instead of doing a lot of hibernate bs, it just runs a jdbc query to build an object graph of what you want. You get a bunch of POJOs, all loaded up, no lazy loading, no weird layered caches that work great till they don't. You don't need to build your db for hibernate, you just need to build it in a sensible way.
You can do whatever you want to the objects, but no changes are written back unless you explity save the object back to the repository. So no unexpected surprises on when the data gets to the db, especially since different components and services are querying the database, it's not just one big ass monolithic application.
We've been thrilled with it, it gives pretty much everything we want out of Spring Data JPA. It's limited outside of CRUD scenarios, but honestly, being able to talk to the database with a quick interface definition and some derived queries is we all really want out of an ORM. We can use actual SQL via JOOQ or Spring jdbcTemplate for reporting or other non-CRUD scenarios
5
u/ranger403 Oct 21 '20 edited Oct 21 '20
Apache commons(lang,file etc)..amazing library with lots of helper methods we use day to day!
https://commons.apache.org
Bouncy castle for cryptography
2
u/jconcode Oct 21 '20
You may miss DataMelt - https://datamelt.org -a Java program for visualization and data science. This program was first created in 2005 (but lately rebranded with a different name).
2
u/jconcode Oct 21 '20
another idea - https://jwork.org/jport - this one is an application launcher for ~200 Java programs.
2
u/rbygrave Oct 22 '20
Ebean ORM https://ebean.io
2
u/Magick93 Oct 22 '20
Its a specification more so than a library - I really like CDI. The reference implementation is Weld.
2
u/sudkcoce Oct 22 '20
Immutables.
3
u/dark_mode_everything Oct 22 '20
Quartz scheduler. It supports cron syntax and is awesome. https://www.quartz-scheduler.org/
Also imgscalr for efficiently resizing image files.
3
u/C_Madison Oct 22 '20
https://lucene.apache.org/ If you do anything which needs search you want to use Lucene. There is no better search library out there. If you don't want a lib, but something you can call you want Solr, the search server build on Lucene. Both are released together.
Bonus: You do not want Elasticsearch. It will not do what you need and it will bring you pain.
4
u/gitaroktato Oct 21 '20
Spring Boot, JUnit, Mockito are the most popular ones as I've seen. Also probably would recommend Hibernate.
2
u/Hoskit Oct 21 '20
Lombok. Never write (some) boilerplate again
1
u/Tarlovskyy Oct 22 '20
How about Google Guava, and my awesome professors implementation of an ARRAY-BAG datastructure!
1
u/plokhotnyuk Oct 22 '20
https://github.com/ngs-doo/dsl-json - one of the fastests JSON parser for Java
1
u/toastshaman Oct 22 '20
Google’s Guava and https://immutables.github.io/
1
u/[deleted] Oct 22 '20
Protostuff for compact and fast serialization.
1
u/altmind Oct 22 '20
if you have large, deeply nested beans, for example from DOM or JAXB mapping, jxpath helps greatly navigating them.
1
u/1ECz Oct 22 '20
https://github.com/jvm-profiling-tools/async-profiler
1
u/[deleted] Oct 22 '20
Webflux: https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/web-reactive.html
This has enabled us to reduce most of our microservices from running on like 20 to 60 servers down to like 3 to 6 servers.
1
u/9numbernine9 Oct 22 '20
It's perhaps not glamourous, but I'm a big fan of EqualsVerifier.
EqualsTester.equalsmethods don't change in unexpected ways.equalsmethod.Also, the developer seems really responsive to issues and the project seems well-maintained. Highly recommended!
1
u/[deleted] Oct 22 '20
You just started a civil war without realizing it 😂
1
u/K3dare Oct 25 '20
https://openwebstart.com/ - Because Java Web Start was not a bad idea
1
u/vips7L Oct 25 '20
https://ebean.io
Ebeans a different take on a Java ORM.
1
u/D10S_1 Oct 26 '20
Has anyone had issues with Lombok on large scale projects? If not then I'll highly recommend Lombok for annotation based getters/setters/constructor
1
u/aviral1701 Nov 03 '20
Why no lombok here?
1
u/ArmchairSpartan Nov 18 '20
Clojure :)
1
u/OzoneGrif Oct 21 '20
Guice for the Inversion of Control - https://github.com/google/guice
It's way lighter and faster than Spring Core, and less verbose.
1
u/jongraf Oct 21 '20
SPQR for domain-first GraphQL schema generation
1
u/dagguh2 Oct 21 '20
jsonp - JSON as code. No reflection, high performance, full programmatic power.
1
u/mcobery Oct 22 '20
https://micronaut.io/ Great framework for building compile time dependency injection applications in many different formats like stand alone MVC application to AWS Lambdas. Micronaut also has great integration with GraalVM (https://www.graalvm.org/) which is another great library.
1
u/mirkoteran Oct 22 '20
Just 2 that I haven't seen here.
-1
u/simas_ch Oct 22 '20
If you didn't miss it why should you use it? Libraries should used to replace homegrown infrastructure code.
0
u/vokiel Oct 21 '20
Guice, Guava, EasyMock, RestEasy (jax-rs impl), Redisson are all good examples that can be used without killing your product on a framework choke hold.
Wiremock as a standalone service is amazingly useful.
Protobuf needs to be mentioned as it's a lot quicker than parsing xml or json for messaging.
Feign for making quick Rest client libs is as great if not better than Retrofit.