JavaFX के लिए ग्रूवी बनाम जावा

JavaFX अच्छा है!

सबसे पहले, JavaFX के बारे में कुछ शब्द। हमें उसके साथ काम करना पसंद था।

आधुनिक एपीआई । "बिल्डरों" के बिना भी, सब कुछ बहुत आधुनिक दिखता है।

कुल डेटा संचालित विकास । इसे अपनाओ। डेटा के एक समूह पर आधारित तर्क कबाड़, गेटर्स / सेटर से कोड को साफ करता है - "नीचे!"। डेटा परिवर्तन की घटनाओं, दो-तरफ़ा "बाध्यकारी" के साथ काम करें।

FXML। प्रोटोटाइपिंग के लिए बहुत अच्छी बात है। डिजाइनर समझता है कि ओरेकल से एक अच्छा दृश्य उपकरण है - "जावाएफएक्स सीन बिल्डर"। मैंने ध्यान दिया कि तब हम नियमित कोड के रूप में एफएक्सएमएल को फिर से लिखना चाहते थे। एफएक्सएमएल को कोड की तुलना में बनाए रखना आसान है - आपको हमेशा दो फ़ाइलों, कोड और एफएक्सएमएल को संपादित करना होगा। साथ ही, कोड का उपयोग करते समय, वंशानुक्रम का उपयोग करना आसान होता है।

नोड्स। घटकों की संरचना। आप एक पेड़ पर दौड़ सकते हैं। आप लुकअप द्वारा खोज सकते हैं ()। जैसे डोम में। सिर्फ jQuery लिखें।

सीएसएस। यह वास्तव में एक बात है। एक सामान्य सीएसएस-फ़ाइल के माध्यम से घटकों को "फेंक दें"। आईडी schnicks, CSS कक्षाएं, चयनकर्ता और छद्म चयनकर्ता।

पाठ इंजन जटिल ग्रंथों के लिए बहुत अच्छा इंजन।

WebView। हम वेबकिट इंजन पर परिष्कृत घटकों को लागू करते हैं। इसके बारे में पिछले लेख में पढ़ें ।

जो बहुत अच्छा न हो

यह अच्छा है। क्या बुरा है? एक समय में JavaFX स्क्रिप्ट का आविष्कार नहीं किया गया था। गेटर्स और सेटर के माध्यम से बिंडेबल डेटा तक पहुंचने के लिए फ़ील्ड बनाना एक कदम पीछे और कल है। जावा यहां बहुत अच्छा नहीं है। Java 8 में लैम्ब्डा एक्सप्रेशन हैं, लेकिन उनकी उपस्थिति भी इस सवाल का जवाब है कि जावा के साथ कुछ करने की जरूरत है और अधिक कार्डिनल समाधान के बारे में सोचने का अवसर।

ग्रूवी!

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

JVM के लिए अच्छी और सुंदर भाषाओं का एक समूह है, लेकिन ऐसा हुआ कि ग्रूवी ने हमें सूट किया। और हम कोष्ठक, एनोटेशन से प्यार करते हैं और हम यहां अपने आप में कुछ तोड़ना नहीं चाहते हैं। साथ ही, मुझे व्यक्तिगत रूप से ग्रूवी का उपयोग करने का सात साल का अनुभव था, और जब टीम में एक विशेषज्ञ होता है, तो इसका उपयोग करना बेहतर होता है, बजाय इसके कि कुछ पूरी तरह से अज्ञात हो।

वैसे, ग्रोवी भाषाओं की लोकप्रियता ( TIOBE के अनुसार) के मामले में 18 वाँ स्थान लेता है।

हमारी प्रथाओं

अब कुछ उदाहरण देखते हैं। हम अपने प्रोजेक्ट से कॉपी करते हैं, कोड असली है।

घटक विन्यास

बस कोड के माध्यम से घटक का एक उदाहरण बनाएं और इसे कॉन्फ़िगर करें।
जावा में, हमें मूल्यों को निर्दिष्ट करने के लिए, कदम से कदम, लाइन से लाइन करना था।

Button button = new Button(); button.setFocusTraversable(false); button.setLayoutX(23); button.setPrefHeight(30); button.setPrefWidth(30); button.setText("ADD"); 

यदि आप ग्रूवी को फिर से लिखते हैं तो यह कैसा दिखता है?

 Button button = new Button(focusTraversable: false, layoutY: 23, prefHeight: 30, prefWidth: 30, text: "Add") 

