What strategy do you use for package naming in Java projects and why? [closed]

by

For package design, I first divide by layer, then by some other functionality.

There are some additional rules:

  1. layers are stacked from most general (bottom) to most specific (top)
  2. each layer has a public interface (abstraction)
  3. a layer can only depend on the public interface of another layer (encapsulation)
  4. a layer can only depend on more general layers (dependencies from top to bottom)
  5. a layer preferably depends on the layer directly below it

So, for a web application for example, you could have the following layers in your application tier (from top to bottom):

  • presentation layer: generates the UI that will be shown in the client tier
  • application layer: contains logic that is specific to an application, stateful
  • service layer: groups functionality by domain, stateless
  • integration layer: provides access to the backend tier (db, jms, email, …)

For the resulting package layout, these are some additional rules:

  • the root of every package name is <prefix.company>.<appname>.<layer>
  • the interface of a layer is further split up by functionality: <root>.<logic>
  • the private implementation of a layer is prefixed with private: <root>.private

Here is an example layout.

The presentation layer is divided by view technology, and optionally by (groups of) applications.

com.company.appname.presentation.internal
com.company.appname.presentation.springmvc.product
com.company.appname.presentation.servlet
...

The application layer is divided into use cases.

com.company.appname.application.lookupproduct
com.company.appname.application.internal.lookupproduct
com.company.appname.application.editclient
com.company.appname.application.internal.editclient
...

The service layer is divided into business domains, influenced by the domain logic in a backend tier.

com.company.appname.service.clientservice
com.company.appname.service.internal.jmsclientservice
com.company.appname.service.internal.xmlclientservice
com.company.appname.service.productservice
...

The integration layer is divided into ‘technologies’ and access objects.

com.company.appname.integration.jmsgateway
com.company.appname.integration.internal.mqjmsgateway
com.company.appname.integration.productdao
com.company.appname.integration.internal.dbproductdao
com.company.appname.integration.internal.mockproductdao
...

Advantages of separating packages like this is that it is easier to manage complexity, and it increases testability and reusability. While it seems like a lot of overhead, in my experience it actually comes very natural and everyone working on this structure (or similar) picks it up in a matter of days.

Why do I think the vertical approach is not so good?

In the layered model, several different high-level modules can use the same lower-level module. For example: you can build multiple views for the same application, multiple applications can use the same service, multiple services can use the same gateway. The trick here is that when moving through the layers, the level of functionality changes. Modules in more specific layers don’t map 1-1 on modules from the more general layer, because the levels of functionality they express don’t map 1-1.

When you use the vertical approach for package design, i.e. you divide by functionality first, then you force all building blocks with different levels of functionality into the same ‘functionality jacket’. You might design your general modules for the more specific one. But this violates the important principle that the more general layer should not know about more specific layers. The service layer for example shouldn’t be modeled after concepts from the application layer.

More Related Contents:

  1. What is the convention for word separator in Java package names?
  2. Are there best practices for (Java) package organization? [closed]
  3. Why should java package name be lowercase?
  4. How can I solve “java.lang.NoClassDefFoundError”?
  5. Valid characters in a Java class name
  6. Java Interfaces/Implementation naming convention [duplicate]
  7. Java packages com and org
  8. Generic type parameter naming convention for Java (with multiple chars)?
  9. What is the purpose of defining a package in a Java file? [closed]
  10. What is the default package in which my classes are put if I don’t specify it?
  11. Should a “static final Logger” be declared in UPPER-CASE?
  12. What package naming convention do you use for personal/hobby projects in Java?
  13. Java Naming Convention with Acronyms [closed]
  14. How to include the Spongy Castle JAR in Android?
  15. How to compile java package structures using javac
  16. Using underscores in Java variables and method names [closed]
  17. Class name convention in java [closed]
  18. For a boolean field, what is the naming convention for its getter/setter?
  19. Java Package Does Not Exist Error
  20. Prohibited package name: java
  21. Package structure for a Java project?
  22. Java data transfer object naming convention?
  23. Extract links from a web page
  24. How to get current class name including package name in Java?
  25. Difference between Package and Directory in Java
  26. Java error – bad source file: file does not contain class x . Please remove or make sure it appears
  27. Java: Use import or explicit package / class name?
  28. Call protected method from a subclass of another instance of different packages
  29. Valid JavaBeans names for boolean getter methods
  30. Why do java source files require package declarations?

Leave a Comment