ग्रूवी प्रेरणा - अंतर महसूस करें

क्यों ग्रोवी

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



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

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

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

जावाबीन और ग्रूवी

जावा का थोड़ा सा सीखने और एनकैप्सुलेशन की मूल बातें जानने के बाद, कोई फर्क नहीं पड़ता कि किस क्रम में ये दोनों क्रियाएं पूरी हो गई हैं, हम में से अधिकांश को जावाबीन लिखने की आवश्यकता के साथ सामना करना पड़ रहा है - वर्ग फ़ील्ड बनाना और "पसंदीदा" गेटर्स / सेटर जनरेट करना। इसके लिए IDE में, ऐसा लगता है, यहां तक ​​कि HotKey ने भी किया। नीचे जावा और ग्रूवी में क्रमशः जावाबीन है।

//Java

import java.util.Date;



public class Employee {

private String firstName;

private String lastName;

private Date dateSince;



public String getFirstName() {

return firstName;

}



public void setFirstName(String firstName) {

this.firstName = firstName;

}



public String getLastName() {

return lastName;

}



public void setLastName(String lastName) {

this.lastName = lastName;

}



public Date getDateSince() {

return dateSince;

}



public void setDateSince(Date dateSince) {

this.dateSince = dateSince;

}

}







//Groovy

class Employee {

String firstName

String lastName

Date dateSince

}







यह Groovy में जावा बनाम 5 में 31 लाइनें निकला।

और यह मापदंडों के साथ अतिरिक्त निर्माणकर्ताओं के बिना है, ग्रूवी में लेखन जो बिल्कुल भी आवश्यक नहीं है:

def e = new Employee(firstName:'Ivan', lastName:'Petrov')







मुझे बताएं कि निजी कहां है या कि वस्तुओं की स्थिति (-सेटर + कंस्ट्रक्टर) को बदलने का अवसर देने के लिए हमेशा आवश्यक नहीं है? और इस तरह की समस्या @Immutable



एनोटेशन के साथ हल हो जाती है

import groovy.lang.Immutable;



@Immutable class Employee {

String firstName

String lastName

Date dateSince

}



अपवाद

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

प्रतिनिधिमंडल

कोड को छोटा करने के लिए, हमें अक्सर कंटेनर क्लास से हमारे एक या एक से अधिक फ़ील्ड्स पर पुर्ननिर्देशित करना पड़ता है, जो थोड़ा मूर्खतापूर्ण और एक ही प्रकार का होता है।

नीचे एक सरल उदाहरण है जो इस समस्या का समाधान दिखा रहा है।



import java.text.SimpleDateFormat



class Event {

@Delegate Date when

String title, url

}



def df = new SimpleDateFormat("yyyy/MM/dd")



def gr8conf = new Event(title: "GR8 Conference",

url: "http://www.gr8conf.org",

when: df.parse("2009/05/18"))

def javaOne = new Event(title: "JavaOne",

url: "http://java.sun.com/javaone/",

when: df.parse("2009/06/02"))



assert gr8conf.before(javaOne.when)







जैसा कि आप देख सकते हैं, अब आप आसानी से दिनांक वर्ग के तरीकों का उपयोग कर सकते हैं। कोड की शुद्धता को संरक्षित करते हुए अभिव्यक्ति gr8conf.before(javaOne.when)



काफी तार्किक लगती है।

उदाहरण, बेशक, बहुत आदिम है, लेकिन मुझे लगता है कि हर कोई अपने सिर को उन क्षणों में पुन: पेश करने में सक्षम होगा जिसमें यह उसकी मदद कर सकता है।

बंद (बंद)

जावा में कोई क्लोजर नहीं हैं, और जब आप योजनाबद्ध या फिर से स्थानांतरित किए जाते हैं, तो आप बिल्कुल नहीं कह सकते कि वे जावा 8 में दिखाई देंगे। ग्रूवी में, आप उन्हें अब उपयोग कर सकते हैं। मैं यहां बहुत विस्तार से बंद करने पर विचार नहीं करूंगा, मुझे लगता है कि यह एक अलग लेख के लिए एक विषय है, लेकिन मैं सिर्फ एक उदाहरण दूंगा कि कोड को कैसे कम किया जाए।



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



List getStaffWithMuchSalaryThan(List staff, double salary);

List getStaffYoungerThan(List staff, int age);

List getStaffByDepartment(List staff, Dept dept);









प्रत्येक में लगभग एक ही तर्क है: हम चक्र के माध्यम से चलाते हैं, शर्तों के अनुपालन के लिए जाँच करते हैं। यदि यह संतुष्ट हो जाता है, तो हम इसे परिणामी सूची में जोड़ देते हैं।

