330 lines
15 KiB
TeX
330 lines
15 KiB
TeX
\part{Layered Architectures}
|
|
\section{Architektur-Pattern}
|
|
\subsection{Layers Pattern}
|
|
\subsubsection{Erkläre die Funktionsweise + Skizze}
|
|
\begin{figure}[!htp]
|
|
\centering
|
|
\includegraphics[width=0.5\textwidth]{pics/esa_layers.jpg}
|
|
\end{figure}
|
|
\begin{itemize}
|
|
\item Client schickt eine Anfrage an Layer N
|
|
\item Layer N reicht da er nicht vollständig alleine beantworten kann, Anfragen an darunterliegenden Layer weiter
|
|
\item Eine Anfrage kann bei Bedarf auch in mehrere Anfragen an darunterliegende Layer geteilt werden
|
|
\item dies wird immer weiter fortgesetzt bis Layer 1 erreicht ist
|
|
\item dabei gehen Abhängigkeiten nur von oben nach unten
|
|
\end{itemize}
|
|
3 Schichten Architektur:
|
|
\begin{itemize}
|
|
\item Presentation Layer: serverseitig, kümmert sich um Benutzerinteraktion
|
|
\item Domain Layer: enthält Business Logik (Berechnungen, Datenvalidierung, ...)
|
|
\item Data Source Layer: Zugriff auf Daten, kümmert sich um Kommunikation mit anderen Systemen (z.B.: Datenbank)
|
|
\end{itemize}
|
|
\subsubsection{Beschreibe ein konkretes Anwendungsbeispiel}
|
|
\begin{itemize}
|
|
\item Java Enterprise Edition (JEE) Architektur bestehend aus
|
|
\begin{itemize}
|
|
\item Client Tier (Client Machine)
|
|
\item Web Tier, Business Tier (Java EE Server)
|
|
\item EIS Tier (Database Server)
|
|
\end{itemize}
|
|
\end{itemize}
|
|
\subsubsection{Nenne die Konsequenzen der Anwendung}
|
|
\begin{itemize}
|
|
\item hilft dabei eine Applikation die in Unteraufgaben zerlegt werden können, zu strukturieren
|
|
\item jede Teilaufgabengruppe befindet sich in einem eigenen Layer
|
|
\item ermöglicht bzw. vereinfacht Austauschbarkeit
|
|
\end{itemize}
|
|
|
|
\subsection{Data Access Object (DAO) Pattern}
|
|
\subsubsection{Erkläre die Funktion + Skizze}
|
|
\begin{figure}[!htp]
|
|
\centering
|
|
\includegraphics[width=0.5\textwidth]{pics/dao_pat1.jpg}
|
|
\includegraphics[width=0.3\textwidth]{pics/dao_pat2.jpg}
|
|
\end{figure}
|
|
\begin{itemize}
|
|
\item Client erstellt ein DAO Object und kann nach Entitäten suchen, einfügen, löschen, etc.
|
|
\item das DAO selbst soll keine spezifischen Elemente enthalten (Entity Manager, SQL Exception -> stattdessen DAOException)
|
|
\item dadurch entsteht eine Kapselung bei der die DAOImpl ohne den Client zu verändern ausgetauscht werden kann
|
|
\end{itemize}
|
|
\subsubsection{Beschreibe ein konkretes Anwendungsbeispiel}
|
|
\begin{itemize}
|
|
\item EntityManager in JEE
|
|
\end{itemize}
|
|
\subsubsection{Nenne die Konsequenzen der Anwendung}
|
|
\begin{itemize}
|
|
\item Zugriff auf persistenten Speicher wird abstrahiert
|
|
\item Details des Speichers werden versteckt
|
|
\item ermöglicht einheitlichen Zugriff auf Daten
|
|
\item entkoppelt Implementierung von Persistierung (Datenbank,...)
|
|
\item ermöglicht Objektorientierte Ansicht des Speichers
|
|
\end{itemize}
|
|
\subsection{Service Layer Pattern (auch Session Fassade)}
|
|
\subsubsection{Erkläre die Funktion + Skizze}
|
|
|
|
\begin{itemize}
|
|
\item Service Layer delegiert auf Business Logik und zum DAO
|
|
\item bei wenig Logik wird zumindest Transaktions, Error und Validierungshandling im Service erledigt
|
|
\end{itemize}
|
|
\begin{figure}[!htp]
|
|
\centering
|
|
\includegraphics[width=0.45\textwidth]{pics/sl_pat1.jpg}
|
|
\includegraphics[width=0.45\textwidth]{pics/sl_pat2.jpg}
|
|
\end{figure}
|
|
\subsubsection{Beschreibe ein konkretes Anwendungsbeispiel}
|
|
\begin{itemize}
|
|
\item eine Applikation mit unterschiedlichen Clienttypen
|
|
\end{itemize}
|
|
\subsubsection{Nenne die Konsequenzen der Anwendung}
|
|
\begin{itemize}
|
|
\item Reduzierung der Abhängigkeiten zwischen Presentation und Domain Layer
|
|
\item Zentralisiertes Sicherheits und Transaktionshandling
|
|
\item verbirgt vor Client Komplexität der Business Logik
|
|
\item stellt Client ein grobkörniges Interface zur Verfügung
|
|
\item gut für Remote Aufrufe geeignet (weniger Aufrufe)
|
|
\end{itemize}
|
|
\subsection{Model-View-Controller Pattern}
|
|
\subsubsection{Erkläre die Funktion + Skizze}
|
|
\begin{figure}[!htp]
|
|
\centering
|
|
\includegraphics[width=0.5\textwidth]{pics/mvc_pat.jpg}
|
|
\end{figure}
|
|
\begin{itemize}
|
|
\item MVC unterteilt eine interaktive Applikation in drei Teile:
|
|
\begin{itemize}
|
|
\item Model: Kenfunktionalität und Daten (z.B.: Datenbankzugriff)
|
|
\item View: Visualisierung bzw. User-Interaktion
|
|
\item Controller: enthält Logik und behandelt Benutzereingaben
|
|
\end{itemize}
|
|
\item Controller und View befinden sich im Presentation Layer und haben gegenseitig Abhängigkeiten
|
|
\item Model darf keine Abhängigkeiten haben (Controller und View hängen vom Model ab)
|
|
\end{itemize}
|
|
\subsubsection{Beschreibe ein konkretes Anwendungsbeispiel}
|
|
\begin{itemize}
|
|
\item Look\&Feel fokusierte Anwendung -> so kann View ohne Große Probleme ausgetauscht werden
|
|
\end{itemize}
|
|
\subsubsection{Nenne die Konsequenzen der Anwendung}
|
|
\begin{itemize}
|
|
\item Visualisierung abhängig vom Model - nicht umgekehrt
|
|
\item verschiedene Darstellungen möglich
|
|
\item einfaches Testen der Domain-Logik
|
|
\item gute Strukturierung
|
|
\item View wird leichter austausch bzw. änderbar
|
|
\end{itemize}
|
|
\subsection{Front Controller}
|
|
\subsubsection{Erkläre die Funktion + Skizze}
|
|
\begin{figure}[!htp]
|
|
\centering
|
|
\includegraphics[width=0.5\textwidth]{pics/fc_pat.jpg}
|
|
\end{figure}
|
|
\begin{itemize}
|
|
\item Client schickt Request an Front Controller
|
|
\item FC erfasst nur Infos die er für die weiter Delegation braucht
|
|
\item FC gibt Request an entsprechenden ConcreteCommand oder View weiter
|
|
\item es gibt zwei Implementierungsvarianten des Controller
|
|
\begin{multicols}{2}
|
|
\begin{itemize}
|
|
\item Servlet
|
|
\item ConcreteCommand
|
|
\end{itemize}
|
|
\end{multicols}
|
|
\end{itemize}
|
|
\subsubsection{Beschreibe ein konkretes Anwendungsbeispiel}
|
|
\begin{itemize}
|
|
\item Java Server Faces (bei Java Server Faces enthält das File zwar keinen Java Code, interagiert aber direkt mit Java Code einer Backing Bean)
|
|
\end{itemize}
|
|
\subsubsection{Nenne die Konsequenzen der Anwendung}
|
|
\begin{itemize}
|
|
\item es muss nur EIN (Front) Controller konfiguriert werden
|
|
\item da bei jedem Request ein neues Command Objekt erzeugt wird ist Thread-Safety nicht notwendig
|
|
\item da nur EIN Controller sind auch Erweiterungen durch z.B.: Decorator einfach (auch zur Laufzeit)
|
|
\end{itemize}
|
|
\subsection{View Helper}
|
|
\subsubsection{Erkläre die Funktion + Skizze}
|
|
\begin{figure}[!htp]
|
|
\centering
|
|
\includegraphics[width=0.4\textwidth]{pics/view-helper_pat1.jpg}
|
|
\includegraphics[width=0.4\textwidth]{pics/view-helper_pat2.jpg}
|
|
\end{figure}
|
|
\begin{itemize}
|
|
\item View delegiert Aufgaben an Helper (Helper adaptieren View zu Model)
|
|
\item in View befindet sich HTML Code im ViewHelper Java Code zur Aufbereitung der Daten (+ wenig HTML)
|
|
\end{itemize}
|
|
\subsubsection{Beschreibe ein konkretes Anwendungsbeispiel}
|
|
\begin{itemize}
|
|
\item bei Verwendung von JSP (Java Server Pages enthalten neben HTML auch Java Code)
|
|
\end{itemize}
|
|
\subsubsection{Nenne die Konsequenzen der Anwendung}
|
|
\begin{itemize}
|
|
\item kapselt Design-Code in View und View-Processing-Code Logik in Helper
|
|
\item steigert Wiederverwendbarkeit, Wartbarkeit und Strukturierungsqualität der Anwendung
|
|
\item vereinfacht Tests (Helperfunktionen ohne View)
|
|
\item bessere Trennung zwischen
|
|
\begin{itemize}
|
|
\item Presentation und Data Source Layer
|
|
\item Entwickler und Designer
|
|
\end{itemize}
|
|
\end{itemize}
|
|
|
|
|
|
\subsection{Dependency Injection (don't call us, we'll call you)}
|
|
\subsubsection{Erkläre die Funktion + Skizze}
|
|
\begin{figure}[!htp]
|
|
\centering
|
|
\includegraphics[width=0.5\textwidth]{pics/dependency_inj_pat.jpg}
|
|
\includegraphics[width=0.4\textwidth]{pics/dependency_inj_spring_pat.jpg}
|
|
\end{figure}
|
|
\begin{itemize}
|
|
\item Grundidee sind loose gekoppelte Objekte
|
|
\item Objekte werden mittels externem Assembler verknüpft
|
|
\item Abhängigkeiten bestehen nur auf Interfaces
|
|
\item Assembler Objekt erzeugt die Interface-Implementierungen (z.B.: durch Factory)
|
|
\end{itemize}
|
|
\subsubsection{Beschreibe ein konkretes Anwendungsbeispiel}
|
|
\begin{itemize}
|
|
\item Im Spring Context: Dependency Injection mit XML-Datei
|
|
\item alle Beans sind dort gelistet und werden verknüpft
|
|
\item Context wird geladen damit alles verknüpft ist
|
|
\item erspart Factories
|
|
\item man unterscheidet Constructor und Setter Injection
|
|
\end{itemize}
|
|
\subsubsection{Nenne die Konsequenzen der Anwendung}
|
|
\begin{itemize}
|
|
\item loose gekoppelte Objekte
|
|
\item Referenzen nurmehr auf Interfaces
|
|
\item hohe Flexibilität (Strategy, Proxy,..)
|
|
\item bessere Erweiterbarkeit und Testbarkeit
|
|
\item bei Spring kann Dependency Injection mittels XML oder Annotation erfolgen
|
|
\begin{itemize}
|
|
\item Vorteil Annotation: Typ-Sicherheit (Tippfehler passieren schnell im XML)
|
|
\item Nachteil Annotation: nicht so flexibel wie XML
|
|
\end{itemize}
|
|
\end{itemize}
|
|
\subsection{Remote Facade}
|
|
\subsubsection{Erkläre die Funktion + Skizze}
|
|
\begin{figure}[!htp]
|
|
\centering
|
|
\includegraphics[width=0.5\textwidth]{pics/rem_fass_pat.jpg}
|
|
\end{figure}
|
|
\begin{itemize}
|
|
\item bietet dem Client ein grobes Interface
|
|
\item ist Schicht die von grob zu fein-granularem Interface umwandelt
|
|
\item steigert so Netzwerkeffizienz
|
|
\end{itemize}
|
|
\subsubsection{Beschreibe ein konkretes Anwendungsbeispiel}
|
|
\begin{itemize}
|
|
\item Implementierung in Applikation um überlastetes Netzwerk zu entlasten.
|
|
\end{itemize}
|
|
\subsubsection{Nenne die Konsequenzen der Anwendung}
|
|
\begin{multicols}{2}
|
|
\begin{itemize}
|
|
\item weniger Remote Calls
|
|
\item Entlastung des Netzwerkes
|
|
\item steigert Zuverlässigkeit
|
|
\end{itemize}
|
|
\end{multicols}
|
|
\subsection{Data Transfer Object (DTO) Pattern}
|
|
\subsubsection{Erkläre die Funktion (Skizze - ein Grund für DTO)}
|
|
\begin{figure}[!htp]
|
|
\centering
|
|
\includegraphics[width=0.9\textwidth]{pics/lok-vs-remote.jpg}
|
|
\end{figure}
|
|
\begin{itemize}
|
|
\item Transportiert Daten zwischen Prozessen um Remote Methodenaufrufe zu minimieren
|
|
\item besteht aus Fields, Getter und Setter
|
|
\item fasst Daten verschiedener Objekte zusammen die vom Remote Objekt benötigt werden
|
|
\item ev. Map, Record Set, ...
|
|
\end{itemize}
|
|
\subsubsection{Beschreibe ein konkretes Anwendungsbeispiel}
|
|
% todo: Anwendungsbeispiel
|
|
\subsubsection{Nenne die Konsequenzen der Anwendung}
|
|
\begin{itemize}
|
|
\item kapselt und versteckt
|
|
\item nimmt Komplexität
|
|
\item steigert Effizienz da weniger Aufrufe über Remotegrenze
|
|
\end{itemize}
|
|
\section{Remote}
|
|
\subsection{Beschreibe die Unterschiede zwischen lokalem und Remote Interface Design}
|
|
\begin{itemize}
|
|
\item Aufrufe innerhalb des Prozesses sind schneller als über Prozessgrenzen
|
|
\item lokale Interfaces sind möglichst fein-granular während Remote Interfaces grob-granular sein müssen (weniger Aufrufe - Effizienz)
|
|
\item viele kleine Aufrufe mit wenigen Daten sind "teuer" (Latenz durch Verbindungsherstellung)
|
|
\end{itemize}
|
|
\subsection{Beschreibe drei Situationen wo Multiple Prozesse in Applikationen verwendet werden müssen}
|
|
\begin{itemize}
|
|
\item Trennung zwischen Clients und Servern in Business Software
|
|
\item Trennung zwischen server-basierter Applikationssoftware und Datenbank (SQL ist als Remote Interface designed, daher sind hier schnelle Abfragen möglich)
|
|
\item Trennung wegen unterschiedlichen Anbietern oder Programmiersprachen
|
|
\end{itemize}
|
|
|
|
\subsection{Beschreibe das folgende Diagramm. Was können wir daraus für das Design von Remote Interfaces folgern?}
|
|
\begin{itemize}
|
|
\item speziell bei "teuren" Remote Calls ist es empfehlenswert weniger Calls mit großen Datenmengen anstatt vielen Calls mit wenigen Daten zu machen
|
|
\item dieser Gedanke befürwortet auch den Einsatz von DTO um Calls und Daten zu bündeln
|
|
\end{itemize}
|
|
\begin{figure}[!htp]
|
|
\centering
|
|
\includegraphics[width=0.9\textwidth]{pics/lok-vs-remote.jpg}
|
|
\end{figure}
|
|
\section{Exception Handling}
|
|
\subsection{Beschreibe den Unterschied zwischen Checked und Runtime Exceptions in Java (inkl. Klassendiagramm)}
|
|
\begin{itemize}
|
|
\item Checked Exceptions (z.B. SQL-Exception) leiten von Exception Klasse ab und müssen behandelt werden (trows - catch)
|
|
\begin{itemize}
|
|
\item Verwendung für Probleme die durch User behoben werden können (alternative Aktion)
|
|
\end{itemize}
|
|
\item Unchecked Exceptions (z.B. NullPointerException) leiten von RuntimeException ab
|
|
\begin{itemize}
|
|
\item Verwendung für technische Probleme (User kann nichts machen außer neu starten)
|
|
\end{itemize}
|
|
\end{itemize}
|
|
\begin{figure}[!htp]
|
|
\centering
|
|
\includegraphics[width=0.3\textwidth]{pics/except_class_dia.jpg}
|
|
\end{figure}
|
|
\subsection{Beschreibe einen Use Case für eine Checked Exceptions in Java}
|
|
\begin{itemize}
|
|
\item eine Netzwerkübertragung schlägt fehl - es ist vorgesehen, dass der Applikations-User dies neu anstoßen kann
|
|
\end{itemize}
|
|
\subsection{Beschreibe einen Use Case für eine Runtime Exceptions in Java}
|
|
\begin{itemize}
|
|
\item Die Datenbank ist beschädigt - die Exception geht durch alle Layer erst mit
|
|
Implementierungsspezifischer Exception später mit Runtime ohne Stacktrace (Sicherheit) bis zum User.
|
|
\end{itemize}
|
|
\subsection{Beschreibe 5 Best Practice Beispiele beim Einsatz von Exceptions}
|
|
\begin{itemize}
|
|
\item Exceptions nicht für Programmflusskontrolle verwenden (schlechte Performance)
|
|
\item offene Ressourcen schließen (try-with-resources bzw. close im finally)
|
|
\item selbst erstellte Exceptions auch mit nützlichen Infos ausstatten
|
|
\item Implementierungsspezifische Exceptions nicht bis zum User durchwerfen (stattdessen catch + trow RuntimeException)
|
|
\item dokumentieren mit @trows im DOC, testen mit JUnit
|
|
\end{itemize}
|
|
|
|
\subsection{Beschreibe 5 Exception Handling Anti Pattern}
|
|
\begin{itemize}
|
|
\item Log and Trow (nie beides: entweder, oder)
|
|
\item Trowing Exception bzw. catch Exception (spezifischere anstatt Basisklasse verwenden)
|
|
\item Destructive Wrapping (wenn bei catch + trow = wrapping nicht die Original Exception weitergegeben wird)
|
|
\item Log and return Null (provoziert an einer anderen Stelle eine NullPointerException)
|
|
\item Catch and Ignore
|
|
\item Unsupported Operation return Null (besser UnsupportedOperationException)
|
|
\end{itemize}
|
|
\section{Logging}
|
|
\subsection{Nenne die Nachteile von debugging mit printf() sowie die Vorteile die Logging Frameworks wie log4j bieten}
|
|
\subsubsection{Nachteile printf()}
|
|
\begin{itemize}
|
|
\item Produktiv-Code wird überfüllt -> erschwert Lesbarkeit
|
|
\item Consolenausgabe wird bei vielen prints auch schnell unübersichtlich
|
|
\item im Falle eines vorzeitigen Absturzes können Ausgabedaten verloren gehen
|
|
\item Performance bei vielen Logprints
|
|
\end{itemize}
|
|
\subsubsection{Vorteile Logging mittels Framework (z.B.: log4j)}
|
|
\begin{itemize}
|
|
\item Nutzt ein einheitliches Format / Konventionen
|
|
\item logging kann optional an und ausgeschalten werden
|
|
\item durch verschiedene Log-level können Logs gefiltert erstellt werden
|
|
\item Layout für Ausgabe kann zentral definiert/geändert werden
|
|
\end{itemize}
|
|
\section{Durchlesen: JEE Web Tier}
|
|
\section{Durchlesen: JavaServer Faces}
|
|
\section{Durchlesen: Wildfly Overview} |