martin fowler

目前，我正在閱讀Martin Fowler撰寫的有關DSL- 特定領域語言的精彩書籍。 圍繞DSL的嗡嗡聲，圍繞輕松支持DSL創建的語言，以及DSL的使用，使我好奇地了解和學習DSL的這一概念。 到目前為止，這本書的使用經驗令人印象深刻。

馬丁·福勒（Martin Fowler）在他的書中提到的DSL定義：

特定領域的語言（名詞）：一種表達能力有限的計算機編程語言，專注于特定領域。

DSL并不是什么新鮮事物，它已經存在了很長時間。 人們使用XML作為DSL的一種形式。 使用XML作為DSL很容易，因為我們有XSD來驗證DSL，有解析器來解析DSL，還有XSLT來將DSL轉換成其他語言。 而且大多數語言為解析XML和填充其域模型對象提供了很好的支持。 諸如Ruby，Groovy等語言的出現增加了DSL的采用。 例如，使用Ruby編寫的Web框架Rails廣泛使用DSL。

Martin Fowler在他的書中將DSL分為內部，外部和語言工作臺。 當我閱讀了內部DSL概念時，我使用Java作為宿主語言在自己的簡單DSL上玩了一些。 內部DSL駐留在宿主語言中，并受宿主語言的語法功能約束。 使用Java作為宿主語言并不能給我真正清晰的DSL，但我已盡力使其更接近可以舒適地理解DSL的形式。

我試圖創建用于創建圖形的DSL。 據我所知，輸入和表示圖形的不同方法是： 鄰接表和鄰接矩陣 。 我一直發現這很難使用，尤其是在Java這樣的語言中，這些語言沒有矩陣作為一等公民。 在這里，我試圖創建一個內部DSL，以用Java填充圖形。

馬丁·福勒（Martin Fowler）在他的書中強調，需要保持語義模型與DSL不同，并引入一種中間表達構建器，該構建器可以從DSL填充語義模型。 通過保持這一點，我能夠通過編寫不同的DSL語法和表達式生成器并同時使用相同的語義模型來實現3種不同形式的DSL。

了解語義模型

在這種情況下，語義模型是Graph類，它包含Edge實例的列表，每個Edge包含從Vertex到Vertex以及權重。 讓我們看一下相同的代碼：

Graph.java

import java.util.ArrayList; import java.util.List; import java.util.Set; import java.util.TreeSet;public class Graph {private List<Edge> edges;private Set<Vertex> vertices;public Graph() {edges = new ArrayList<>();vertices = new TreeSet<>();}public void addEdge(Edge edge){getEdges().add(edge);}public void addVertice(Vertex v){getVertices().add(v);}public List<Edge> getEdges() {return edges;}public Set<Vertex> getVertices() {return vertices;}public static void printGraph(Graph g){System.out.println("Vertices...");for (Vertex v : g.getVertices()) {System.out.print(v.getLabel() + " ");}System.out.println("");System.out.println("Edges...");for (Edge e : g.getEdges()) {System.out.println(e);}} }

Edge.java

public class Edge {private Vertex fromVertex;private Vertex toVertex;private Double weight;public Edge() {}public Edge(Vertex fromVertex, Vertex toVertex, Double weight) {this.fromVertex = fromVertex;this.toVertex = toVertex;this.weight = weight;}@Overridepublic String toString() {return fromVertex.getLabel()+" to "+toVertex.getLabel()+" with weight "+ getWeight();}public Vertex getFromVertex() {return fromVertex;}public void setFromVertex(Vertex fromVertex) {this.fromVertex = fromVertex;}public Vertex getToVertex() {return toVertex;}public void setToVertex(Vertex toVertex) {this.toVertex = toVertex;}public Double getWeight() {return weight;}public void setWeight(Double weight) {this.weight = weight;} }

頂點

public class Vertex implements Comparable<Vertex> {private String label;public Vertex(String label) {this.label = label.toUpperCase();}@Overridepublic int compareTo(Vertex o) {return (this.getLabel().compareTo(o.getLabel()));}public String getLabel() {return label;}public void setLabel(String label) {this.label = label;} }

現在我們已經有了語義模型，讓我們構建DLS。 您應該注意，我不會更改語義模型。 語義模型不應該改變不是硬性規定，而是可以通過添加用于獲取數據或修改數據的新API來發展語義模型。 但是將語義模型緊密綁定到DSL并不是一個好的方法。 將它們分開可以幫助獨立測試語義模型和DSL。

Martin Fowler提出的創建內部DSL的不同方法是：

• 方法鏈接
• 功能順序
• 嵌套函數
• Lambda表達式/閉包

