We have a good time with it in our work. We don't use everything it has to offer, but we do use dependency injection, Spring MVC and JMS. We write testable classes, we new them up in @Bean methods and group them together in @Configuration classes. Everything is modular - you want to use our in-process message bus? Just @Import the configuration class. You want to include Jetty and use MVC? Just @Import the configuration class, you can set a couple of properties and authentication is enabled using our in house SSO.

I think modern Spring lends itself very well to making services this way, if you can make the effort to make your application components modular, you can reuse the common stuff and have it interface nicely with the service specific code.

I still hate it. It gets in my way every day at work. I love to write small, self-contained, testable units. But our code is peppered with @SpringAnnotations. You can never be sure what’s really going to happen.

Also we don’t upgrade because teammates are afraid of breakage. Because of that, we’re now at five different versions of Spring in our app.

If I had my way, I would rip it all out.

Used it non-stop for ~3 years at Pivotal Labs. Moved elsewhere and haven't touched it once. Don't miss it in the slightest. It turns out it just doesn't actually do anything you need that you can't easily do yourself.

Not had the bad experiences that other people have had with Spring. I'm currently at a Java/Kotlin place that prefers lightweight frameworks. A lot of time has been invested in reinventing stuff Spring already does and does better.

I haven't worked with it in almost that long, but I still hate it quite a lot.

I try not to be too fussy about tech overall, but Spring is on my "I won't work with this again" list:

    1. Spring
    2. Mediawiki Visual Editor / OOJS UI
    3. Typo3

It really isn't that hard and gets even better as you incorporate tools like lombok and mapstruct. There's very little programming to do and with testing I barely bother starting my local docker containers before kicking off pipelines to try in the larger org

Spring monoliths used to be hard but that was a long time ago. My advice is this though. If you have an app written to xml spring stay that way until it's eol. Mixing annotations and xml was hairy and made things answers and documentation less applicable.

Wrt the author sounds like some poor decisions were made. Leaking Spring apis is an obvious nono. Even from v1. Second modularization is for pluggability of common apis not for you to version internal software projects. Stuff like that. If you just sit and whiteboard how you should use this thing you'll see it's not that scary. There's no doubt it's a sharp tool which is good right? If someone really needs certain beans to not show up in specific contexts they're glad it's there as a feature and easily implemented.

I'm glad spring and spring boot are available. I've looked at other alternatives and don't consider them in the same league.

I really feel like people often compare long-running projects with ill-defined/ever-changing requirements that churned through 100s of developers with some trivially small-scoped new microservice written in Y that can be written in 2 months by a single dev.

Of course the former will be a disgusting monster compared to that, but that would be the case with any 2 frameworks substituted.

Spring does a shitton of things, because enterprise business project require the strangest things. But it has a clear structure convention and if the developers actually know the platform instead of using the chimp-typewriter technique it does make other devs job easier. I am not necessarily a fan of runtime DI though, but otherwise I think it is a well-thought out framework making the easy thing really easy, and making the hard random godforsaken requirements of businesses possible — many possibly better liked framework forgets about the latter. I would be interested in what others consider a good framework (in any language)

Nonetheless, I would like to see a new framework slowly emerge making use of new java features as much as possible.

I like Spring, Spring Boot is good, and the libraries do stuff that you'll need (while maybe you don't realize whether you'll need it yet).

I'm a DI fan and I've found alternative DI frameworks to not work as well as Spring's DI. I'm only talking about Spring's annotation-based configuration.

There are also several good reasons not to like it, though: the errors can be unbelievably confusing, and it's quite hard to get a good mental model of how and why things are done in it.