1. Einleitung
2. Was ist unsere Idee?
2.1. Wie sind wir auf die Idee gekommen?
2.2. Warum machen wir das?
3. Wie haben wir diesen Comparator umgesetzt und wofür ist er gedacht?
3.1. Wie funktioniert unser SmartComparator?
3.1.1. Die Instanziierung
3.1.2. Die Vorverarbeitung
3.1.3. Der Vergleich
3.1.4. Änderung der Sortierung
4. Wie kann unser SmartComparator eingesetzt werden?
4.1. Erzeugung per String-Array
4.2. Erzeugung per MethodNameRecord-Array
4.3. Erzeugung per MethodNameGenerator
4.4. Erzeugung per @CompareCriteria-Annotation
4.5. Erzeugung per @NamedSorts und @NamedSort Annotations
5. Haben wir getestet?
5.1. Was haben wir getestet?
5.2. Wie haben wir getestet?
5.3. Was war das Testergebnis?
5.3.1. Auswertung System 1 Linux (Oracle 1.7.0_45):
5.3.2. Auswertung System 1 Linux ( icedtea 7.2.4.3):
5.3.3. Auswertung System 1 Windows ( 1.7.0_45):
5.3.4. Auswertung System 2 Linux ( icedtea 7.2.4.3):
5.3.5. Auswertung System 2 Windows ( 1.7.0_45):
5.3.6. Auswertung System 3 ( Oracle 1.7.0_07 ):
6. Quellcode
7. Fazit und Ausblick

1. Einleitung

Wir wollen hier unser Hauptthema erörtern, auf das wir so lange hin gearbeitet haben. Wir werden uns hier folgenden Fragen stellen:

• Was ist unsere Idee
• Wie sind wir auf die Idee gekommen
• Warum machen wir das
• Wie haben wir diesen Comparator umgesetzt und wofür ist er gedacht
• Wie funktioniert unser SmartComparator
• Wie kann unser SmartComparator eingesetzt werden
• Haben wir getestet
• Was haben wir getestet
• Wie haben wir getestet

2. Was ist unsere Idee?

Die Idee die wir hatten, besteht darin einen Comparator für alles anzubieten. Ein Comparator soll für die Sortierung aller eigenen Datenobjekte dienen. Dabei muss die Möglichkeit bestehen, die Objekte nach einem oder mehreren Attributen zu sortieren. Der Comparator sollte dabei einfach und flexibel zu benutzen sein.

2.1. Wie sind wir auf die Idee gekommen?

Nachdem wir viel programmieren und programmiert haben in der Vergangenheit, sind wir immer auf ähnlich geartete Probleme gestoßen. Eines, was sehr häufig auftritt, ist eben das Sortieren von eigenen Datenobjekten nach verschiedenen Kriterien. Zum einen traten diese Dinge zum Vorschein bei der Verarbeitung der Daten, aber auch bei der Ausgabe der Daten in Tabellen. Hier benötigt man die Funktion zum Sortieren der Tabelleninhalte recht häufig. Vor allem immer dann, wenn man dem Benutzer eine gut bedienbare GUI anbieten will.

2.2. Warum machen wir das?

Wir wollen allen anderen Entwicklern und auch uns selbst in Zukunft die Möglichkeit an die Hand geben, Software schneller und auch einfacher zu entwickeln. Außerdem kann die Umsetzung von mehreren Comparatoren für verschiedene Datenobjekte ziemlich eintönig auf Dauer werden.

3. Wie haben wir diesen Comparator umgesetzt und wofür ist er gedacht?

Die Umsetzung und das Testen gestalteten sich schwierig und umfangreich. Wir haben dafür zusammen volle 4h benötigt für unsere erste Version. ;-)

Wir fingen damit an, uns zu überlegen, welche Objekte oder Werte wir sortieren können - angefangen von den Wrapper Klassen von Java, wie Integer, Float, Boolean usw., aber auch Objekte wie Strings oder primitive Datentypen. Hier wird der erfahrene Programmierer wissen, dass die zurück gelieferten Datentypen eines Datenobjektes meist primitive Datentypen sind oder die Wrapper-Klassen davon. Natürlich besteht die Möglichkeit, eine Liste oder ein Array als Rückgabe zu erhalten. Diese Objekte sind eben das Ziel wofür ein Comparator benötigt wird und diente uns somit nicht als Ausgangspunkt für die Sortierung.

3.1. Wie funktioniert unser SmartComparator?

Der Kern besteht aus der public int compare(T t, T t1) Methode und den drei dazugehörigen private Methoden private int compare(T t, T t1, MethodNameRecord VAL), private void analyzeClassReturnTypes() und private Class castObjects(Class clazz).

3.1.1. Die Instanziierung

Man erzeugt eine SmartComparator-Instanz und übergibt ihm im Konstruktor die Klasse des zu sortierenden Objekttyps und eine Liste von Methodennamen. Bei der Liste der Methodennamen handelt es sich um Methoden, die in dem Objekttyp implementiert sind. Dieser Liste kann man eine Sortierrichtung für jede Methode übergeben.

3.1.2. Die Vorverarbeitung

