Java – Cyclic dependency in this project design

designjavajava8object-oriented-design

I have 2 modules (containing multiple classes). Let's call them Module A and Module B. Module B has a dependency on Module A: Module B -> Module A. Now, I have created an utility class C, which A and B are supposed to use but the utility itself depends on functionality found in A and B, thus A and B also depend on C. So something like this: C <-> B -> A <-> C.

Unfortunately, I am not allowed to extract the dependency from A and B and put them somewhere else, so they have to remain untouched (except for code using the utility). Making the utility an Interface and implementing it in A and B also does not work because the implementations would also depend on A and B respectively causing again a cyclic dependency…

Is this a general design issue of how my project is designed which is unsolvable?

EDIT: adding a bit more of details.

The dependencies are in form of method calls to classes located inside the modules A and B. An extraction would be possible but it would break the initial design and also make it look weird as it makes sense to keep them where they are.

Best Answer

If C is an utility class to be reused from A and B, it should not contain any direct dependencies from A and B. That is as simple as it is.

However, if C needs a service from A (or B) to fulfill its purpose, you should define an interface for that service, make A (and/or B) implement that interface, and inject the service into C during construction:

   class C
   {
        IService _service;
        C(IService x)
        {
            _service=x;
        }
   }

   class A : implements IService
   {
       C c;
       A()
       {
           c=new C(this);
       }
   }

This way, there will be no need to extract anything from A or B into another place, you just allow C to access the functionality in A or B through the IService interface.

Related Solutions

How to Solve Cyclic Dependencies in a Visitor Pattern

What about changing the visitor interface to remove the dependency from a to b?

package pkg.a;  
public abstract ClassA extends ClassA {  
    public abstract void accept(ClassAVisitor visitor);  
   /* other methods ... */   
} 

package pkg.a;  
public interface ClassAVisitor {  
    public abstract void handleB(ClassA visitee);
    public abstract void handleC(ClassA visitee);  
}

and then

package pkg.b;
import pkg.a.ClassAVisitor;
public ClassB extends ClassA {
    public void accept(ClassAVisitor visitor) {
        visitor.handleB(this);
    }
}

package pkg.b;

import pkg.a.ClassAVisitor;
public ClassC {
    public void accept(ClassAVisitor visitor) {
        visitor.handleC(this);
    }
}

Python Program Design – Improving Design and Avoiding Coupling

There are at least two questions being asked here (arguably a lot more, so I'll have to ignore many of the little ones), but the solution to both comes down to writing a class that effectively encapsulates retrieving (your) data from (your) files. Since you specifically asked whether it should be a class or something else, in this language classes are the main data abstraction that's capable of remembering things, which is obviously necessary if you want to avoid reading the same file over and over, so that's why this should be a class.

Since you haven't told me what any of the functions in module 2 actually do after calling func1, I'm going to make up some fairly generic requirements. Let's pretend func1 reads a comma-separated value file of numbers. Say func2 gets the sum of all numbers. Say func3 gets the average and standard distribution of each row.

What you want to do is write a class that handles reading and parsing these files, and exposes methods to retrieve certain aspects of the data it finds. For instance, you might have the class' constructor take a single filename/filepath argument, so the file gets read exactly once during construction, and all method calls on the object merely manipulate the in-memory representation of the data you've already read. The important thing is that no other module should know (exactly) how this class gets its data. They should see getNums() and getStdDev() and getTotal() methods, but they probably shouldn't know whether these values come from a .csv file or an Excel spreadsheet or a website or wherever, and they certainly should not know whether that file/site is being cached or not.

If you do this right, it will be trivial to add getEigenvectors() and whatnot to module2 whenever you feel like it without even thinking about what module1 is doing. That is always the main goal of reducing coupling. This applies to pretty much every language that supports OOP.

If you need more specific help you'll have to explain more about what these functions actually do and why the generic advice I just gave is insufficient.

Best Answer

Related Solutions

How to Solve Cyclic Dependencies in a Visitor Pattern

Python Program Design – Improving Design and Avoiding Coupling

Related Topic