The class's description is "Convenient proxy factory bean superclass for proxy factory beans that create only singletons."

Seriously? That's fucking hilarious.

"Added a new superclass because you wouldn't believe how hard it was to to create beans that create beans that create only singletons!"

Turtles all the way down.

I'm curious: what would you name that class?

But honestly, I'm kidding around. I'm not arguing the class is silly, or poorly named. I bet it's perfectly named. I'm not arguing the author did a bad thing here, I'm sure he or she did something awesome. All I'm saying is that the context that makes writing that class description necessary is totally hilarious.

Let's just agree on that. It doesn't mean Java sucks or Spring sucks. Big complicated projects sometimes lead to pretty wacky situations and we ought to be able to laugh at them. I'm certainly not suggesting other languages don't have the same culdesacs of lunacy.. they totally all do. Can you imagine the number of times someone's posted "Everything that's wrong with Perl in one line of code" ?

I really don't see any reason to take this stuff so seriously.

As it turns out, there was no need for the class as it has been deprecated. However, providing an abstract singleton scoped proxy factory bean is indeed convenient. If there was a need for a factory that creates AOP proxies then it would be very useful to have an abstract class that implements most of the methods for you, and create them with singleton scope. In that case, AbstractSingletonProxyFactoryBean is sensible.

It's a corner case. It was used by one class, but that was deprecated later, so this was deprecated as there wasn't really a need for the convenience class.

I take this lot of stuff seriously because I see a lot of ignorant pattern bashing by those who haven't taken the time to understand why patterns are very useful and potentially can make OOP code cleaner and easier to maintain.

I give my users vastly more value-per-line-of-code now than I ever did writing Java.

That said, I have nothing against Java or folks that enjoy doing it... but even when it was a language that I was knee deep in and stoked on, I was able to laugh at some of the shark-jumping complexity of these cartesian products of patterns that would arise.

A factory bean is a class that creates factories. You'll almost never need to create your own as you normally use the ones Spring provide for you. And with annotations, you'll likely never even notice them.

A proxy factory bean is used for Aspect Oriented Programming in the Spring framework. AOP is a fantastic way of doing OOP. Try reading up on it before you knock it. Spring uses AOP via proxies. By using proxies, you don't need to inject bytecode via CGLIB, which while a totally valid way of doing AOP, adds another dependency to your project which you may not want or even need.

Singletons are used by default by Spring, which is an IoC (Inversion Of Control) container. An IoC container is extremely useful as it fully decouples classes from one another - the container handles the coupling and you merely set things such as object creation up via annotations or configuration. One of the considerations needed to be taken into account when using Spring for object creation is to decide whether each object is created once and once only by the factory bean, or if multiple instances should be created. You usually use a singleton bean in Spring - otherwise you have to introduce tighter bean coupling with other beans, which kind of defeats the purpose of an IoC container.

A bean is a JavaBean, which is a very simple but powerful convention used to allow reusable components in Java.

So what does this do? It's a convenience class used to extend the Spring AOP framework should you need to do so without having to make changes within the Spring framework itself. Almost no application programmers will need to use it. However, if you have a very particular requirement for AOP proxy bean creation that is not currently handled by the Spring framework (unlikely) then you will indeed find it useful, and I dare say it is, indeed, convenient.

In short, ignorance is OK. But mocking something in ignorance is pretty foolish, and your foolishness is on full display here.

P.S. incidentally, Spring is now well past v2.5 and in fact the current version is 3.1.x. It helps to read the most up to date documentation when trying to understand something in a framework. The description of the class in the latest documentation now reads:

  Convenient superclass for FactoryBean types that produce singleton-scoped 
  proxy objects

I don't see anything hilarious about it.

Secondly, this is a class used to extend the Spring framework unobtrusively if it is needed. Most likely you would never need it (if you are even someone who uses Spring, which I somewhat doubt... If you are then you should really learn more about the framework you use) but there are doubtless folks who may need it at some point for some super complex or out of the ordinary project you haven't even dreamed of yet.

Only if you isolate it from all context. Within the context of how Spring is built and works, it's all perfectly reasonable. As cletus said above, if someone is going to slag Java, they should really pick something to pick on that is actually deserving.