ग्रूव्स, मैं आपको याद दिलाता हूं जो नहीं जानते हैं, आपको सेट / उपसर्ग के बिना एक्सेस विधियों (गेटर्स, सेटर) तक पहुंचने की अनुमति देता है। यही है, अगर कक्षा में एक सेटटेक्स्ट विधि है, तो इसे मूल्य के एक साधारण असाइनमेंट के माध्यम से कहा जाता है - पाठ = "जोड़ें"। इसके अलावा, जब ग्रूवी कक्षाओं को संकलित किया जाता है, तो गेटर्स और सेटर स्वचालित रूप से सार्वजनिक क्षेत्रों में जुड़ जाते हैं। इसलिए, इसके लिए कोई वास्तविक आवश्यकता नहीं होने पर, एक खांचे से सेट को प्राप्त करने / प्राप्त करने के लिए कॉल करना कोई गुप्त बात नहीं है।

और निर्माण मापदंडों में, आप जोड़े - नाम: मान पारित कर सकते हैं (वास्तव में, यह सामान्य हैशपॉप है और यहां वाक्यविन्यास ग्रूवी मैप्स है - [key1: value1, key2: value])।

इसके अलावा, यह महत्वपूर्ण है कि आईडीईए हमें यह सब बताता है, डेटा प्रकार और एक्सेस प्रतिबंध को मान्य करता है।

घटकों को कॉन्फ़िगर करने का यह तरीका तुरंत बताता है कि घटकों की संरचना को एक बार में कॉन्फ़िगर करना असंभव है?

आप कर सकते हैं!

 menus.addAll( new Menu(text: "File", newItems: [ new MenuItem( text: "New Window", onAction: { t -> ApplicationUtil.startAnotherColtInstance() } as EventHandler<ActionEvent>, accelerator: new KeyCodeCombination(KeyCode.N, KeyCombination.SHORTCUT_DOWN) ), new Menu(text: "New Project", newItems: [ newAs = new MenuItem( text: "New AS Project", id: "new-as", onAction: { t -> ProjectDialogs.newAsProjectDialog(scene, false) } as EventHandler<ActionEvent> ), newJs = new MenuItem( text: "New JS Project", id: "new-js", onAction: { t -> ProjectDialogs.newJsProjectDialog(scene, false) } as EventHandler<ActionEvent> ) ]), new SeparatorMenuItem(), new MenuItem( text: "Open Project", onAction: { t -> ProjectDialogs.openProjectDialog(scene, false) } as EventHandler<ActionEvent>, accelerator: new KeyCodeCombination(KeyCode.O, KeyCombination.SHORTCUT_DOWN) ), recentProjectsSubMenu = new Menu(text: "Open Recent", newItems: [ clearRecentProjects = new MenuItem( text: "Clear List", onAction: { t -> RecentProjects.clear() } as EventHandler<ActionEvent> ), ]), new SeparatorMenuItem(), save = new MenuItem( text: "Save Project", id: "save", onAction: { t -> ProjectDialogs.saveProjectDialog() } as EventHandler<ActionEvent>, accelerator: new KeyCodeCombination(KeyCode.S, KeyCombination.SHORTCUT_DOWN), disable: true ), saveAs = new MenuItem( text: "Save As...", onAction: { t -> ProjectDialogs.saveAsProjectDialog(scene) } as EventHandler<ActionEvent>, accelerator: new KeyCodeCombination(KeyCode.S, KeyCombination.SHORTCUT_DOWN, KeyCombination.SHIFT_DOWN), ), new MenuItem( text: "Close Project", onAction: { t -> ProjectDialogs.closeProjectDialog() } as EventHandler<ActionEvent>, accelerator: new KeyCodeCombination(KeyCode.W, KeyCombination.SHORTCUT_DOWN), ), new SeparatorMenuItem(), new MenuItem( text: "Exit", onAction: { t -> ApplicationUtil.exitColt() } as EventHandler<ActionEvent> ), ]), new Menu(text: "Help", newItems: [ new MenuItem( text: "Open Demo Projects Directory", onAction: { t -> ProjectDialogs.openDemoProjectDialog(scene) } as EventHandler<ActionEvent> ), new MenuItem( text: "Open Welcome Screen", onAction: { t -> ProjectDialogs.openWelcomeScreen(scene) } as EventHandler<ActionEvent> ), ]) ) 

ऐसा कोड एफएक्सएमएल से कम पठनीय नहीं दिखता है। इसके अलावा, यहां, जगह में, आप सभी ईवेंट हैंडलर का वर्णन कर सकते हैं, जो एफएक्सएमएल पर नहीं किया जा सकता था। और ऐसे कोड को बनाए रखना आसान है।

