🤰🏾 📌 🎅🏽 Groovy पर अपनी भाषा बनाएं ☁️ 🎍 🏢

अनिवार्य प्रोग्रामिंग भाषाओं की मुख्य समस्या प्राकृतिक भाषाओं से उनकी कम निकटता है।

OOP ने इस समस्या को भागों में हल किया, डेटा और लॉजिक को ऑब्जेक्ट्स की कक्षाओं में सॉर्ट किया, लेकिन इसे समझना अभी भी मुश्किल है। यहां मुख्य समस्या यह है कि वस्तुगत पदानुक्रम और नेस्टेड विधि कॉल के साथ काम करने के लिए आवश्यक नहीं है।

उदाहरण के लिए, मेरे पास ग्राहकों के लिए उत्पाद ऑर्डर के साथ काम करने के लिए कक्षाओं का एक पदानुक्रम है:

//  class Customer { int inn String name String address String phone } //  class Customers { Customer findByInn(inn) void add(Customer customer) } //  class Product { String article String name double price } //  class Products { Product findByArticle(article) void add(Product product) } //  class Order { int num Customer customer List<OrderDetail> details = [] OrderDetail findByPos(pos) void add(OrderDetail detail) } //   class OrderDetail { int pos Product product def count = 1 def getSum() { count * product.price } } //  class Orders { Order findByNum(num) void add(Order order) }

नौकरी विवरण का व्यावसायिक तर्क स्वयं इस तरह दिखाई देगा:

 //  - def customers = new Customers() def products = new Products() def orders = new Orders() //   customers.add(new Customer(inn: 1234, name: "", address: "", phone: "+74951002030")) //   products.add(new Product(article: "a100", name: " 1", price: 100.00)) products.add(new Product(article: "a200", name: " 2", price: 200.00)) //   def order = new Order(num: 1, customer: customers.findByInn(1234)) order.add(new OrderDetail(pos: 1, product: products.findByArticle("a100"), count: 1)) order.add(new OrderDetail(pos: 2, product: products.findByArticle("a200"), count: 1)) orders.add(order)

ग्रूवी की कृपा के लिए धन्यवाद, कोड काफी सरल और पठनीय है। लेकिन उदाहरण जटिल नहीं है। वास्तविक जीवन में, वस्तुओं के प्रबंधन के लिए जटिल व्यावसायिक तर्क लिखते समय, कोड भारी और खराब पढ़ा जाएगा। यह पता चला है कि मेरे पास एक निश्चित एपीआई है जिसे केवल कोड से नियंत्रित किया जाता है, यह लिखना मुश्किल है और पढ़ना आसान नहीं है।

ग्रूवी के पास अपनी स्वयं की घोषणात्मक मार्कअप भाषा लिखकर अपने जीवन को सरल बनाने का अवसर है ताकि आप आसानी से वर्णन कर सकें कि आप कैसे आवश्यक कार्य करते हैं। यहां एक मार्कअप भाषा में उपर्युक्त व्यावसायिक तर्क का एनालॉग कैसा दिखेगा:

 AddCustomer(inn: 1234, name: "", address: "", phone: "+74951002030") AddProduct(article: "a100", name: " 1", price: 100.00) AddProduct(article: "a200", name: " 2", price: 200.00) AddOrder(num: 1, customer: 1234) { Detail(pos: 1, product: "a100", count: 1) Detail(pos: 2, product: "a200", count: 1) }

इस तरह के कोड को टिप्पणियों की ज़रूरत नहीं है - इसकी उच्च पठनीयता है।

