Dieser Artikel vermittelt Ihnen relevantes Wissen über Java, das hauptsächlich Probleme im Zusammenhang mit der Open-Source-Bibliothek für strukturierte Daten (SPL) vorstellt. Werfen wir einen Blick auf die ideale Bibliothek für die strukturierte Datenverarbeitung unter Java.
Empfohlene Studie: „Java-Video-Tutorial“
Moderne Java-Anwendungsarchitekturen legen zunehmend Wert auf die Trennung von Datenspeicherung und -verarbeitung, um eine bessere Wartbarkeit, Skalierbarkeit und Portabilität zu erreichen, wie z. B. Fiery Microservices sind ein typisches Beispiel. Diese Architektur erfordert normalerweise die Implementierung der Geschäftslogik in Java-Programmen, anstatt sie wie bei der herkömmlichen Anwendungsarchitektur in der Datenbank abzulegen.
Der Großteil der Geschäftslogik in Anwendungen umfasst die strukturierte Datenverarbeitung. Die Datenbank (SQL) bietet umfassende Unterstützung für solche Aufgaben und Geschäftslogik kann relativ einfach implementiert werden. Allerdings fehlte Java schon immer eine solche grundlegende Unterstützung, was die Implementierung von Geschäftslogik in Java sehr umständlich und ineffizient machte. Infolgedessen ist die Entwicklungseffizienz trotz verschiedener architektonischer Vorteile erheblich gesunken.
Wenn wir auch einen vollständigen Satz strukturierter Datenverarbeitungs- und Berechnungsklassenbibliotheken in Java bereitstellen, kann dieses Problem gelöst werden: Die Vorteile der Architektur nutzen, ohne die Entwicklungseffizienz zu beeinträchtigen.
Welche Eigenschaften sollte eine ideale strukturierte Datenverarbeitungsbibliothek unter Java haben? Wir können aus SQL zusammenfassen:
Strukturierte Daten erscheinen oft in Stapeln (in Form von Sätzen). Um diese Art von Daten bequem berechnen zu können, ist es notwendig, ausreichende Satzberechnungsfähigkeiten bereitzustellen.
Wenn es keine Mengenoperationsbibliothek gibt, gibt es nur den Basisdatentyp Array (entspricht einer Menge). Wenn wir einfach die Mengenmitglieder summieren möchten, müssen wir vier oder fünf Zeilen mit Schleifenanweisungen schreiben, um sie zu vervollständigen . Operationen wie Filterung, Gruppierung und Aggregation erfordern das Schreiben von Hunderten von Codezeilen.
SQL bietet eine Vielzahl von Operationen, wie z. B. SUM/COUNT und andere Aggregationsoperationen, WHERE wird zum Filtern verwendet, GROUP wird zum Gruppieren verwendet und es unterstützt auch grundlegende Operationen wie Schnittmenge, Vereinigung und Differenz für Mengen. Der auf diese Weise geschriebene Code wird viel kürzer sein.
Reicht es aus, über festgelegte Betriebsfunktionen zu verfügen? Können wir den Effekt von SQL erzielen, wenn wir eine Reihe von Mengenoperationsbibliotheken für Java entwickeln?
So einfach ist das nicht!
Nehmen Sie als Beispiel den Filtervorgang. Für das Filtern ist normalerweise eine Bedingung erforderlich, um die Mengenmitglieder beizubehalten, die die Bedingung erfüllen. In SQL erscheint diese Bedingung in Form eines Ausdrucks. Das Schreiben von WHERE x>0 bedeutet beispielsweise, dass diejenigen Elemente beibehalten werden, die das Berechnungsergebnis von x>0 wahr machen. Der Ausdruck x>0 wird vor der Ausführung dieser Anweisung nicht ausgewertet, sondern während der Iteration für jedes Mengenmitglied. Im Wesentlichen handelt es sich bei diesem Ausdruck um eine Funktion, eine Funktion, die die aktuellen Sammlungsmitglieder als Parameter verwendet. Für die WHERE-Operation entspricht dies der Verwendung einer Funktion, die mit einem Ausdruck als Parameter von WHERE definiert ist.
Für diese Schreibweise gibt es einen Begriff namens Lambda-Syntax oder funktionale Sprache.
Ohne Lambda-Syntax müssten wir oft vorübergehend Funktionen definieren, was den Code sehr umständlich und anfällig für Namenskonflikte machen würde.
Lambda-Syntax wird in SQL häufig verwendet. Sie ist nicht für Filter- und Gruppierungsvorgänge erforderlich. Sie kann auch in unnötigen Szenarien wie berechneten Spalten verwendet werden, was den Code erheblich vereinfacht.
Strukturierte Daten sind kein einfacher einzelner Wert, sondern ein Datensatz mit Feldern.
Wir haben festgestellt, dass Sie beim Verweisen auf Datensatzfelder in SQL-Ausdrucksparametern in den meisten Fällen den Feldnamen direkt verwenden können, ohne den Datensatz anzugeben, zu dem das Feld gehört. Nur wenn mehrere Felder mit demselben Namen vorhanden sind, müssen Sie den verwenden Tabellenname (oder Alias).
Obwohl die neue Version von Java auch damit begonnen hat, die Lambda-Syntax zu unterstützen, kann sie nur den aktuellen Datensatz als Parameter an die mit der Lambda-Syntax definierte Funktion übergeben und diesen Datensatz dann beim Schreiben von Berechnungsformeln immer mitbringen. Wenn beispielsweise bei der Berechnung des Betrags anhand von Einheitspreis und Menge der Parameter, der zur Darstellung des aktuellen Elements verwendet wird, den Namen x hat, muss er in der langatmigen Form „x. Einheitspreis * x. Menge“ geschrieben werden. In SQL kann es intuitiver als „Stückpreis * Menge“ geschrieben werden.
SQL kann auch dynamische Datenstrukturen sehr gut unterstützen.
Bei strukturierten Datenberechnungen handelt es sich bei dem Rückgabewert häufig um strukturierte Daten, und die Ergebnisdatenstruktur bezieht sich auf Operationen und kann vor dem Schreiben des Codes nicht vorbereitet werden. Daher ist es notwendig, dynamische Datenstrukturfunktionen zu unterstützen.
Jede SELECT-Anweisung in SQL generiert eine neue Datenstruktur, und Felder können im Code hinzugefügt und gelöscht werden, ohne dass die Struktur (Klasse) im Voraus definiert werden muss. Dies ist bei Sprachen wie Java nicht möglich. Alle verwendeten Strukturen (Klassen) müssen während der Code-Kompilierungsphase definiert werden. Neue Strukturen können grundsätzlich nicht während der Ausführung generiert werden.
Aus der Analyse der vorherigen Artikel können wir bereits schließen, dass Java selbst nicht als Sprache für die strukturierte Datenverarbeitung geeignet ist. Sein Lambda-Mechanismus unterstützt Funktion 3 nicht und als kompilierte Sprache kann er Funktion 4 nicht implementieren.
Tatsächlich ist die zuvor erwähnte Lambda-Syntax nicht für die Implementierung in kompilierten Sprachen geeignet. Der Compiler kann nicht bestimmen, ob der an die Parameterposition geschriebene Ausdruck den Wert des Ausdrucks sofort berechnen und dann weitergeben soll oder ob er den gesamten Ausdruck in eine Funktion kompilieren und übergeben soll, und es müssen weitere Syntaxsymbole vorhanden sein entworfen, um es zu unterscheiden. Interpretierte Sprachen haben dieses Problem nicht, ob der Ausdruck als Parameter zuerst berechnet wird oder nach dem Durchlaufen der Mengenmitglieder berechnet wird, kann von der Funktion selbst entschieden werden.
SQL ist tatsächlich eine interpretierte Sprache.
Stream ist eine strukturierte Datenverarbeitungsbibliothek, die offiziell in Java 8 eingeführt wurde, aber die oben genannten Anforderungen nicht erfüllt. Es verfügt nicht über professionelle strukturierte Datentypen, es fehlen viele wichtige Berechnungsfunktionen für strukturierte Daten, es handelt sich nicht um eine interpretierte Sprache, es werden keine dynamischen Datentypen unterstützt und die Schnittstelle der Lambda-Syntax ist komplex.
Kotlin ist Teil des Java-Ökosystems. Es hat leichte Verbesserungen auf Basis von Stream vorgenommen und bietet auch strukturierte Datenberechnungstypen. Aufgrund unzureichender strukturierter Datenberechnungsfunktionen handelt es sich jedoch nicht um eine interpretierte Sprache und unterstützt keine dynamischen Daten .Typ, die Schnittstelle der Lambda-Syntax ist komplex und es handelt sich immer noch nicht um eine ideale Klassenbibliothek für strukturierte Datenverarbeitung.
Scala bietet einen umfangreichen Satz strukturierter Datenberechnungsfunktionen, aber die Eigenschaften kompilierter Sprachen verhindern auch, dass es sich zu einer idealen Klassenbibliothek für strukturierte Datenberechnungen entwickelt.
Was kann man sonst noch im Java-Ökosystem nutzen?
esProc SPL.
SPL ist eine von Java interpretierte und ausgeführte Programmiersprache. Sie verfügt über eine umfangreiche strukturierte Datenberechnungsklassenbibliothek, eine einfache Lambda-Syntax und benutzerfreundliche dynamische Datenstrukturen. Sie ist eine ideale strukturierte Verarbeitungsklassenbibliothek.
SPL bietet einen professionell strukturierten Datentyp, nämlich eine Sequenztabelle. Wie die SQL-Datentabelle ist die Sequenztabelle eine Sammlung von Batch-Datensätzen und verfügt über die allgemeinen Funktionen strukturierter Datentypen. Das Folgende ist ein Beispiel.
Parsen Sie die Quelldaten und generieren Sie die Sequenztabelle:
Orders=T("d:/Orders.csv")Erzeugen Sie eine neue Sequenztabelle aus der ursprünglichen Sequenztabelle nach Spaltennamen:
Orders.new(OrderID, Amount, OrderDate)
Berechnete Spalte:
Orders.new(OrderID, Amount, year(OrderDate))
Feldumbenennung:
Orders.new(OrderID:ID, SellerId, year(OrderDate):y)
Verwenden Sie Felder nach Seriennummer:
Orders.groups(year(_5),_2; sum(_4))
Umbenennen der Sequenztabelle (linke Assoziation)
join@1(Orders:o,SellerId ; Employees:e,EId).groups(e.Dept; sum(o.Amount))
Die Sequenztabelle unterstützt alle strukturierten Berechnungsfunktionen, und das Berechnungsergebnis ist ebenfalls eine Sequenztabelle und kein Datentyp wie Map. Verarbeiten Sie beispielsweise weiterhin strukturierte Daten für gruppierte Zusammenfassungsergebnisse:
Orders.groups(year(OrderDate):y; sum(Amount):m).new(y:OrderYear, m*0.2:discount)
Basierend auf der Sequenztabelle bietet SPL eine Fülle strukturierter Datenberechnungsfunktionen wie Filtern, Sortieren, Gruppieren, Deduplizieren, Umbenennen, berechnete Spalten, Assoziationen und Unterabfragen , Satzberechnungen, geordnete Berechnungen usw. Diese Funktionen verfügen über leistungsstarke Rechenfunktionen und können Berechnungen unabhängig ohne fest codierte Unterstützung durchführen:
Kombinierte Abfrage:
Orders.select(Amount>1000 && Amount<=3000 && like(Client,"*bro*"))
Sortieren:
Orders.sort(-Client,Amount)
Gruppenzusammenfassung:
Orders.groups(year(OrderDate),Client; sum(Amount))
join(Orders:o,SellerId ; Employees:e,EId).groups(e.Dept; sum(o.Amount))
Orders.select(Amount>1000)
Orders.select(Amount>1000 && Amount<2000)
Dynamische Datenstruktur
SPL Es handelt sich um eine interpretierte Sprache, die auf natürliche Weise dynamische Datenstrukturen unterstützt und basierend auf der Berechnungsergebnisstruktur dynamisch neue Sequenztabellen generieren kann. Es eignet sich besonders für Berechnungen wie berechnete Spalten, Gruppenzusammenfassungen und Korrelationen. Beispielsweise müssen die Ergebnisse der Gruppenzusammenfassung direkt neu berechnet werden:
Orders.sum(Amount*Amount)
Orders.sort(-Client, Amount)
Orders.groups(Client;sum(Amount):amt).select(amt>1000 && like(Client,"*S*"))
Direkte Ausführung von SQL
SPL implementiert auch einen SQL-Interpreter, der direkt ausgeführt werden kann SQL unterstützt alles vom einfachen WHERE und GROUP bis hin zu JOIN und sogar WITH:join(Orders:o,SellerId ; Employees:e,Eid).groups(e.Dept; sum(o.Amount))
Sales2021.group(month(sellDate)).(~.groups(Client;sum(Amount):sumValue)).(~.sort(-sumValue)) .(~.select(#<=10)).(~.(Client)).isect()
$select * from d:/Orders.csv where (OrderDate<date('2020-01-01') and Amount<=100)or (OrderDate>=date('2020-12-31') and Amount>100)$select year(OrderDate),Client ,sum(Amount),count(1) from d:/Orders.csv group by year(OrderDate),Client having sum(Amount)<=100
但是，更彻底的集合化需要离散性来支持，集合成员可以游离在集合之外，并与其它数据随意构成新的集合参与运算 。
SPL兼具了SQL的集合化和Java的离散性，从而可以实现更彻底的集合化。
比如，SPL中很容易表达“集合的集合”，适合分组后计算。比如，找到各科成绩均在前10名的学生：
| A | |
|---|---|
| 1 | =T(“score.csv”).group(subject) |
| 2 | =A2.(.rank(score).pselect@a(<=10)) |
| 3 | =A1.(~(A3(#)).(name)).isect() |
| SPL序表的字段可以存储记录或记录集合，这样可以用对象引用的方式，直观地表达关联关系，即使关系再多，也能直观地表达。比如，根据员工表找到女经理下属的男员工： |
Employees.select(性别:"男",部门.经理.性别:"女")
有序计算是离散性和集合化的典型结合产物，成员的次序在集合中才有意义，这要求集合化，有序计算时又要将每个成员与相邻成员区分开，会强调离散性。SPL兼具集合化和离散性，天然支持有序计算。
具体来说，SPL可以按绝对位置引用成员，比如，取第3条订单可以写成Orders(3)，取第1、3、5条记录可以写成Orders([1,3,5])。
SPL也可以按相对位置引用成员，比如，计算每条记录相对于上一条记录的金额增长率：Orders.derive(amount/amount[-1]-1)
SPL还可以用#代表当前记录的序号，比如把员工按序号分成两组，奇数序号一组，偶数序号一组：Employees.group(#%2==1)
大量功能强大的结构化数据计算函数，这本来是一件好事，但这会让相似功能的函数不容易区分。无形中提高了学习难度。
SPL提供了特有的函数选项语法，功能相似的函数可以共用一个函数名，只用函数选项区分差别。比如select函数的基本功能是过滤，如果只过滤出符合条件的第1条记录，只须使用选项@1：
Orders.select@1(Amount>1000)
数据量较大时，用并行计算提高性能，只须改为选项@m：
Orders.select@m(Amount>1000)
对排序过的数据，用二分法进行快速过滤，可用@b：
Orders.select@b(Amount>1000)
函数选项还可以组合搭配，比如：
Orders.select@1b(Amount>1000)
结构化运算函数的参数常常很复杂，比如SQL就需要用各种关键字把一条语句的参数分隔成多个组，但这会动用很多关键字，也使语句结构不统一。
SPL支持层次参数，通过分号、逗号、冒号自高而低将参数分为三层，用通用的方式简化复杂参数的表达：
join(Orders:o,SellerId ; Employees:e,EId)
普通的Lambda语法不仅要指明表达式（即函数形式的参数），还必须完整地定义表达式本身的参数，否则在数学形式上不够严密，这就让Lambda语法很繁琐。比如用循环函数select过滤集合A，只保留值为偶数的成员，一般形式是：
A.select(f(x):{x%2==0} )这里的表达式是x%2==0，表达式的参数是f(x)里的x，x代表集合A里的成员，即循环变量。
SPL用固定符号~代表循环变量，当参数是循环变量时就无须再定义参数了。在SPL中，上面的Lambda语法可以简写作：A.select(~ %2==0)
普通Lambda语法必须定义表达式用到的每一个参数，除了循环变量外，常用的参数还有循环计数，如果把循环计数也定义到Lambda中，代码就更繁琐了。
SPL用固定符号#代表循环计数变量。比如，用函数select过滤集合A，只保留序号是偶数的成员，SPL可以写作：A.select(# %2==0)
相对位置经常出现在难度较大的计算中，而且相对位置本身就很难计算，当要使用相对位置时，参数的写法将非常繁琐。
SPL用固定形式[序号]代表相对位置：
| A | B | |
|---|---|---|
| 1 | =T(“Orders.txt”) | /订单序表 |
| 2 | =A1.groups(year(Date):y,month(Date):m; sum(Amount):amt) | /按年月分组汇总 |
| 3 | =A2.derive(amt/amt[-1]:lrr, amt[-1:1].avg():ma) | /计算比上期和移动平均 |
作为用Java解释的脚本语言，SPL提供了JDBC驱动，可以无缝集成进Java应用程中。
简单语句可以像SQL一样直接执行：
…
Class.forName("com.esproc.jdbc.InternalDriver");
Connection conn =DriverManager.getConnection("jdbc:esproc:local://");
PrepareStatement st = conn.prepareStatement("=T(\"D:/Orders.txt\").select(Amount>1000 && Amount<=3000 && like(Client,\"*S*\"))");
ResultSet result=st.execute();
...复杂计算可以存成脚本文件，以存储过程方式调用
…
Class.forName("com.esproc.jdbc.InternalDriver");
Connection conn =DriverManager.getConnection("jdbc:esproc:local://");
Statement st = connection.();
CallableStatement st = conn.prepareCall("{call splscript1(?, ?)}");
st.setObject(1, 3000);
st.setObject(2, 5000);
ResultSet result=st.execute();
...将脚本外置于Java程序，一方面可以降低代码耦合性，另一方面利用解释执行的特点还可以支持热切换，业务逻辑变动时只要修改脚本即可立即生效，不像使用Java时常常要重启整个应用。这种机制特别适合编写微服务架构中的业务处理逻辑。
推荐学习：《java视频教程》
Das obige ist der detaillierte Inhalt vonMachen Sie sich mit der Open-Source-Bibliothek SPL für die strukturierte Java-Datenverarbeitung vertraut. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
