Wie kann man eine Codebasis für mehr als 10 Projekte freigeben und Schmerzen minimieren?

Ich habe eine Reihe von Anwendungen, die dieselben Daten in derselben Datenbank verwenden. Um die Redundanz des Codes zu minimieren, ist die Datenzugriffsschicht ein gemeinsam genutztes Projekt. Dies verhindert, dass jedes Projekt seinen eigenen Datenzugriff neu codieren muss, schafft jedoch auch einen großen Schmerzpunkt. Wenn ein Team die Datenschicht aktualisieren muss, müssen alle anderen Teams die Änderungen abrufen und testen, um sicherzustellen, dass sie nichts kaputt gemacht haben. Dies ist ein langsamer und schmerzhafter Prozess.

Ich habe über die Idee nachgedacht, die gemeinsam genutzte Datenschicht zu entfernen und jedes Team seine eigene Datenschicht verwalten zu lassen, aber das Problem ist, dass alle Teams immer noch auf dieselbe Datenbank zugreifen. Wenn also Tabellenänderungen vorgenommen werden, ist der Schmerzpunkt immer noch da, weil jedes Team dies tun muss Aktualisieren Sie den entsprechenden Code.

Meine Frage ist also, wie ich unsere Daten- und Zugriffsschicht so gestalten kann, dass viele Projekte aus derselben Datenquelle vertrieben werden, und den Aufwand für Änderungen an der Datenbank oder der Zugriffsschicht minimieren kann.

Die gemeinsam genutzte Datenschicht sieht ziemlich gut aus. Die Lösung zur Schmerzminimierung ist:

1. Erstellen Sie Testmodule, die eine Ausnahme auslösen (z. B. alles funktioniert nicht mehr nur als Meldung), wenn ein Test fehlschlägt.
2. Legen Sie ALLE Testmodule in einem freigegebenen Ordner ab. Ich meine, alle Testmodule von mehr als 10 Projekten müssen sich im selben Ordner befinden (oder in einem leicht verständlichen Pfad).
3. Wenn ein Programmierer die kritische Ebene bearbeiten möchte, muss er alle Tests in diesem Ordner ausführen. Wenn etwas nicht funktioniert, kann er den Code nicht festschreiben.

Auf diese Weise bin ich motiviert, eine gute Testklasse zu schreiben, wie eine echte Testklasse, wenn ich einen Teil des Codes erstelle, denn wenn meine Testklasse mit einer Modifikation explodiert, bedeutet dies, dass diese Modifikation meinen Code beschädigt. Jeder Programmierer ist also gezwungen, einen guten Test zu schreiben (wenn ich es nicht tue, kann mein Code von Zeit zu Zeit kaputt gehen). Das fehlerfreie Ausführen aller Projekttests bedeutet: "OK, Sie können ein Commit durchführen". Wenn etwas schief geht, bedeutet dies "Nein, diese Änderungen würden das System in einer Zeile x beschädigen."

Dies ist ein guter Punkt, da das Testmaterial in einem Projekt zu oft zurückgelassen wird. Die Pflege des Testcodes erfordert natürlich zusätzlichen Aufwand.

Ich habe dieses Problem aus erster Hand erlebt. Es ist schwierig und ich habe nur fünf Anwendungen integriert. Ich kann ein paar Tipps geben:

1. Entkoppeln Sie die Datenbank, indem Sie RESTful-Services für so viele Dinge wie möglich verwenden. Auf diese Weise können Sie bei Bedarf problemlos mehrere Schnittstellenversionen erstellen und Datenbankmigrationen erheblich vereinfachen.
2. Wenn der Datenbankzugriff für einige Anwendungen schreibgeschützt ist, erstellen Sie Datenbankansichten der erforderlichen Daten. Wenn Sie einen Stapelprozess durchführen müssen, um Werte zu berechnen, tun Sie dies in einer materialisierten Ansicht.
3. Denken Sie sorgfältig über Design nach. Jede Datenbankänderung wird höchstwahrscheinlich andere Anwendungen beschädigen. Benötigen alle Apps wirklich vollen Datenbankzugriff? Wenn nicht, brechen Sie sie aus, um einen Dienst zu nutzen. Entkoppeln Sie den Datenbankzugriff von einer beliebigen Logik.

Die kurze Antwort lautet, dass Sie viel Zeit in Ihren freigegebenen Code investieren müssen, um ihn so robust / solide / zuverlässig wie möglich zu gestalten.

Wie Sie feststellen, können Sie es sich nicht leisten, Ihren Bibliothekscode sehr oft ändern zu lassen.

Möglicherweise müssen Sie Ihre Datenschicht in zwei Teile aufteilen - einen Teil auf niedriger Ebene, der sehr einfache Dinge ausführt, sich jedoch nie ändert (dh den gemeinsam genutzten Code), und einen Teil auf hoher Ebene, der möglicherweise für jede Anwendung eindeutig sein muss.

Für den gemeinsam genutzten Teil auf niedriger Ebene müssen Sie wie ein Bibliotheksentwickler und nicht wie ein Anwendungsentwickler denken. Dies bedeutet viele Komponententests, eine sehr klar und gründlich definierte Anwendungsoberfläche, eine korrekte, vollständige und nützliche Dokumentation und viel Verteidigungscode - alle Eingaben sind ungültig, bis das Gegenteil bewiesen ist.

Der gemeinsam genutzte Code sollte so geschrieben werden, dass er den Anforderungen der Anwendungen entspricht, die heute den Code verwenden. Sie sollten jedoch zusätzliche Zeit investieren, um zu prüfen, wie dieser Code für das nächste Dutzend Anwendungen funktioniert, die noch nicht vorhanden sind noch vorgeschlagen. Anders ausgedrückt, der gemeinsam genutzte Code löst das allgemeine Problem, Daten für seine Verbraucher auf sinnvolle Weise verfügbar zu machen. Wenn dies gut gemacht wird, können neue Verbraucher diese Bibliothek ohne Änderungen verwenden.