गतिशील गुण और विधियाँ

चौकस पाठक पूछेगा, मेनू फ़ील्ड "newItems" के लिए क्या है? हां, मेनू वर्ग में ऐसी कोई विधि नहीं है। और हमने ऐसी विधि जोड़ी है, क्योंकि हम केवल आइटम फ़ील्ड पढ़ सकते हैं, लेकिन हम इसे असाइन नहीं कर सकते हैं। इसमें "सेटइमेट्स ()" विधि नहीं है, लेकिन इसमें केवल "getItems ()" है और आप एक नया मान असाइन नहीं कर सकते। केवल-पढ़ने के लिए। एक संरचना के रूप में मेनू को कॉन्फ़िगर करें, हमने एक गतिशील क्षेत्र जोड़ा।

इस तरह के क्षेत्र को जोड़ना बहुत सरल है, लेकिन हमारी जावा इकाई ने लंबे समय से इस तरह के राजद्रोह का विरोध किया है। हमने बहुत सी साइकिल का आविष्कार किया, जब तक कि हम गतिशीलता का उपयोग करने की आवश्यकता के तथ्य के साथ सामंजस्य नहीं कर पाए। और सब कुछ सरल और निडर हो गया।

गतिशील क्षेत्रों को जोड़कर हम एक अलग श्रेणी GroovyDynamicMethods में चले गए हैं। यहाँ उसका कोड है:

 class GroovyDynamicMethods { private static inited = false static void init() { if(inited)return inited = true addSetter(javafx.scene.Node, "newStyleClass", { String it -> styleClass.add(it) }) addSetter(Parent, "newChildren", {List<MenuItem> it -> children.addAll(it) }) addSetter(Menu, "newItems", {List<MenuItem> it -> items.addAll(it) }) } private static void addSetter(Class clazz, String methodName, Closure methodBody) { addMethod(clazz, "set" + methodName.capitalize(), methodBody) } private static void addMethod(Class clazz, String methodName, Closure methodBody) { ExpandoMetaClass exp = new ExpandoMetaClass(clazz, false) exp."$methodName" = methodBody exp.initialize() clazz.metaClass = exp } } 

जैसा कि आप देख सकते हैं, हमें केवल संरचना के माध्यम से घटक कॉन्फ़िगरेशन का समर्थन करने के लिए तीन तरीकों को जोड़ने की आवश्यकता थी।

इसके अलावा हमने यह समझने के लिए IDEA सिखाया कि कक्षाओं में ये गतिशील क्षेत्र हैं।



अब IDEA ऐसे क्षेत्रों के अस्तित्व से अवगत है जैसे कि वे JavaFX API में मौजूद हैं।

Bindable गुण के साथ कार्य करना

डेटा बाइंडिंग एक अद्भुत चीज है। हमारी टीम इस मंत्र का उपयोग करती है - "यदि बंधन के माध्यम से कुछ किया जा सकता है, तो इसे बंधन के माध्यम से करें।" "... तो बाद में इसे फिर से करने के लिए नहीं।"

बैंडिंग आपको एक डेटा मॉडल और घटकों को संबद्ध करने की अनुमति देता है। यूआई घटकों में स्वयं बाध्यकारी गुण होते हैं जो मॉडल डेटा के साथ जुड़े हो सकते हैं या इन गुणों तर्क के परिवर्तन पर निर्माण कर सकते हैं - डेटा परिवर्तन घटनाओं की सदस्यता लें।

एक साधारण चेकबॉक्स उदाहरण:

 CheckBox checkBox = new CheckBox(); checkBox.selectedProperty().bindBidirectional(selectedProperty); 

और यहाँ हम चेकबॉक्स पर क्लिक करने की घटना पर प्रतिक्रिया करते हैं:

 CheckBox checkBox = new CheckBox(); checkBox.selectedProperty().addListener(new ChangeListener<Boolean>() { @Override public void changed(ObservableValue<? extends Boolean> value, Boolean before, Boolean after) { System.out.println("value = " + value); } }); 

उपयोग सुविधाजनक है। ऐसे गुणों का वर्णन करना बहुत सुविधाजनक नहीं है।

जावा ऐसा परिदृश्य प्रदान करता है (IDEA कोड स्वतः उत्पन्न होता है)।

 private StringProperty name = new SimpleStringProperty(); //   //     (     ) public StringProperty nameProperty() { return name; } //    public String getName() { return name.get(); } //       public void setName(String name) { this.name.set(name); } 