Further, if you accept that Spring is a good idea (which in my opinion is equivalent to accepting that Java has major shortcomings that require something like Spring to overcome) then this class is likely plenty reasonable. Like other commenters have pointed out, frameworks are hard. Java makes them harder. In the context where Spring and Java are givens, I'm sure the author of the above is a very handy chap to know.

Be nicer.

[Edit: To be clear. I want to make sure there's no confusion that the point of my original comment was that the class is hilarious. Not that it's not justified, or that the author is foolish, or that Java is awful, or that Spring is awful. I don't have very strong opinions about any of those things.. other than assuming a committer on such a huge, demonstrably successful project is plenty smart and did the poor chaps who are in the unfortunate position of needing this class a great service.]

OK, maybe they're not an idiot. Maybe it's warranted. I'd say it's probably over engineered stupidity though.

Even so, the title is like pointing to a stupidly constructed house and calling it "Everything that is wrong with bricks".

  - Abstract
  - Singleton
  - Proxy
  - Factory
  - Bean
  - Interceptors

On the upside, you feel really smart once you grok all these concepts simultaneously. After a couple years this you get to brand yourself a "Java Architect".

Abstract is a pretty basic OO concept. You make an abstract class when you want it to be derived and never used directly.

Singleton is where a class can only ever create one object. Harder than it sounds.

Proxy is where the class interfaces with something else. Again, very useful. Proxies are used by Spring to implement AOP.

Factory - abstracts away the creation of objects, in other words the client object does not need to know how to create objects. It's used extensively in the Spring IoC container.

Beans are object that use simple but powerful conventions of creating reusable components in Java.

Interceptors at used by AOP.

If you use these concepts as they are intended to be used then your code will be cleaner, maintainable and a joy to work with.

Interestingly, things like @Inject came after Spring, and were inspired by Spring and a number of other containers.

Could it be all these mocking are symptom of your insecure language choice or library choice?

I seriously don't think you understand that at the core of Spring is an IoC container - it just so happens that Spring does a lot of other useful things.

So you'd rather see every project that wants to use DI, roll their own DI implementation?

On Ruby, I'm constantly at a loss on how to do logging. Sure, in Rails there's the Rails logger available pretty much everywhere. But if I'm writing a reusable library, I can't count on that. So what do I do? Demand every user of my library configure it with a logger?

The stdlib Ruby logger also has no way to fine-tune log levels by class. In a Rails app, sometimes I want debug level, but I rarely care to see each and every SQL statement. (There tend to be hacks to monkey patch around the common cases suggesting others have been similarly frustrated.) Even if I use log4r or some other logger with more fine-grained tuning, within Rails, everything will be using the same logger object, so the typical Java method of tuning by giving each class its own logger doesn't work.

Bleh. Give me SLF4J with logback any day. When writing a reusable Java library, I really have no qualms about using SLF4J.

Care to explain? Logback is easy to configure and extremely efficient

> Something as simple as wanting symbolic links in a Maven build requires a third party plugin, last updated in 2007 (maven-junction-plugin) that requires something no longer in the central repo;

If you are still using Maven it's your problem. Switch to Gradle and your life will be much better.

> No lambdas yet;

True, but if you really need them use Groovy or Scala. Groovy 2.0 is almost as fast as Java and Scala is fun.

> Type erasure in generics and the consequences thereof (eg inability to create generics of primitive types unlike C#);

True, but doesn't this lack of feature harm framework developers mostly? The same people which the article is critiquing.

> Checked exceptions;

You can just ignore them when you write new code. If you have to deal with code that throws them, just deal with them. Most of the modern frameworks nowadays don't use them.

> No function references, lambdas, etc (still a year+ away);

Groovy, Scala and the favorite kid on the block, Clojure

> Eclipse is a hot mess (IMHO). And, no, for Java at least, vim/emacs simply are no better. IntelliJ is but for some reason they insist on making it hard to make plugins as their API changes every major version. Jetbrains seems to be going out of their way to make it hard;

This is the only point for which I tend to agree. Eclipse is difficult to work with. IntelliJ on the other hand is a valid alternative. These days I mostly code in Sublime Text 2 though.

Logback != "java logging". "Java logging" is some messy combination of JDK logging, Logback, Log4j, Commons Logging, SLF4J, some cruft that fell out of Avalon or Fortress or whatever it was, etc. And then you try to use a library that uses Commons logging alongside another library that uses log4j directly, alongside your code, which really wants to use SLF4J... or you deploy your code, which uses log4j, into JBoss, which configures it's own hacked version of logj4 before your code loads, and you run into needing to figure out RepositorySelectors...

You'd be better off reading from Ludvig Prinn's De Vermis Mysteriis, Friedrich von Junzt's Unaussprechlichen Kulten and the Necronomicon. Ia! Ia! Cthulhu fhtagn! Ph'nglui Mglw'nafh Cthulhu R'lyeh wgah'nagl fhtagn!

> True, but if you really need them use Groovy or Scala. Groovy 2.0 is almost as fast as Java and Scala is fun.

> Groovy, Scala and the favorite kid on the block, Clojure

Java's upcoming lambdas will have lazily-evaluated results from its map, filter, reduce, etc lambdas. Both Scala and Clojure already have their lambdas/functions return lazily-evaluated results, but certainly not Groovy, neither version 1.x nor the just-released version 2.0.4. Groovy's closures only return strictly-evaluated results.

In fact, 2.0.4 was released only 2 weeks after 2.0.2 to fix "some important issues with generics with the stub generator, as well as several related to the static type checking and static compilation features". (Version 2.0.3 was skipped because "it was mistakenly built with JDK 6 instead of JDK 7".) It may be "almost as fast as Java and Scala" but it certainly isn't fun or production-ready.

Lastly Eclipse is THE best thing since sliced bread. I LOL'ed when you mentioned vim/emacs in the same sentence. Have you actually used Eclipse on a big code base? It's introspection is such a productivity booster. I've not used jetbrains in a decade, but nothing else out there beats it, hands down. Both in terms of speed and quality.

My tool of choice for Java is however IntelliJ, which is simply light years ahead of Eclipse (IMHO).

I agree.

Eclipse seems to always become unstable once enough plugins are installed. After a few updates and removals it ends up tipping over regularly. I suspect the underlying OSGi plugin system is a tricky thing to get right.

Intellij IDEA seems to "just work".

That said, I prefer coding in Clojure with Aquamacs but I've yet to get Clojure into a production system.

Yoxos allows the creation of eclipse profile that make it easier to have stable eclipse.

If you have a lot of eclipse users, I think yoxos is the way to go.

But I still use IntelliJ at home :)

NB: I m talking about this yoxos: https://yoxos.eclipsesource.com/

Well yes, logging. There is slf4j though. I think that works, although the fact that one needs a metaframework is... interesting.

Eclipse? I love eclipse. I used emacs every day for 2 years, IRC in emacs, news in emacs, EVERYTHING in emacs. Eventually I got sick of IMAP blocking and interrupting the world. I grew to love Eclipse because I realised I could not efficiently comprehend Java code any more without it.

Over-layering is a serious, serious problem in Java. I think I understand your point of view, but a big part of my job is performing code reviews. It really sh%ts me every time to have to jump through the Service, the ServiceImpl, then the Repository, the RepositoryImpl, the Dao, the DaoImpl and... oh, there's the fricking query. Thanks guys.

My huge problem in Java is that I always find 8 classes where 2 would do. The extra classes do serve a purpose; they fulfil stereotyped, expected roles. In some ways the boilerplace reduces cognitive overhead. In other ways, it really does not.

Personally as someone who reviews multi-million line codebases regularly for a living, I am actually terrified of hordes of new Java developers discovering lambdas or acquiring advanced generics. These things are tactical nuclear weapons of source code obfuscation in the hands of people whose judgement (through bitter experience) I no longer really trust.

Spring is not evil, but it does make life difficult because it's hard to follow references. Fortunately, whenever you see an interface Foo you normally just have to jump to FooImpl. Because it turns out that 90% of interfaces are actually not needed; except culturally, stylistically or dogmatically. Personally I think they're over-used, but that's because my observation is that most interfaces (seriously, 90% level) are implemented only once.

Agree on the checked exceptions though. That was a mistake.

I think actually there is nothing wrong with Java as a language, but without sane leadership the corporate culture of it becomes uniquely byzantine.

Is that the only thing you think is wrong?