Hallo zusammen. In dieser Aufgabe solltet ihr ein Reproduce-Framework in Anlehnung einer

Patchier-DOOP implementieren. Einige Konzepte und Java-Eigenheiten, die euch dabei helfen

werden, stelle ich euch in diesem Video vor.

Damit euer Framework dem Anwendungsentwickler eine möglichst hohe Flexibilität bieten kann,

schauen wir uns zuerst das Konzept von Abstract Factories an. Danach gibt es einige Hinweise

zum Sortieren von Listen in Java und dem Zusammenführen von vorsortierten Listen. Future-Objekte

lassen sich zur Synchronisation der verschiedenen Reproduce-Phasen verwenden und zum Schluss

gibt es noch ein paar Infos zum Extrahieren von Daten aus Textdateien.

Ein Framework, wie das von euch zu implementierende Reproduce-Framework, stellt den Rahmen für

eine Anwendung bereit. Das Framework gibt dabei den grundsätzlichen Ablauf vor, lässt

aber gewisse Details zur freien Gestaltung offen. Damit kann man dann eine Vielzahl der

Anwendungen realisieren. Auch wenn das Framework üblicherweise Standardimplementierung für

viele seiner Schritte anbietet, liegt die Stärke in der Konfigurierbarkeit. Da muss

ein Framework eine hohe Flexibilität für den Anwendungsentwickler anbieten.

Im Falle von eurem Reproduce-Framework sollen folgende Schritte dabei konfigurierbar gestaltet

werden. Die Deserialisierung der Daten, also das Auslesen der Schlüsselwertpaare aus der

Datei, die Map- und Reduce-Funktion und das Sortierkriterium, mit welchem im Zwischenschritt

die Daten für die Reducer sortiert werden. Auch wenn ihr diese Schritte vom Entwickler

frei anpassbar gestalten wollt, muss euer Framework aber trotzdem Objekte der jeweiligen

Klasse für den Ablauf des MapReduceJob instanzieren. Da ihr bei der Implementierung des Frameworks

aber die Klassen, die der Anwendungsentwickler irgendwann später mal schreiben wird, noch

gar nicht kennen könnt, greift man hier auf das Konzept einer AbstractFactory zurück.

Eine Factory ist dabei der erste Schritt zur Lösung des Problems. Ihr müsst ein Objekt

instanzieren, das zwar eine bestimmte Schnittstelle zur Verfügung stellt, dessen genauen Typ

ihr aber noch nicht kennt. Eine Factory funktioniert dabei auf die Weise, dass sie die Instanzierung

eines Objekts in eine eigene Klasse kapselt. Hier ein Beispiel dazu. Es gibt die Klasse

WordCountMapper, die die Mapperschnittstelle implementiert. Wir möchten eine Instanz von

WordCountMapper erzeugen. Die WordCountFactory kapselt diese Erzeugung jetzt in eine eigene

Methode CreateMapper, die einen WordCountMapper erzeugt und diesen als Typ Mapper zurückgibt.

Das Framework, das die Methode CreateMapper aufruft, muss in diesem Moment also noch nichts

vom Datentyp WordCountMapper wissen. Er bekommt erst mal ein beliebiges Mapperobjekt zurück

und arbeitet damit. Dem Framework muss hier aber immer noch die Klasse WordCountFactory

bekannt sein, die ja doch wieder direkt mit der Anwendung zusammenhängt. Wir haben das

Problem mit einer reinen Factory also nur etwas verschoben, aber noch nicht gelöst.

Dafür brauchen wir eine weitere Abstraktionsschicht und verwenden eine sogenannte AbstractFactory.

Hier erzeugen wir eine weitere Schnittstelle für die Factory selbst. Für unser Beispiel

gibt es neben der gerade schon verwendeten Schnittstelle Mapper also noch die Schnittstelle

MapperFactory, die die Methode CreateMapper anbietet. An der Implementierung unserer WordCountKlassen

ändert sich dabei kaum etwas. Nur unsere WordCountFactory muss jetzt das neue Interface

MapperFactory implementieren. Unser Framework kann jetzt die Schnittstelle MapperFactory

verwenden, um sich eine Instanz eines Mappers zu erzeugen und muss dabei weder von der Factory

noch vom Mapper wissen, welchen tatsächlichen Typ er dann später eigentlich in der Hand

hat. Die echte Instanz unserer Factory-Klasse braucht das Framework ja erst bei der eigentlichen

Ausführung. Dort kann sie dann beispielsweise im Framework-Konstruktor oder über eine Methode

übergeben werden. In der Aufgabe stellt die Klasse mwdrop diese Factory zur Konfiguration

dar.

Als nächstes schauen wir uns das Sortieren von Elementen in Java an. Die Standardschnittstelle

zum Vergleichen von Objekten ist Comparable, die die Methode compareTo implementiert. Die

meisten Standardklassen von Java haben dieses Interface bereits mit sinnvollen Sortierregeln

implementiert. Wie im Grundlagenvideo von Java erwähnt, stellt euch die Klasse Collections