Frameworks – What Are Callback Frameworks?

The next line of Effective Java is helpful in clarifying the issue:

"Because a wrapped object doesn't know of its wrapper, it passes a reference to itself(this) and callbacks elude the wrapper. This is known as the SELF problem [Lieberman86]."

It seems like a trivial thing to make sure that all references to an object are via its wrapper, but wrappers are generally injected when a need arises and their design (their entire purpose of being) is to provide a low friction way to add more functionality to an existing class. This leads to subtle bugs, like the wrapper missing the event. Or the wrapper and wrapped object both registering for the same events - leading to duplicate processing and potential concurrency issues as well. If you don't know (don't have the source code) where callbacks are registered, it may be impossible to work around this problem. Additionally, wrappers are based on "pure" composition principles and callback frameworks force a "dirty" wrapper design.

There are a couple of compromises that are to be made when using DI frameworks as far as I can see.

The most worrying for me is that your application code is usually spread between a main programming language (like Java) and XML/JSON configuration code (it is code). This means that in the case of problems with your application you need to look in two places. Often the configuration code is not easily related to the main application code.

Of course the configuration is also outside the bounds of what the compiler (and often the IDE) can check for you, meaning that it is much easier to make mistakes in this configuration than if you were writing a main class that handled the wiring. In effect this means that wiring issues are pushed from being compile-time issues to being runtime issues.

As well as splitting the application, using DI Frameworks also often mean that you use @Inject or similar within your code, instead of traditional DI techniques (CTOR interface injection in Java/C++, template injection in C++). The downside of this is that you must then use a DI framework with the application. An alternative would be to design your application without expecting a DI framework and then allow the DI framework to re-use the traditional CTOR/setter injection of your classes.

The downside to the traditional injection mechanism comes when a complex and properly encapsulation classes demands a number of other relatively complex injections at CTOR time. This is usually solved by incorporating a Builder, but it can be a pain.

EDIT:

The lads below have mentioned that Guice does not need a separate XML/JSON config. My answer really applies to my own usage of Spring.