Während der Instanziierung wird eine Vorverarbeitung der übergebenen Methoden und deren Sortierrichtung vorgenommen. Die Analyse startet mit der Methode analyzeClassReturnTypes. Diese Methode überprüft, ob die angegebenen Methoden existieren oder nicht. Wenn die angegebene Methode existiert, wird das Methodenobjekt, der Datentyp für die Rückgabe und die Sortierrichtung in den MethodNameRecord-Parameter übergeben. Wenn die Methode nicht existiert oder der Rückgabetyp der Methode Void ist, dann wird eine entsprechende Runtime Exception geworfen.

3.1.3. Der Vergleich

Nachdem die Instanz des SmartComparators erzeugt und die Vorverarbeitung beendet wurde, übergibt man der public compare Methode die zu vergleichenden/sortierenden Instanzen des angegebenen Objekttyps. Hier wird der Vergleich gestartet, indem die privat compare Methode gerufen wird. Dabei werden die vorher übergebenen und analysierten Methoden mit deren Datentypen für die Rückgabewerte an die Methode übergeben. Dies geschieht mit der Übergabe des MethodNameRecord-Parameters. In der private compare Methode wird dann der Vergleich für die eine übergebene Methode durchgeführt. Hierfür werden die Daten per Reflection von den Objekten geholt und über die compareTo Methode der Klassen miteinander verglichen. Der Rückgabewert der compareTo Methode wird an die public compare Methode zurückgegeben. In dieser Methode wird geprüft, ob beide Werte gleich sind oder nicht. Wenn beide Werte gleich sind, dann wird der Vergleich mit der nächsten übergebenen Methode fortgeführt. Sind die Werte unterschiedlich, wird überprüft welche Sortierrichtung angegeben wurde. Ist die Sortierrichtung Absteigend/ Descendent, wird der Rückgabewert des Vergleichs mit -1 multipliziert. Im Anschluss wird der Wert des Vergleichs zurückgegeben.

Die Reihenfolge, in der die Vergleiche durchgeführt werden, entspricht der Reihenfolge der Übergabe der Methodennamen.

3.1.4. Änderung der Sortierung

Für ein und denselben Objekttyp, der bei der Instanziierung angegeben wurde, kann die Sortierung geändert werden ohne das der SmartComparator neu erzeugt werden muss. Hierfür benutzt man eine der changeSorting Methoden. Nach dem Aufruf einer solchen Methode wird abermals die Methode analyzeClassReturnTypes aufgerufen, um die übergebenen Daten zu validieren. Wenn der Aufruf keine Runtime Exception erzeugt, kann danach mit der neuen Sortierung weiter gearbeitet werden.

4. Wie kann unser SmartComparator eingesetzt werden?

Der SmartComparator ist vielseitig einsetzbar. Man kann den SmartComparator zum Beispiel erzeugen lassen mit einer Liste von Methodennamen. Ein anderer Ansatz, den wir bevorzugen, ist der Einsatz von Annotations in der Datenklasse. Hier besteht die Möglichkeit, eine Sortierung als Standard zu definieren, mit der @CompareCriteria Annotation. Ein anderer Weg ist der, viele verschiedene Sortiermöglichkeiten anzubieten. Das kann man mit den Annotations @NamedSorts und @NamedSort realisieren. Vergleichbar sind diese beiden Annotations mit dem Ansatz der NamedQueries in Hibernate oder anderen JPA Providern. Weiter unten sind alle Möglichkeiten aufgelistet, über die man einen SmartComparator instanziieren kann.

4.1. Erzeugung per String-Array

In dieser Variante übergeben sie dem Konstruktor ein Array von Methodennamen. Das reicht aus, um den SmartComparator erzeugen zu lassen. Hierbei ist zu beachten, dass die Sortierung für jede angegebene Methode Aufsteigend/Ascendent erfolgt.

4.2. Erzeugung per MethodNameRecord-Array

Mit dieser Möglichkeit muss der Programmierer im Quellcode die MethodNameRecord Instanzen selbst erzeugen und in einem Array zusammenführen. Die Priorisierung findet hier über die Array Indizes statt. Der Index mit der geringeren Nummer hat die höhere Priorität.

4.3. Erzeugung per MethodNameGenerator

Mit dem MethodNameGenerator besteht eine einfache Alternative, ein MethodNameRecord-Array generieren zu lassen. Dabei wird dem Generator eine Liste von Methodennamen und optional auch die Sortierrichtung übergeben. Der MethodNameGenerator erzeugt daraus ein MethodNameRecord-Array, das dann nach der vorher beschriebenen Methode an den SmartComparator übergeben werden kann.

4.4. Erzeugung per @CompareCriteria-Annotation

Die @CompareCriteria Annotation kann an den Methodennamen oder den Feldern definiert werden. Weiterhin erlaubt diese Annotation die Priorisierung der Methoden oder Felder für die Sortierung. Optional ist wie immer die Angabe der Sortierrichtung in der Annotation möglich. Nach der Übergabe der Klasse an den Konstruktor wird die Klasse auf die angegebene Annotation geparst und ausgewertet. Danach ist der SmartComparator auch schon einsatzbereit.

