Guten Morgen,

 

ich soll (in Java) eine Kostenberechnung bestehend aus ca. zwei dutzend Formeln implementieren. Je zwei der Formeln gehören zusammen und stellen den Ist- bzw. Soll-Wert eines Kostenpunkts dar. Im Businessprozess ist die Berechnung von Soll- und Ist-Werten (zeitlich) getrennt, d.h. wir berechnen erst die Soll-Werten, es passieren weitere Schritte, wir berechnen die Ist-Werte.

Mein erster naiver Ansatz wäre, dafür einen Service zu schreiben, der Methoden für die ganzen Formeln enthält. Was dann ungefähr so aussieht:

 

class Service{

  calculatePlannedX() {}
    
  calculateActualX() {}
    
  calculatePlannedY() {}
    
  calculateActualY() {}
  
  calculatePlannedZ() {}
    
  calculateActualZ() {}
}

 

Das sieht schon bei 3 Formelpaaren unübersichtlich aus und mich gruselts bei der Vorstellung, damit arbeiten zu müssen.

Das Trennen in einen Soll-Service und einen Ist-Service machts nur marginal besser. Das Trennen in Services für die Formelpaare macht zwar die einzelnen Services schön klein und übersichtlich, ist aber in der Benutzung ein Graus.

Ich suche jetzt nach Strategien/Entwurfsmustern, die das Ganze übersichtlicher machen. In der Benutzung am Ende (d.h. beim Berechnen der Kosten im Businessprozess) soll es so einfach wie möglich sein.

 

Hat jemand ne Idee, wie ich dieses Problem lösen könnte?

 

 

 

 

 

 

Ich persönlich würde aus jeder Berechnung eine eigene Klasse machen. Du hättest dann Klassen wie PlannedX, ActualX, PlannedY, ActualY, etc. Dadurch wären die Berechnungen schon mal isoliert und lassen sich testen. Beispiel:

public class PlannedX {
    public int calculate() {
        return 123;
    }
}

(Syntaxfehler seien mir verziehen. Ich hab schon lange nicht mehr mit Java entwickelt.)

public class X {
    private final PlannedX plannedX;
    private final ActualX actualX;
  
    public X {
        this.plannedX = new PlannedX();
        this.actualX = new ActualX();
    }

    public int getPlanned {
        return this.plannedX.calculate();
    }

    public int getActual {
        return this.actualX.calculate();
    }
}

Damit man nicht etliche Male sowas schreiben muss das DRY-Prinzip verstoßt, kann man daraus aus mit einem Interface und einer abstrakten Klasse vereinheitlichen aber das überlasse ich dir.

Hinterher sähe meine Lösung dann so aus:

class Service{
    Figure x = new X();
    Figure y = new Y();
    Figure z = new Z();

    int plannedX = x.getPlanned();
    int actualX = x.getActual();
    // ...
}

Und da könnte man wiederum ein Command-Pattern daraus bauen, wo dann eine Liste von Commands abgearbeitet wird aber das überlasse ich auch mal dir.

Es gibt ein allgemeines Interface:

 

public interface ICalculate{

calculatePlanned()

actualPlanned()

}

 

Du erstellst Klassen und lässt jede davon dieses Interface ICalculate Implementieren. Bspw:

 

class ServiceX implements ICalculate{

deine Resourcen kommen hierher: {...}

du bist nun gezwungen diese ICalculate Methoden zu implementieren:

 

calculatePlanned{

...

}

 

actualPlanned(){

...

}

}

von aussen kannst du nun verschiedene Instanzen des Interfaces ICalculate erstellen, diese ggf. mit den Resourcen versorgen bspw.:

 

main(){

ICalculate serviceX = new ServiceX();

ICalculate serviceY = new ServiceY();

 

nun kannst du die Methoden mit den verschiedenen Implementierungen ausführen:

 

serviceX.calctulatePlanned();

serviceY.actualPlanned();