यही है, जावा में हमारे पास फॉर्म के तीन तरीके हैं:



सार्वजनिक सूची getStaffWithMuchSalaryThan (सूची कर्मचारी, दोहरा वेतन) {

सूची परिणाम = नया ArrayList ();

के लिए (कर्मचारी ई: कर्मचारी) {

if (e.getSalary ()> = वेतन) {

result.add (e);

}

}

वापसी परिणाम;

}



और इसलिए उपरोक्त दो और विधियों के लिए। बेशक, रणनीति पैटर्न का उपयोग करके कोड डिज़ाइन समस्या को हल किया जा सकता है, लेकिन लाइनों की संख्या काफी बड़ी रहेगी।



अब क्लोजर का उपयोग करके एक ही बात लिखने की कोशिश करें।



//

def staff = [

new Employee(firstName: 'A', salary:500, age:20, dept:'K'),

new Employee(firstName: 'B', salary:700, age:30, dept:'K'),

new Employee(firstName: 'C', salary:1000, age:25, dept:'A2') ]



//

def getStaffWithCriteria(staff, criteria) {

result = []

for(e in staff) {

if(criteria(e)) result.add(e)

}

result

}



println getStaffWithCriteria(staff, {e -> e.salary > 600}) // 600

println getStaffWithCriteria(staff, {e -> e.age < 27}) //, 27

println getStaffWithCriteria(staff, {e -> e.dept == 'K'}) // K







// UPD: और एक बाइक के बिना भी, कोड सरल हो जाता है:



Println staff.grep {e -> e.salary> 600}

Println staff.grep {e -> e.age <27}

Println staff.grep {e -> e.dept == 'K'}



धन्यवाद धन्यवाद



परिणाम:

[बी, सी]

[ए, सी]

[ए, बी]

संग्रह के साथ काम करें

ग्रूवी ने सूचियों के साथ काम करना बहुत आसान बना दिया है, उन्हें बनाने से लेकर उन पर चलने तक।



यह काफी तार्किक है:

def list = ['a', 'b', 'c']







जावा कोड के बजाय:



सूची सूची = नया ArrayList ();

list.add ("a");

list.add ("बी");

list.add ("c");



मान लें कि हमें तत्वों को सूचीबद्ध करने की आवश्यकता है:

जावा में:

for(String s: list) {

System.out.println(s);

}







ग्रूवी में:

list.each {println it}







एक जावा लूप इतना आकर्षक नहीं होगा यदि हमें तत्व सूचकांक तक पहुंच की आवश्यकता है। फिर आप नीचे दिए गए फॉर्म के लूप के बिना नहीं कर सकते हैं, या एक अतिरिक्त चर की शुरुआत करके, इसके साथ, लूप के अंदर उस पर वेतन वृद्धि ऑपरेशन कर सकते हैं:

for (int i = 0; i < list.size(); i++) {

System.out.println(i + " - " + list.get(i));

}







ग्रूवी में, इस कार्य का एक सरल समाधान भी है।



list.eachWithIndex {e, i -> println “${i} - ${e}”}







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



इस उद्देश्य के लिए ग्रूवी कोड को सम्मिलित विधि का उपयोग करके बहुत सरल किया जाता है



list.join(', ')







एक लाइन का उत्पादन करेगा: "ए, बी, सी"

प्रोजेक्ट असेंबली

जिन लोगों को विकास के वातावरण की अंतर्निहित कार्यक्षमता के बजाय चींटी, मावेन जैसी परियोजनाओं के निर्माण के लिए उपकरणों का उपयोग करने के लिए उपयोग किया जाता है, उन्हें ग्रैडल की कोशिश करने की सलाह दी जा सकती है। जावा परियोजनाओं के निर्माण के लिए मावेन के लिए मेरे काफी प्यार के बावजूद, ग्रैडल मुझे बहुत अच्छे लगते हैं। दुर्भाग्य से, इस लेख के ढांचे में, ग्रैडल के बारे में अच्छी बात कही जा सकती है। वैसे, कल 19 दिसंबर को संस्करण 0.9 जारी किया गया था, जिसमें कई बदलाव शामिल थे।

निष्कर्ष

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

मुख्य स्रोत

groovy.codehaus.org

www.infoq.com/pretations/Transforming-to-Groovy (आप प्रस्तुति चित्रों को बदलने के लिए इंतजार नहीं कर सकते, आप सुरक्षित रूप से वीडियो पर फुलस्क्रीन दबा सकते हैं)

www.infoq.com/presentations/Industrial-Strength-Groovy

www.asert.com.au/pubs/Groovy/Groovy.pdf