4.5. Erzeugung per @NamedSorts und @NamedSort Annotations

Wie oben bereits erwähnt, sind diese beiden Annotations von der Deklaration und der Anwendung her mit den NamedQuery-Annotations der JPA-Provider zu vergleichen. Um eine Liste von Sortiermöglichkeiten zu definieren, wird als erstes die @NamedSorts-Annotation verwendet. In dieser Annotation kann man eine durch Komma getrennte Liste von @NamedSort-Annotations angeben. In der @NamedSort-Annotation wird als erstes der Name der Sortierung angegeben. Danach folgt eine Liste von @MethodName-Annotations. Diese Annotation erwartet als Parameter den Namen der Methode und optional die Sortierrichtung. Die Priorität, die bei der Sortierung den Methodennamen zukommt, entspricht der Reihenfolge der Aufzählung in der @NamedSort-Annotation.

5. Haben wir getestet?

Ja

5.1. Was haben wir getestet?

System 1 ist definiert als:

• AMD A4-3300M APU mit Radeon HD Graphics AuthenticAMD
• 8GB DDR 3 RAM

Betriebssysteme:

• Sabayon Linux mit Kernel 3.12.0
• Windows 8.1 Professional

JavaVM:

• Linux: Oracle 1.7.0_45
• Linux: icedtea-7.2.4.3
• Windows: 1.7.0_45

System 2 ist definiert durch:

• Intel(R) Core(TM)2 Duo CPU E8400 @ 3.00GHz
• 8GB DDR 3 RAM

Betriebssysteme:

• Genttoo Linux mit Kernel 3.12.0
• Windows 8.1 Professional

JavaVM:

• Linux: icedtea-7.2.4.3
• Windows: 1.7.0_45

System 3 ist definiert als:

• Intel Core i7-2630QM 2GHz 64 Bit
• 8 GB DDR 3 RAM
• Windows 7 64-Bit
• JVM: 1.7.0_07

Unser Ziel ist es, unseren SmartComparator gegen einen Nativ implementierten Comparator antreten zu lassen. Wir wollen zeigen, inwieweit unser Comparator mithalten kann und für welche Datenmengen er eine hinreichende Alternative darstellt.

5.2. Wie haben wir getestet?

Wir haben hierfür eine Datenklasse und mehrere Testfälle geschrieben. An den SmartComparator wurde die Deklarierung der Methodennamen und der Sortierrichtung übergeben. Hier haben wir nicht nur den Nativen dem SmartCompararor gegenüber gestellt, wir haben auch den Vergleich primitive Variable und Wrapper-Klasse nicht gescheut. Damit wollen wir die Performanz dieses Ansatzes aufzuzeigen. Die Tests sind hierbei mehrfach durchlaufen worden mit einer Datenmenge von 10.000 durch Zufall generierten Datensätzen. Aus den gesammelten Werten der einzelnen Durchläufe wurde ein Durchschnittswert ermittelt. Auch diese Tests haben wir für ein und das gleiche Beispiel mehrfach wiederholt, weil die Zeiten von Test zu Test schwankend waren. Daher werden die Vergleiche nicht durch exakte Zeiten dargestellt, sondern durch Ratios. Durch diese Darstellung lässt sich das Laufzeitverhalten auch besser beurteilen. Abgerundet werden die Tests durch den Vergleich von Datenobjekten mit mehreren Variablen und mit einer Mischung aus Wrapper-Klassen und primitiven Datentypen.

5.3. Was war das Testergebnis?

5.3.1. Auswertung System 1 Linux (Oracle 1.7.0_45):

5.3.2. Auswertung System 1 Linux ( icedtea 7.2.4.3):

5.3.3. Auswertung System 1 Windows ( 1.7.0_45)

5.3.4. Auswertung System 2 Linux ( icedtea 7.2.4.3):

5.3.5. Auswertung System 2 Windows ( 1.7.0_45):

5.3.6. Auswertung System 3 ( Oracle 1.7.0_07 ):

6. Quellcode

https://github.com/P1tt187/SmartComparator

7. Fazit und Ausblick

Der SmartComparator ermöglicht das Sortieren von Werten ohne die Programmierung eigener Comparatoren. Hier ist es nur erforderlich, zu deklarieren, nach welchen Kriterien der SmartComparator die Vergleiche vollziehen soll. Zusammengefasst gesagt, ist der SmartComparator eine Alternative für alle, denen es nicht auf jede Millisekunde ankommt.

Wir durchdenken schon die nächste Stufe des SmartComparators, um noch mehr Performance- Gewinn zu erzielen. Bis dahin wünschen wir euch erst einmal mit dieser Version viel Spaß und freuen uns über Hinweise oder Anregungen.

Wir möchten alle Leser dazu anhalten, den SmartComparator selber zu testen und uns ihre Systembeschreibung mit ihren Messdaten zukommen zu lassen. Wir werden auf einer weiterführenden Seite die Testergebnisse, Systembeschreibung und falls gewünscht - den Namen der testenden Person - veröffentlichen.

Stand: 5. November 2013