除了功能序列，我已經在本文中說明了3。 但是我在使用Closures / Lambda表達式時使用了Functional Sequence方法。

通過方法鏈接實現內部DSL

我設想我的DSL是這樣的：

Graph().edge().from("a").to("b").weight(12.3).edge().from("b").to("c").weight(10.5)

為了實現這種DSL的創建，我們將必須編寫一個表達式生成器，該表達式生成器允許彈出語義模型并提供使創建DSL 流暢的接口 。

我創建了2個表達式構建器-一個用于構建完整的Graph，另一個用于構建單個邊。 在構建Graph / Edge的過程中，這些表達式生成器保存中間的Graph / Edge對象。 通過在這些表達式生成器中創建靜態方法，然后使用靜態導入在DSL中使用它們，可以實現上述語法。

Graph()開始填充Graph模型，而edge()及其后的一系列方法： from() ， to() ， weight()填充Edge模型。 edge()也會填充Graph模型。

讓我們看一下GraphBuilder，它是用于填充Graph模型的表達式構建器。

GraphBuilder.java

public class GraphBuilder {private Graph graph;public GraphBuilder() {graph = new Graph();}//Start the Graph DSL with this method.public static GraphBuilder Graph(){return new GraphBuilder();}//Start the edge building with this method.public EdgeBuilder edge(){EdgeBuilder builder = new EdgeBuilder(this);getGraph().addEdge(builder.edge);return builder;}public Graph getGraph() {return graph;}public void printGraph(){Graph.printGraph(graph);} }

還有EdgeBuilder，它是用于填充Edge模型的表達式生成器。

EdgeBuilder.java

public class EdgeBuilder {Edge edge;//Keep a back reference to the Graph Builder.GraphBuilder gBuilder;public EdgeBuilder(GraphBuilder gBuilder) {this.gBuilder = gBuilder;edge = new Edge();}public EdgeBuilder from(String lbl){Vertex v = new Vertex(lbl);edge.setFromVertex(v);gBuilder.getGraph().addVertice(v);return this;}public EdgeBuilder to(String lbl){Vertex v = new Vertex(lbl);edge.setToVertex(v);gBuilder.getGraph().addVertice(v);return this;}public GraphBuilder weight(Double d){edge.setWeight(d);return gBuilder;}}

讓我們嘗試一下DSL：

public class GraphDslSample {public static void main(String[] args) {Graph().edge().from("a").to("b").weight(40.0).edge().from("b").to("c").weight(20.0).edge().from("d").to("e").weight(50.5).printGraph();Graph().edge().from("w").to("y").weight(23.0).edge().from("d").to("e").weight(34.5).edge().from("e").to("y").weight(50.5).printGraph();} }

輸出將是：

Vertices... A B C D E Edges... A to B with weight 40.0 B to C with weight 20.0 D to E with weight 50.5 Vertices... D E W Y Edges... W to Y with weight 23.0 D to E with weight 34.5 E to Y with weight 50.5

您是否發現此方法比“鄰接表/鄰接矩陣”方法更易于閱讀和理解？ 這種方法鏈接類似于我不久前寫的Train Wreck模式 。

嵌套功能的內部DSL

在嵌套函數方法中，DSL的樣式不同。 在這種方法中，我會將函數嵌套在函數中以填充語義模型。 就像是：

Graph(edge(from("a"), to("b"), weight(12.3),edge(from("b"), to("c"), weight(10.5) );

這種方法的優點是它的層次結構自然不同于方法鏈接，在方法鏈中，我不得不以不同的方式設置代碼格式。 而且這種方法不會在“表達式”構建器中保持任何中間狀態，即，在解析/執行DSL時，表達式構建器不保存Graph和Edge對象。 語義模型與此處討論的相同。

讓我們看一下此DSL的表達式構建器。

NestedGraphBuilder.java

//Populates the Graph model. public class NestedGraphBuilder {public static Graph Graph(Edge... edges){Graph g = new Graph();for(Edge e : edges){g.addEdge(e);g.addVertice(e.getFromVertex());g.addVertice(e.getToVertex());}return g;}}

NestedEdgeBuilder.java

//Populates the Edge model. public class NestedEdgeBuilder {public static Edge edge(Vertex from, Vertex to, Double weight){return new Edge(from, to, weight);}public static Double weight(Double value){return value;}}

NestedVertexBuilder.java

//Populates the Vertex model. public class NestedVertexBuilder {public static Vertex from(String lbl){return new Vertex(lbl);}public static Vertex to(String lbl){return new Vertex(lbl);} }

如果您已經觀察到上面定義的表達式構建器中的所有方法都是靜態的。 我們在代碼中使用靜態導入來創建我們開始構建的DSL。

注意：我對表達式構建器，語義模型和dsl使用了不同的軟件包。 因此，請根據您使用的軟件包名稱更新導入。

//Update this according to the package name of your builder import static nestedfunction.NestedEdgeBuilder.*; import static nestedfunction.NestedGraphBuilder.*; import static nestedfunction.NestedVertexBuilder.*;/**** @author msanaull*/ public class NestedGraphDsl {public static void main(String[] args) {Graph.printGraph(Graph(edge(from("a"), to("b"), weight(23.4)),edge(from("b"), to("c"), weight(56.7)),edge(from("d"), to("e"), weight(10.4)),edge(from("e"), to("a"), weight(45.9))));} }

輸出為：

Vertices... A B C D E Edges... A to B with weight 23.4 B to C with weight 56.7 D to E with weight 10.4 E to A with weight 45.9

現在來了有趣的部分：如何在DSL中利用即將到來的lambda表達式支持。

使用Lambda表達式的內部DSL

如果您想知道Lambda表達式在Java中的作用，請在此花一些時間，然后再繼續進行操作。

在本示例中，我們還將堅持此處描述的相同語義模型。 該DSL利用功能序列以及使用lambda表達式支持。 讓我們看看我們如何希望最終的DSL像這樣：

Graph(g -> {g.edge( e -> {e.from("a");e.to("b");e.weight(12.3);});g.edge( e -> {e.from("b");e.to("c");e.weight(10.5);});} )

是的，我知道上面的DSL充滿了標點符號，但是我們必須忍受它。 如果您不喜歡它，那么可能會選擇其他語言。

在這種方法中，我們的表達式構建器應接受lambda expression / closure / block，然后通過執行lambda expression / closure / block填充語義模型。 此實現中的表達式生成器以通過方法鏈接在DSL實現中相同的方式維護Graph和Edge對象的中間狀態。

讓我們看一下表達式構建器：

GraphBuilder.java

//Populates the Graph model. public class GraphBuilder {Graph g;public GraphBuilder() {g = new Graph();}public static Graph Graph(Consumer<GraphBuilder> gConsumer){GraphBuilder gBuilder = new GraphBuilder();gConsumer.accept(gBuilder);return gBuilder.g;}public void edge(Consumer<EdgeBuilder> eConsumer){EdgeBuilder eBuilder = new EdgeBuilder();eConsumer.accept(eBuilder);Edge e = eBuilder.edge();g.addEdge(e);g.addVertice(e.getFromVertex());g.addVertice(e.getToVertex());} }

EdgeBuilder.java

//Populates the Edge model. public class EdgeBuilder {private Edge e;public EdgeBuilder() {e = new Edge();}public Edge edge(){return e;}public void from(String lbl){e.setFromVertex(new Vertex(lbl));}public void to(String lbl){e.setToVertex(new Vertex(lbl));}public void weight(Double w){e.setWeight(w);}}

在GraphBuilder您會看到兩行突出顯示的代碼。 它們利用Java 8中引入的功能接口 Consumer 。

現在，讓我們使用上述表達式構建器來創建我們的DSL：

//Update the package names with the ones you have given import graph.Graph; import static builder.GraphBuilder.*;public class LambdaDslDemo {public static void main(String[] args) {Graph g1 = Graph( g -> {g.edge( e -> {e.from("a");e.to("b");e.weight(12.4);});g.edge( e -> {e.from("c");e.to("d");e.weight(13.4);});});Graph.printGraph(g1);} }

輸出為：

Vertices... A B C D Edges... A to B with weight 12.4 C to D with weight 13.4

至此，我結束了這段繁重的代碼。 讓我知道是否您想把它吐到3個帖子中-每個DSL實現一個。 我將其放在一個地方，這樣可以幫助我們比較3種不同的方法。

總結一下：

• • 在這篇文章中，我談到了DSL， 即 Martin Fowler在《 領域特定語言 》一書中提到的DSL。
  • 為實現內部DSL的三種方法分別提供了一種實現：
    • • 方法鏈接
      • 嵌套函數
      • 具有函數序列的Lambda表達式

參考： 使用Java，Java 8創建內部DSL 8 ：在Experiences Unlimited博客中采用了JCG合作伙伴 Mohamed Sanaulla的Martin Fowler的方法 。

翻譯自: https://www.javacodegeeks.com/2013/06/creating-internal-dsls-in-java-java-8-adopting-martin-fowlers-approach.html

martin fowler

總結

以上是生活随笔為你收集整理的martin fowler_用Java和Java 8创建内部DSL，采用Martin Fowler的方法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。