Aufgrund der Unterschiede zwischen den Betriebssprachen der relationalen Datenbank und den objektorientierten Sprachen müssen wir weiterhin viel Zeit damit verbringen, eine Brücke zwischen Datenbanken und Java-Anwendungen aufzubauen. Normalerweise können wir unsere eigene Zuordnungsschicht schreiben oder ein Relationskartierungsgerüst von Drittanbietern (Object Relational Mapper) wie Hibernate verwenden. Obwohl das ORM -Framework sehr bequem zu verwenden ist, ist es nicht einfach, die Leistung der Betriebsdatenbank des Frameworks korrekt zu konfigurieren und zu verbessern. ORM -Frameworks beeinträchtigen unsere Anwendungsleistung häufig. Vor kurzem habe ich ein neues Open -Source -Projekt, die Geschwindigkeit, bei der es schneller und effizienter gestellt, Datenbankanwendungen mit Java 8 zu entwickeln.
Die Geschwindigkeit ist eine Option, um ORM zum Betrieb der Datenbank zu verwenden. In der Vergangenheit brauchten wir 100 Zeilen Java -Code, um die Datenbank zu betreiben. In Java 8 brauchen wir möglicherweise nur eine Codezeile.
In den späten neunziger Jahren, als ich Java verwendete, um Datenbankanwendungen zu entwickeln, mussten viele Codelogiken von mir selbst verfasst werden, z. B. Ausnahmen, Typ -Conversion usw. Nach vielen Änderungen wurden diese Codes schwer zu pflegen und zu erweitern.
Aufgrund der Unterschiede zwischen den Betriebssprachen der relationalen Datenbank und den objektorientierten Sprachen müssen wir weiterhin viel Zeit damit verbringen, eine Brücke zwischen Datenbanken und Java-Anwendungen aufzubauen. Normalerweise können wir unsere eigene Zuordnungsschicht schreiben oder ein Relationskartierungsgerüst von Drittanbietern (Object Relational Mapper) wie Hibernate verwenden. Obwohl das ORM -Framework sehr bequem zu verwenden ist, ist es nicht einfach, die Leistung der Betriebsdatenbank des Frameworks korrekt zu konfigurieren und zu verbessern. ORM -Frameworks beeinträchtigen unsere Anwendungsleistung häufig.
Vor kurzem habe ich ein neues Open -Source -Projekt, die Geschwindigkeit, bei der es schneller und effizienter gestellt, Datenbankanwendungen mit Java 8 zu entwickeln.
Was ist Speakment?
Geschwindigkeit ist ein Open -Source -Projekt. Es handelt sich um eine neue Java -Bibliothek, die auf neuen Funktionen von Java 8 entwickelt wurde. Seit der Entwicklung dieses Projekts wurde der gesamte Code in Java 8 geschrieben. Die Geschwindigkeit verwendet den Standardfluss zu Abfragedatenbanken, wodurch Entwickler neue Abfragemapis erlernen und nicht in Betracht gezogen werden müssen.
Die Geschwindigkeit generiert automatisch Code basierend auf der vorhandenen Datenbank. Aus diesem Weg müssen Entwickler keine Codezeile über Datenbankentitäten schreiben. Der von ihm generierte Code enthält auch Javadocs -Hilfedokumentation, wodurch Entwickler Entitätsklassen über Objekte wie Benutzer oder Buch schreiben. Stattdessen müssen wir nur eine vorhandene Datenbank erstellen oder verwenden und dann mit der Geschwindigkeit verbinden. Anschließend analysiert die Geschwindigkeit die Datenbankstruktur, um den Code der Entitätsklasse zu generieren.
Noch interessanter ist, dass die Geschwindigkeit den Hasen als Maskottchen verwendet. Im nächsten Beispiel werden wir eine Datenbank namens "Hare" verwenden, um zu demonstrieren, wie die Geschwindigkeit verwendet wird. Die Tabellenstruktur dieser Datenbank lautet wie folgt:
MySQL> Erklären Sie Hase;
+-------------------------+------------------------------------------------------------------------------------------------------------------------
| Feld | Typ | NULL | Schlüssel | Standard | Extra |
+-------------------------+------------------------------------------------------------------------------------------------------------------------
| id | int (11) | Nein | Pri | NULL | auto_increment |
| Name | Varchar (45) | Nein | | NULL | |
| Farbe | Varchar (45) | Nein | | NULL | |
| Alter | int (11) | Nein | | NULL | |
+-------------------------+------------------------------------------------------------------------------------------------------------------------
4 Zeilen in Set (0,01 Sek.)
Hier ist eine entsprechende Entitätsklasse, die auf der Grundlage von Datenbankinformationen durch Geschwindigkeit erzeugt wird (für die Kürze haben wir hier Javadocs entfernt):
Die öffentliche Schnittstelle erweitert Entity <Hare> {öffentliche endgültige statische Referenz -Vergleichbarerfield <Hare, Integer> id = Neue ReferenceCompablefieldImpl <> ("ID", Hare :: getid, hare :: setId); Public Final Static ReferenceComatabringfield <Heare> New ReferenceComparablingFieldImpledimPling <>, Hare> New Reference: "New ReferenceComparableStringFieldImpl <>," Name: New Reference: "NAMECELLECEPRAGE:" NAME: "NEW REFERENCEPNAUM:" NAY: NAY: Hare :: setName); öffentliche endgültige statische ReferenceComparablestringfield <Hare> color = Neue ReferenceComparablestringfieldImpl <> ("Farbe", Hare :: GetColor, Hare :: setColor); Hare :: Setage); Integer getId (); String getName (); String getColor (); Integer getage (); Hare setId (Integer id); Hare setName (String-Name); Hare setColor (String Color); Hare Setage (Integer Age); findCarrotsByowner (); Stream <Carrot> findCarrotsByRival (); Stream <Carrot> findCarrots ();};Ich werde einen separaten Artikel verwenden, um die Verwendung der Find*() -Methode einzuführen, die anstelle von SQL -Verbindungsoperationen verwendet werden kann.
Anfragebeispiel
Das folgende Beispiel zeigt, wie Datenbankinformationen einer Hare -Tabelle abfragen:
Liste <Hare> oldhares = haves.stream ()
.Filter (Alter.Greaterthan (8))
.Collect (tolist ());
Smart Streaming
Der obige Code scheint über alle Zeilen der Hare -Datenbanktabelle iteriert zu haben, ist jedoch nicht der Fall. Stream ist intelligent. Wenn es den Collect () -Operationsvorgang erreicht, analysiert es den Filterbetrieb und färbt die Spalten mit Hase. Wenn Sie mehrere Filter verwenden, werden sie zusammengeführt, um Streaming -Operationen zu speichern. Hier ist ein weiteres Beispiel für mehrere Operationen mit Streaming:
long Nooldhares = Hasen.Stream ()
.Filter (Alter.Greaterthan (8))
.Maptoint (Hare :: Getage)
.Sortiert ()
.zählen();
Im obigen Code überprüft der Stream die eigene Pipeline. Zunächst wird der Altersbetrieb im obigen Beispiel abgeleitet, und zweitens, ohne das Ergebnis von count () zu ändern, werden die Operationen maptoint () und sortiert () abgeleitet, was beseitigt werden kann, sodass der Betrieb dieses Codes in "Wählen Sie Count (*) aus Hase Where Age> 8". Dies bedeutet, dass Sie Java 8 -Streams verwenden können, ohne dass Sie sich so sehr darum kümmern müssen, wie Streams in SQL konvertiert werden.
So laden Sie uns herunter und treten Sie uns an
Wenn Sie erfahren möchten, wie Sie die API von Speedment verwenden und die Geschwindigkeit in Ihrem Projekt verwenden, können Sie die URL www.speedment.org besuchen und den Gitter kommentieren oder den Speedment -Quellcode von GitHub herunterladen, um Ihren eigenen Code beizutragen.
Zusammenfassen
Rückblickend auf einige alte Projekte in den frühen Tagen kann eine Datenbankklasse mit mehr als 100 Codezeilen mit Java 8 auf 1 Codezeile reduziert werden. Das ist das Moore -Gesetz nach der Umkehrung. In 14 Jahren (= 7 Maulwurfszeiten) wurde die Anzahl der Linien um etwa siebenmal halbiert. Das ist Fortschritt!
Was ist der Datenfluss
Der Stream stellt ein Objekt aus einer Sequenz dar, das die Aggregationsoperationsquelle unterstützt. Das Folgende sind die Eigenschaften des Datenflusss.
Elementsequenz - Ein Stream liefert auf sequentielle Weise einen bestimmten Satz von Elementen. Stream -Fetch-/Computerelemente der Nachfrage. Es speichert keine Elemente.
Quelle - Streams verwenden Sammlungen, Arrays oder E/A -Ressourcen als Eingabequellen.
Aggregationsbetrieb - Datenfluss unterstützt Aggregationsvorgänge wie Filter, MAP, Limit, Reduzierung, Finden, Übereinstimmung usw.
Pipeline -Übertragung - Die meisten Stream -Operationen geben selbst Streams zurück, die ihre Ergebnisse übergeben werden können. Diese Operationen werden als Zwischenoperationen bezeichnet, und ihre Funktion besteht darin, Eingänge, Prozesseingänge und Ausgänge zu verwenden, um zum Ziel zurückzukehren. Die sammel () -Methode ist ein Terminalbetrieb, der normalerweise am Ende des Pipeline -Vorgangs vorhanden ist, um das Ende des Stroms zu markieren.
Automatische Iteration - Der Stream -Betrieb wird wiederholt intern verglichen, wo klar ist, dass die Iteration die Sammlung erfordert, um Quellelemente bereitzustellen.