इस भाषा को लागू करने के लिए, आपको ग्रूवी में एक बिल्डर लिखना होगा। ग्रूवी के पास एक अमूर्त वर्ग बिल्डरसुपोर्ट है, जिसमें से आपको अपना खुद का बिल्डर बनाने की आवश्यकता है। विरासत में मिली कक्षा में, आपको कई तरीकों को ओवरराइड करना होगा जो कोड में मार्कअप भाषा को पार्स करते समय ग्रूवी स्वचालित रूप से कॉल करेंगे। यहां बताया गया है कि बिल्डर वर्ग कैसा दिखेगा:

 public class MyBuilder extends BuilderSupport { public Customers customers public Products products public Orders orders //     protected void setParent(Object parent, Object child) { } //     protected Object createNode(Object name) { if (name != "call") throw new Exception("Node required parameters") new Node(null, name); } //        protected Object createNode(Object name, Object value) { throw new Exception("Node required parameters") } //     protected Object createNode(Object name, Map attributes) { //     Node parent = getCurrent() def result //    switch (name) { case "AddCustomer": result = addCustomer(attributes) break case "AddProduct": result = addProduct(attributes) break case "AddOrder": result = addOrder(attributes) break case "Detail": if (parent == null || parent.name() != "AddOrder") throw new Exception( "Detail must be specified with only AddOrder") result = addOrderDetail(parent.value(), attributes) break defailt: throw new Exception("Unknown node ${name}") } new Node(null, name, attributes, result); } //          protected Object createNode(Object name, Map attributes, Object value) { throw new Exception("Node ${name} can not support objects") } //   def addCustomer(Map params) { def customer = new Customer(inn: params.inn, name: params.name, address: params.address, phone: params.phone) customers.add(customer) println "Added customer ${customer.inn}: ${customer.name}" customer } //   def addProduct(Map params) { def product = new Product(article: params.article, name: params.name, price: params.price) products.add(product) println "Added product ${product.article}: ${product.name}" product } //   def addOrder(Map params) { def order = new Order(num: 1, customer: customers.findByInn(params.customer)) orders.add(order) println "Added order ${order.num} from customer ${order.customer.name}" order } //    def addOrderDetail(Order order, Map params) { def count = params.count?:1 def detail = new OrderDetail(pos: params.pos, product: products.findByArticle(params.product), count: count) order.add(detail) println "Added into order ${order.num} detail pos ${detail.pos} " + "with product ${detail.product.name}" detail } }

इस वर्ग में दो अमूर्त विधियाँ सेटपैरेंट और क्रिएटनोड ओवरराइड हैं। setParent उस समय कहा जाता है जब मूल नोड नोड को सौंपा जाता है और मेरे तर्क में उपयोग नहीं किया जाता है। लेकिन createNode में यह प्रत्येक मार्कअप तत्व के लिए कहा जाता है। मार्कअप नोड के विवरण के सिंटैक्स के आधार पर, चार अतिभारित createNode विधियों में से एक कहा जाता है। मेरा सिंटैक्स मानता है कि तत्वों में हमेशा पैरामीटर होते हैं। इसलिए, मैंने वांछित विधि में आवश्यक कार्यक्षमता दर्ज की और अन्य सभी createNode विधियों में अपवाद जोड़े। यह आपको विधि कॉल का वर्णन करने के लिए गलत सिंटैक्स को नियंत्रित और समाप्त करने की अनुमति देगा। रूट लेबल कॉल के लिए एकमात्र अपवाद बनाया गया था, जो बिल्डर के मापदंडों के बिना शुरू होने पर स्वचालित रूप से पहले बनाया जाता है। मैंने निर्माता के साथ बिल्डर वर्ग का विस्तार किया, जिसमें ग्राहक सूची, उत्पादों और ऑर्डर की वस्तुओं को स्थानांतरित किया जाता है। व्यावसायिक संस्थाओं को जोड़ने के लिए वर्ग विधियों में भी वर्णित है। कुछ भी जटिल नहीं है - सब कुछ कोड में और इसमें टिप्पणियों में उल्लेखनीय रूप से दिखाई दे रहा है।

और यहाँ परिणाम की जाँच के साथ बनाई गई मार्कअप भाषा का उपयोग करने के लिए अंतिम कोड है:

 //  - def customers = new Customers() def products = new Products() def orders = new Orders() //    def myApi = new MyBuilder(customers: customers, products: products, orders: orders) //   myApi { AddCustomer(inn: 1234, name: "", address: "", phone: "+74951002030") AddProduct(article: "a100", name: " 1", price: 100.00) AddProduct(article: "a200", name: " 2", price: 200.00) AddOrder(num: 1, customer: 1234) { Detail(pos: 1, product: "a100", count: 1) Detail(pos: 2, product: "a200", count: 1) } } //   println "\n*** Result ***" println "Customers:" println customers println "Products:" println products println "Orders:" println orders

परिणाम:

ग्राहक को जोड़ा गया 1234: ग्राहक
जोड़ा गया उत्पाद a100: उत्पाद 1
जोड़ा गया उत्पाद a200: उत्पाद 2
ग्राहक ग्राहक से जोड़ा गया आदेश 1
उत्पाद 1 आइटम के साथ आदेश 1 विस्तार स्थिति 1 में जोड़ा गया
उत्पाद आइटम 2 के साथ क्रम 1 विवरण 2 स्थिति में जोड़ा गया

*** परिणाम ***
ग्राहक:
{inn = 1234, नाम = ग्राहक, पता = रूस, फोन = + 74951002030}
उत्पाद:
{लेख = a100, नाम = आइटम १, मूल्य = १००.०}
{लेख = a200, नाम = उत्पाद २, मूल्य = २००.०}
आदेश:
{संख्या = 1, ग्राहक = ग्राहक,
विस्तार = {स्थिति = 1, उत्पाद = उत्पाद 1, गिनती = 1, योग = 100.0};
{स्थिति = २, उत्पाद = उत्पाद २, गिनती = १, योग = २००.०}}

सब कुछ काम करता है :)

