Wie funktioniert die 3-Schichten-Architektur?

Ein essentielles Thema in der Softwareentwicklung, ist das Modell der 3-Schichten-Architektur!

Die Drei Schichten Architektur (3 Layer Architecture, 3 Tier Architecture) ist ein Modell, bei dem man das Programm in drei Teile teilt. In eine Grafik-Schicht (Presentation tier), Logik-Schicht (Logic tier) und Daten-Schicht (Data tier). Diese bauen von unten nach oben aufeinander auf und sollen in einer Richtung Abhängigkeiten vermeiden.

So ist eine höhere Schicht immer von allen Schichten darunter abhängig, aber nicht anders herum. Die Grafik-Schicht ist abhängig von der Logik-Schicht und indirekt von der Datenschicht, die Logik-Schicht ist nur von der Daten-Schicht abhängig und die Datenschicht ist von nichts abhängig. Ändert man eine Schicht, müssen alle darüber gelegten Schichten mit geändert werden.

Verwirrt?

Ich gebe zu, es ist etwas verwirrend, denn man muss eigentlich genau anders herum denken. Auch wenn die Grafikschicht, die abhängigste von allen ist, ist es die die am einfachsten zu ändern ist. Vielleicht merkt man es sich so, dass man sagt „Die Grafikschicht ist deswegen so abhängig, da alle Änderungen an anderen Schichten eine direkte Auswirkung am Grafik-Layer haben“. Im Gegenzug kann man sagen „Die Daten-Schicht ist unabhängig, da Änderungen an anderen Schichten, diese völlig kalt lassen. Alle anderen Schichten müssen immer auf die Daten-Schicht aufbauen“.

unten gehts weiter

Drei Schichten:

Grafik Schicht – GUI

Hier werden alle Steuerelemente und grafischen Komponenten platziert. Zu dem werden die Event-Handler (Button-Click, Mouse-Over usw.) definiert. In den Events werden jedoch selber keine Berechnungen vorgenommen. Diese rufen lediglich die Funktionen aus dem Logik-Layer auf.

Logik Schicht

Hier werden sämtliche Methoden zu Berechnungen und umgesetzte Algorithmen implementiert. Jedoch werden keine Datenquellen direkt angesteuert. Braucht man Daten aus einer Datenbank, oder von Webservices usw. wird die Datenschicht angesteuert.

Daten Schicht

In der Datenschicht werden alle Methoden verankert die Daten direkt aus einer Datenquelle lesen. Dies könnten Methoden sein die mittels SQL Datenbank-Abfragen machen, Methoden welche APIs von Webservices ansteuern oder sogar Methoden welche ganz simple Daten aus Dateien (Excel csv, Textdatei usw.) lesen.

Die Kommunikation zwischen den Schichten

Die Kommunikation zwischen den einzelnen Schichten stellen die Rückgabewerte der einzelnen Methoden dar.

Ein Beispiel:

Vorab: Der Code ist exemplarisch anzusehen, dieser stellt teilweise inkorrekte Statements dar. Der Programmtext soll nur ein Verständnis für semantisch Zusammenhänge geben.

Grafik-Schicht

Es wird eine Oberfläche erstellt mit Label und Button. Wird auf dem Button geklickt, wird das aktuelle Datum errechnet und in das Label geschrieben. Anschließend werden zusätzlich alle Personen untereinander in das Label geschrieben. Dazu greift die GUI-Schicht auf die Logik zu.

[code language=“Java“]
public class GUI extends JFrame {

JLabel label = new JLabel();
JButton button = new JButton();

public GUI() {
this.add(label);
this.add(button);
this.show();
}

// Exemplarisch, als ButtonClick Event
void ButtonClick() {
Logic l = new Logic();
this.label.setText(l.getCurrentDate());
this.label.setText(label.getText() + l.getAllPersons());
};
}
[/code]

Logik-Schicht

Die Methode getCurrentDate() berechnet das aktuelle Datum und gibt es zurück. Die Funktion getAllPersons() gibt alle Personen zurück, dazu wird die Datenschicht per getAllSQLPersons() veranlasst.

[code language=“Java“]
public class Logic {
// Gibt das akutelle Datum zurück
public Date getCurrentDate() {
Date akutellesDatum = now();
return akutellesDatum;
}

// Holt alle Personen aus dem Data-Layer
public String getAllPersons() {
Data d = new Data();
return d.getAllSQLPersons();
}
}
[/code]

Daten-Schicht

Die Methode getAllSQLPersons() holt aus der Datenbank, mittels SQL, alle existierenden Personen und gibt diese Zurück.

[code language=“Java“]
public class Data{
//Holt alle Daten aus der Datenbank
public String getAllSQLPersons()
{
String sql;
sql = "select * from Person";
//wandelt alle Ergebnisse
//in String um
result = resultFromDB(sql);
return result;
}
}
[/code]

Der Zweck der 3 Schichten Architektur

Wie man sehr schön sehen kann, greift bei der drei-Schichten-Architektur immer nur die obere Schicht auf eine darunter liegende Schicht zu. So Ruft die Grafikschicht Methoden aus der Logik-Schicht auf und die Logik-Schicht Methoden aus der Datenschicht. Das heißt im Umkehrschluss, dass die Grafikschicht ohne weiteres geändert werden kann, diese muss nur wieder die richtigen Methoden aus dem Logic-Layer aufrufen.

Ändert man Methodennamen oder fügt neue Methoden der Logik-Schicht hinzu, so muss man diese auch in der Grafikschicht ändern bzw. verwenden. Das bedeutet, dass die Grafikschicht abhängig ist von der Logik-Schicht, aber nicht anders herum. Der Logik-Schicht ist es relativ egal, wo ihre Methoden aufgerufen werden und ihre Rückgabewerte ausgegeben werden.

Genauso ist es bei der Datenschicht. Werden hier Methoden zugefügt oder Methodennamen geändert, müssen diese in der Logik-Schicht geändert werden. Das heißt, die Logik-Schicht ist abhängig vom Data-Tier, aber nicht andersherum. Ergeben sich dadurch neue oder geänderte Methoden in der Logikschicht, müssen diese natürlich auch wieder in der Grafikschicht berücksichtigt werden, denn diese ist indirekt über die Logikschicht auch abhängig von der Datenschicht.