सब कुछ ठीक हो जाएगा, और आईडीई हमारे लिए इस तरह का कोड तैयार करता है। अच्छा, क्या यह मूर्खता नहीं है? हमें यह सब देखने की आवश्यकता क्यों है? इस सब बकवास के पीछे हम अपने तर्क नहीं देखते हैं।

समाधान! हम एएसटी परिवर्तन लेते हैं जो हमारे लिए इस कोड को उत्पन्न करता है। संकलन करते समय।

हमारी संपत्ति (जिसे हमने जावा में 10 लाइनों के साथ वर्णित किया है) एक रेखा में ग्रूवी में बदल जाती है और इस तरह दिखाई देती है:

 @FXBindable String name; 

@FXBindable आप GroovyFX में ले सकते हैं, या आप हमारा ले सकते हैं।
हमने इस एनोटेशन को भुनाया और आप इसे गीथूब से ले सकते हैं।

साथ ही, उसी परियोजना में आपको एक्सटेंशन .gdsl के साथ एक फ़ाइल मिलेगी , जो IDEA को इस एनोटेशन - ऑटोकलाइट, आदि का उपयोग करना सिखाएगी।

इस तरह के परिवर्तन से सेटनाम, गेटनेम, गेटनामप्रोपरेटरी मेथड भी बनते हैं। साथ ही, नाम () पद्धति भी जोड़ी गई है, जो आपको कम अक्षर लिखकर भी क्षेत्र तक पहुंचने की अनुमति देती है। स्वाद, लेकिन सबसे अधिक बार हम इस विशेष विधि का उपयोग करते हैं।

 this.nameInput.textProperty().bindBidirectional(this.name()) // this.name() -     name 

अनाम कक्षाओं के साथ नीचे

मेनू उदाहरण में, हम गुमनाम कक्षाओं के माध्यम से घटनाओं की सदस्यता लेते हैं। मेनू संरचना का एक उदाहरण दिखाता है कि ईवेंट हैंडलर एक "शेल" है।

 onAction: { t -> ProjectDialogs.newAsProjectDialog(scene, false) } as EventHandler<ActionEvent> 

"के रूप में EventHandler" सभी जादू है कि खजाने की बॉडी EventHandler वर्ग के संभाल विधि के शरीर के लिए ले जाता है। घटनाओं को संभालने के लिए इस तरह के एक छोटे से रिकॉर्ड का उपयोग कोड क्लीनर बनाता है। वैसे, स्मार्ट आईडिया एक त्वरित बदलाव "क्विक टू इंस्टेंट इंस्टेंटेशन" क्विकफिक्स प्रदान करता है। यदि आप क्लास के हैंडलर को कई तरीकों से ओवरलोड करने की आवश्यकता होती है, तो आप मैप के माध्यम से ([हैंडलर 1: {}, हैंडलर 2: {}]) एक और लेखन का उपयोग कर सकते हैं।

XML का काम

हमारी परियोजना में, हमें XML में डेटा मॉडल को क्रमबद्ध करना और इसे डिस्क से लेना आवश्यक है। पहले हम आदत से बाहर एक्सस्ट्रीम का उपयोग करना चाहते थे, लेकिन हमें एक अधिक प्रबंधनीय संरचना की आवश्यकता थी - जावाएफएक्स के बाइंडेबल गुण बड़े हैं, और कन्वर्टर्स लिखने के लिए बहुत आलसी हैं। JAXB को देखा, तो बहुत बुरा। इसके अलावा Groovy XML क्रमांकन।

XmlSlurper बिल्ट-इन Groovy SDK आया।

प्रत्येक बीन मॉडल दो तरीकों को लागू करता है - buildXml और buildModel - क्रमांकन और डीरियलाइज़ेशन

 Closure buildXml(Project project) { return { 'launcher'(launcherType) 'browser-path'(browserPath) 'nodejs-path'(nodejsPath) 'console-value'(console) } } @Override void buildModel(Object node) { launcherType = node.'launcher' browserPath = node.'browser-path' nodejsPath = node.'nodejs-path' console = node.'console-value' } 