संक्षेप में, हम कह सकते हैं कि बिल्डरों का दायरा बड़ा है। उदाहरण के लिए, अब मैं अपने ओपन सोर्स प्रोजेक्ट GETL (Groovy पर आधारित ETL) के लिए डेटा परिवर्तन का वर्णन करने के लिए इसके आधार पर एक भाषा विकसित कर रहा हूं। बिल्डर का उपयोग करके, आप आसानी से एक सिंटैक्स विकसित कर सकते हैं जो आपको कोड में एसक्यूएल प्रश्नों को इकट्ठा करने या एक पदानुक्रमित देशी स्वरूपित जानकारी प्रदर्शित करने की अनुमति देता है। हां, और मुझे लगता है कि नियमित XML / JSON मार्कर अब रहस्यों का गठन नहीं करते हैं। मार्कअप भाषा का उपयोग न केवल ग्रूवी प्रोग्राम कोड में किया जा सकता है, बल्कि वस्तुओं और कार्यों का वर्णन करने के लिए ब्लॉक के रूप में भी किया जाता है जो अलग-अलग फ़ाइलों में निकाले जाते हैं। विवरण ब्लॉकों को रनटाइम में फ़ाइलों से सीधे पढ़ा जा सकता है और EVAL विधि का उपयोग करके निष्पादित किया जा सकता है। चूंकि ब्लॉक अच्छी तरह से औपचारिक हैं, उनके लिए आप साधारण उपयोगकर्ताओं द्वारा व्यावसायिक तर्क विकसित करने के लिए आसानी से अपना स्वयं का GUI लिख सकते हैं।

कई उदाहरण हैं। लेकिन सबसे महत्वपूर्ण बात, यह मत भूलो - उपरोक्त सभी जावा में बिना किसी प्रयास के ठीक काम करता है! ग्रूवी में, कोई भी जावा वर्गों और विधियों को अपनी मार्कअप भाषा के साथ टाई करने के लिए परेशान नहीं करता है, जिसमें व्यावसायिक तर्क लिखने के लिए, जो आगे जावा अनुप्रयोगों में उपयोग किया जाता है। ये विशेषताएं जावा में जादुई ग्रूवी का उपयोग करने के लिए शुरू होने लायक हैं :)

लेख में प्रयुक्त पूर्ण ग्रंथ यहाँ से कक्षा द्वारा डाउनलोड करें ।

Groovy पर अपनी भाषा बनाएं

More articles: