I am currently preparing a presentation for my software engineering class, in which I want to present the idea of package dependency management in Java on the example of "radial encapsulation" (http://edmundkirwan.com/general/radial.html).

In order to give my course a more relatable introduction to this topic, I would really like to compare the idea of radial encapsulation to other common Java package dependency management strategies. However, I am having a really hard time finding any fixed strategies at all. Most of the time, I only get to some best practices, but I would really like to give a comparison, not a bunch of ideas which might be applicable for package dependency management at all.

As a mainly C++-developer, I was thinking about something like precompiled headers as a comparison to radial encapsulation, as it serves as a tool to manage dependencies as well.

The fact that I am not really familiar to the java naming conventions and the java world in general might be a reason I can't find any suitable resources.

Are there any Java developers who might be able to point me to papers which display some strategies in the Java world?

Thanks a lot in advance!

  • Dante has described them well – Basilevs Dec 4 '16 at 17:26
  • Dante? Is that an author of a useful book regarding this topic? Or, if it is one, could you provide me a link to the article? – Sossenbinder Dec 4 '16 at 17:44
  • 1
    Your search might be easier if you realise that there are a lot of terms that are used to describe this organization pattern. @Basilevs has pointed out "onion architecture" in his answer. There's also "clean architecture" and "hexagaonal architecture", and probably lots of other similar terms too. The core idea of making sure your dependencies all point out from your central module is a very common one, to the point that the "dependency inversion principle" that you use to achieve it is commonly cited as one of the major principles of OO design (e.g. in the "SOLID" principles). – Periata Breatta Dec 5 '16 at 7:24

Most Java projects depend on modules to manage dependencies. As Java did not have module support until recently, application containers, build systems and frameworks handled modularization themselves, each in a different manner. Examples of module providers are Maven, OSGI, Java EE implementations, etc.

As there are tons of different module systems, no common definitive documentation was possible. Projects just followed specific recommendations for their main framework.

Once modularized, application usually follows some generic best practices for dependency management. For example, onion architecture on modular level.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.