BuildXml विधि एक संरचना को एक बुकमार्क के रूप में वापस करती है। यहां जादू गैर-मौजूद तरीकों और गुणों को कॉल करने और असाइन करने में है। यदि कोई भी नोन्टेंसेन्ट विधि नहीं कहलाती है, तो एक प्रॉपर्टी को एक बच्चे के नोड के रूप में बनाया जाता है, यदि कोई मान किसी गैर-संबंधित फ़ील्ड को असाइन किया जाता है, तो एक XML विशेषता बनाई जाती है, यदि कोई नॉनएक्सेंसेन्ट विधि नहीं है और एक पैरामीटर के रूप में इसे पास किया जाता है, तो एक एम्बेडेड XML नोड संरचना बनाई जाती है।

BuildModel विधि नोड तर्क लेती है, और डायनेमिक अनुरोधों के माध्यम से नोड को पार्स करती है।

फाइलों के साथ काम करें

हमारा प्रोग्राम फ़ाइल सिस्टम के साथ बहुत काम करता है। Groovy का उपयोग करके हम IO कोड को बहुत कम करने में सक्षम थे। हमें हर नैनोसेकंड को बचाने की आवश्यकता नहीं थी, हमारे पास एक व्यस्त वेब सर्वर नहीं था, और ग्रूवी ने हमारे लिए जो काम किया वह हमारे साथ ठीक था।

ग्रूवी एसडीके फ़ाइल सहित जावा कक्षाओं के लिए कई उपयोगी एक्सटेंशन प्रदान करता है। उदाहरण के लिए, "टेक्स्ट" फ़ील्ड के माध्यम से किसी फ़ाइल की सामग्री को बस लिखने / पढ़ने की क्षमता, या "स्प्लिटएचलाइन" का उपयोग करके फ़ाइल की पंक्तियों के साथ काम करना।

इसके अलावा, हमें AntBuilder पसंद आया, जिसका उपयोग फ़ाइलों को खोजने और फ़िल्टर करने के लिए भी किया जा सकता है।

निम्न उदाहरण फ़ाइलों की प्रतिलिपि बनाता है:

 def ant = new AntBuilder() ant.sequential { myDir = "test/to/" mkdir(dir:myDir) copy(todir:myDir) { fileset(dir:"text/from/") { include(name:"**/*.*") } } } 

आप फ़ाइल का उपयोग करके फ़ाइलों के लिए खोज कर सकते हैं

 def ant = new AntBuilder() def scanner = ant.fileScanner { fileset(dir: file) { include(name: "**/*.jpg") } } scanner.each{ printlt(it) } 

और निश्चित रूप से AntBuilder अपने सभी एक्सटेंशन और क्षमताओं के साथ एक पूर्ण ANT है। अभी और अध्ययन करना बाकी है। ग्रैडल AntBuilder का भी उपयोग करता है, और यह तथ्य कि वहां आप "ट्विस्ट" कर सकते हैं, वह प्रभावशाली है।

GPath का उपयोग नोड्स के साथ काम करने के लिए

जावाएफएक्स में घटकों की संरचना के बाद से, हमने संग्रह के रूप में नोड्स के लिए अनुरोधों का उपयोग किया। इस दृष्टिकोण के साथ, बड़ी संख्या में छोरों से छुटकारा पाकर, हमने अपने कोड को बहुत कम कर दिया।

उदाहरण के लिए, जावा में स्क्रॉलिंग हटाने के लिए:

 webView.getChildrenUnmodifiable().addListener(new ListChangeListener<Node>() { @Override void onChanged(ListChangeListener.Change<? extends Node> change) { Set<jNode> scrolls = webView.lookupAll(".scroll-bar"); for (Node scroll : scrolls) { scroll.setVisible(false); } } }); 

ग्रूवी पर एक ही बात:

 webView.childrenUnmodifiable.addListener({ change -> webView.lookupAll(".scroll-bar")*.visible = false } as ListChangeListener) 

लड़ना एनपीई

ऑपरेटर "?" - हमारी राय में, केवल एक, आप जावा से ग्रूवी पर स्विच करने के बारे में सोच सकते हैं।

 model?.projectSettings?.projectPaths?.livePaths?.each{ println(it) } 

हम इसे जावा में अनुवाद करते हैं और कोड की कम से कम बीस लाइनें प्राप्त करते हैं।

निष्कर्ष

शायद यही वह सब है जिसे हम याद रख सकते हैं। बेशक, हमने अपनी परियोजना में अन्य Groovy "उपहार" का उपयोग किया है, लेकिन यदि आप सब कुछ सूचीबद्ध करते हैं, तो हम लेख के दायरे से परे जाएंगे, और Groovy पर बहुत सारी पाठ्यपुस्तकें हैं।

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

Codeorchestra.com परियोजना स्थल