जावा में स्टैंडअलोन क्रॉस-प्लेटफॉर्म मोनोलिथिक कार्यक्रम

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

मुझे साफ-सुथरी वास्तुकला और मजबूत टाइपिंग वाली उच्चस्तरीय भाषाएं भी पसंद हैं। मेरे पसंदीदा जावा और C # हैं। दोनों सी + + की तुलना में डेवलपर को कई फायदे प्रदान करते हैं, दोनों कई चिंताओं से छुटकारा दिलाते हैं। आपको क्या देना है? ओरेकल JVM, .NET या मोनो नामक एक भारी डेक ले जाने से। सभी तीन डेक सैकड़ों मेगाबाइट का वजन रखते हैं और लाइसेंस ऐसा है कि प्रत्येक उपयोगकर्ता को अपने कंप्यूटर की क्षमता को भ्रमित किए बिना, इस चीज़ को स्वयं डाउनलोड करने के लिए मजबूर किया जाता है, और सबसे महत्वपूर्ण बात, एक जावा प्रोग्राम एक बार में जेवीएम के सभी संस्करणों के साथ संगत नहीं हो सकता है, है ना? और अब - हम इस तथ्य पर आते हैं कि सिर्फ एक दोस्त (या एक लाख दोस्तों) के लिए एक कार्यक्रम फेंकना और यह ध्यान रखना कि यह उसके साथ शुरू नहीं होगा। मुझे मुश्किल सेटअप करना है, बैसाखी चलाना है, और मैंने अभी तक .NET का उल्लेख नहीं किया है - एक बार मैंने एक दोस्त को 3 स्थापित संस्करणों को एक बार देखा था, और तीनों को अलग-अलग अनुप्रयोगों की आवश्यकता थी ...

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


बेशक, मैं एक जादूगर नहीं हूं। मुझे सिर्फ एक जादुई कलाकृति मिली। इसे Avian कहा जाता है, जो oss.readytalk.com/avian पर स्थित है , और यह एक हल्का, लेकिन तीसरे पक्ष के JVM कार्यान्वयन है जिसे ओरेकल ने नहीं सुना होगा। यह प्लेटफ़ॉर्म और आर्किटेक्चर के एक समूह का समर्थन करता है, "लाइसेंस लें और जो आप चाहते हैं" लाइसेंस प्राप्त करें, और - नहीं, मेरा इस परियोजना से कोई लेना-देना नहीं है, मेरा कोई योगदानकर्ता भी नहीं है, मैंने अभी सीखा कि इसका उपयोग कैसे करना है और सम्मान के साथ एक शक्तिशाली ज्ञान साझा करना है। हब्र के निवासी। यह भी ध्यान देने योग्य है कि यह एक जेआईटी कंपाइलर है, यानी इसमें प्रतिस्पर्धात्मक रूप से उच्च प्रदर्शन है (हालांकि मैंने इसे अभी तक नहीं मापा है)।

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

0. बुधवार

निर्माण के लिए, हमें पहले यूनिक्स-डेवलपर कमांड-लाइन उपयोगिताओं की आवश्यकता है, विशेष रूप से, जी ++ संकलक। विंडोज उपयोगकर्ताओं के लिए सबसे मुश्किल काम है। मैं विंडोज के तहत MinGW32 का उपयोग अपने अद्भुत MSYS पर्यावरण के साथ एक यूनिक्स टर्मिनल का अनुकरण करने के लिए करता था। MinGW32 में शामिल संकलक 32-बिट हैं, जो किसी तरह परिणामी कार्यक्रम को सीमित करता है। टिप्पणियों में, उन्होंने मुझे बताया कि लंबे समय से एक सुविधाजनक मिंगव-डब्ल्यू 64 था, जो नियमित रूप से अपडेट किया जाता है और जिसमें न केवल एमएसवाईएस है, बल्कि यहां तक ​​कि गिट भी है।

इसके बाद, मैंने सुविधा के लिए स्पॉइलर के तहत प्लेटफ़ॉर्म-विशिष्ट निर्देशों को छिपा दिया।





प्रत्येक ऑपरेटिंग सिस्टम में नीचे की रेखा वह होनी चाहिए जो आप कमांड लाइन पर टाइप करते हैं

 > g++ 

और प्रतिक्रिया में आप कुछ इस तरह देखते हैं

 g++: fatal error: no input files 

इस तरह के संदेश का मतलब है कि संकलक लड़ाई के लिए तैयार है और स्रोत फ़ाइलों को प्राप्त करने के लिए उत्सुक है।

1. एवियन

शुरू करने के लिए, हम सुझाव देंगे कि हमारा g ++ एवियन का निर्माण करे।
ओपन: oss.readytalk.com/avian स्टेटस लिंक को चुने। खुलने वाले पृष्ठ पर, एवियन 0.6 डाउनलोड करें। मामूली संस्करण संख्या के बावजूद, कार्यक्रम पूरी तरह से स्थिर है (किसी भी मामले में, मैं इसे गिराने में कभी कामयाब नहीं हुआ, और उनके बगट्रक्टर में बहुत मुश्किल कीड़े दिखाई देते हैं, जिसका अर्थ है उच्च स्थिरता)।

एवियन स्रोत फ़ाइल को अनपैक करें जिसे हमने एक निश्चित फ़ोल्डर में डाउनलोड किया है (इसे ~ / प्रोजेक्ट्स होने दें)।

 > cd ~/Projects 

विंडोज पर, MSYS में ~ फ़ोल्डर उपयोगकर्ता के होम फ़ोल्डर से जुड़ा नहीं है, लेकिन C: \ MinGW64 \ msys \ home \ उपयोगकर्ता नाम फ़ोल्डर में। हमारे मामले में, चूंकि हम खुद को प्लेटफॉर्म से जितना दूर रखना चाहते हैं, यह एक फायदा भी है।

मान लें कि डाउनलोड किए गए संग्रह को एवियन-0.6.tar.bz2 कहा जाता है और ~ / डाउनलोड में निहित है, तो इसे टाइप करके वर्तमान फ़ोल्डर में अनपैक करें

 > tar -xjf ~/Downloads/avian-0.6.tar.bz2 

विंडोज पर, पथ को प्रपत्र / c/User/username/Downloads/avian-0.6.tar.bz2 में फ़ॉरवर्ड स्लैश के साथ mingw फॉर्मेट में निर्दिष्ट किया जाना चाहिए। बेशक, आप संग्रह को अनज़िप करने के लिए सौ वैकल्पिक तरीकों में से एक का उपयोग कर सकते हैं - मुख्य बात यह है कि यह वर्तमान फ़ोल्डर में आता है। नतीजतन, संग्रह से अनपैक किया गया एक एवियन सबफ़ोल्डर इसमें दिखाई देगा। आइए इसमें चलते हैं:

 > cd avian 

अब आप मेक कमांड को चलाने की कोशिश कर सकते हैं, लेकिन यदि आप अभी विधानसभा शुरू करते हैं, तो सबसे अधिक संभावना है कि हमें एक संदेश मिलेगा कि zlib नहीं मिला है। Zlib.h जैसी कोई चीज़: ऐसी कोई फ़ाइल या निर्देशिका नहीं।




हालाँकि, zlib स्थापित करने और फिर से टाइप make से, हमें एक और त्रुटि मिलती है - एवियन कलेक्टर को / bin / javac प्रोग्राम नहीं मिलता है। जावा डेवलपर्स इस कार्यक्रम को पहचानने की संभावना रखते हैं - यह एक जावा कंपाइलर है। चूंकि एवियन केवल एक आभासी मशीन है, हम अभी भी ओरेकल से - आधिकारिक कंपाइलर का उपयोग करते हैं। वीएम का निर्माण करते समय, स्रोत जावा फाइलों से छोटे एवियन मानक पुस्तकालय, जैसे System , ArrayList या HashMap कक्षाओं को संकलित करने के लिए इसकी आवश्यकता होती है। तदनुसार, जेडीके को अभी भी डेवलपर की मशीन पर होना चाहिए - दोनों जब एवियन का निर्माण कर रहे हैं, और जब अनुप्रयोगों का निर्माण होगा जो इसका उपयोग करेंगे। और JDK7 को स्थापित करना वांछनीय है, जिसके साथ एवियन 0.6 संगत है। JRE की तरह आपके एप्लिकेशन के उपयोगकर्ता को अब इसकी आवश्यकता नहीं होगी (वास्तव में, इसके लिए हम प्रयास कर रहे हैं)।




यह देखने के लिए कि आपने अपना जावा विकास वातावरण कहां रखा है, पढ़िए JAVA_HOME पर्यावरण चर, जिसे अब हमें सही ढंग से सेट करने की आवश्यकता है। हमें अपने स्वयं के प्रोजेक्ट को इकट्ठा करने के लिए बाद में उसी मान के साथ इसी चर की आवश्यकता होगी।




और अंत में, बेहतरीन घंटा - हम एवियन इकट्ठा करते हैं:

 > make 

यदि आपने सब कुछ सही ढंग से किया है, तो आपको बिल्ड / <आपके प्लेटफ़ॉर्म का नाम> / <कुछ फ़ाइल> संकलित करने वाली फ़ॉर्म की पंक्तियों का एक अनुक्रम दिखाई देगा, और फिर बिल्ड / <आपके प्लेटफ़ॉर्म का नाम> / <कुछ फ़ाइल> लिंक करना होगा। असेंबली प्रक्रिया के अंत में, हमें बिल्ड / <आपके platform_name> फ़ोल्डर में कई फाइलें प्राप्त होंगी, लेकिन हम केवल यहां रुचि रखेंगे:

• classpath.jar आधार कक्षाओं की सबसे छोटी लाइब्रेरी है जिसका उपयोग आप अपने कार्यक्रमों में करेंगे। ओपनजेडके लाइब्रेरी का उपयोग करके एवियन का निर्माण करने का एक अवसर है, लेकिन, सबसे पहले, जैसा कि मैं इसे समझता हूं, इसके पास कम प्रकार का लाइसेंस है, और दूसरी बात, यह बहुत भारी है।
  
• द्विआधारीऑब्जेक्ट (.exe) - आपके अनुप्रयोगों में एवियन को एम्बेड करने के लिए आवश्यक एक उपयोगिता, जिसका उद्देश्य बाद में खुलासा किया जाएगा।
  
• libavian.a सबसे महत्वपूर्ण फ़ाइल है। यह वास्तव में, एक एम्बेडेड वर्चुअल मशीन है। यह मुझे 23 मेगाबाइट जितना लगता है, लेकिन घबराने की जरूरत नहीं है। वह कुछ सरल और महत्वपूर्ण रूप से पूरी तरह से हानिरहित और स्वचालित जोड़तोड़ के बाद वजन कम कर देगा, जिसका सार भी बाद में पता चलेगा।
  

2. जावा में क्रॉस-प्लेटफॉर्म स्वतंत्र अखंड हेल्लो

हमने सभी आवश्यक तृतीय-पक्ष कोड संकलित किए। अब हम अपना खुद का निर्माण करें।

कार्य एक प्रोग्राम बनाना है जो जावा में लिखा जाएगा, जिसमें एक ही समय में संभव के रूप में बहुत कम प्लेटफ़ॉर्म-निर्भर बुकमार्क होंगे और जिन्हें एक एकल exe फ़ाइल में इकट्ठा किया जाएगा, जिसे स्वयं द्वारा विशेष स्थापना की आवश्यकता नहीं होती है और बिना किसी "क्लीन" सिस्टम के काम करता है। किसी भी निर्भरता को स्थापित करना।

2.1। जेएनआई के बारे में थोड़ा सा

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

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

 package packagename; { class ClassName { void native foo(); } } 

इस तरह के एक फ़ंक्शन को जावा कंपाइलर द्वारा नियमित (गैर-आभासी) कोड के लोड किए गए पुस्तकालयों से कहा जाता है। इनमें से एक लाइब्रेरी कुछ इस तरह होनी चाहिए

 extern "C" JNIEXPORT void JNICALL Java_packagename_ClassName_foo(JNIEnv * env, jobject caller) { … } 

जब हम जावा कोड में foo() फ़ंक्शन को कॉल करते हैं, तो हम वास्तव में मूल लाइब्रेरी से फ़ंक्शन को कॉल करते हैं, इसे JNIEnv पर्यावरण के लिए एक संकेतक पास करते हैं - एक ऑब्जेक्ट जो आपको वीएम के अंदर डेटा और कोड के साथ "संवाद" करने की अनुमति देता है, और उस ऑब्जेक्ट को एक पॉइंटर जिससे फ़ंक्शन कहा जाता है - jobject caller (यदि फ़ंक्शन स्थिर था, ऑब्जेक्ट के डिस्क्रिप्टर के बजाय एक क्लास डिस्क्रिप्टर jclass caller_class )। उन लोगों के लिए जो जावा से परिचित हैं, लेकिन जेएनआई का अध्ययन नहीं किया है, बातचीत के इस सिद्धांत को निम्नानुसार समझाया जा सकता है: जेएनआई एक बाहरी देशी कोड को जावा प्रोग्राम पर प्रतिबिंबित करने की अनुमति देता है। यदि आप इस तकनीक का अधिक विस्तार से अध्ययन करना चाहते हैं, तो आधिकारिक ओरेकल वेबसाइट पर एक विशेष खंड में आपका स्वागत है ।

2.2। जेएनआई ने डायल किया

यह सब शैक्षिक कार्यक्रम क्यों था? फिर, इस समय हम एक बहुत ही दिलचस्प, लगभग उलटा, कार्य के साथ सामना कर रहे हैं। हमें एक मूल-निष्पादन योग्य फ़ाइल को चलाने की आवश्यकता है, जो कि libavian.a लाइब्रेरी से सांख्यिकीय रूप से जुड़ी हुई है, जिसमें JVM सीधे ही अंदर होगा। इसके अलावा, इसमें "एंट्री पॉइंट" - फॉर्म की एक क्लास सहित, सभी आवश्यक जावा कक्षाएं शामिल होंगी

 class Application { public static void main(String... args) { … } } 

यह सब बहुत डरावना लगता है, लेकिन यह कार्य काफी सरल है। आपको काफी सरल सी कोड लिखना होगा जो एवियन क्लास लाइब्रेरी (हमारी Application क्लास के साथ इसमें जोड़ा गया है) को अपनी स्वयं की बाइनरी फ़ाइल से बाहर निकालता है और जेवीएम के साथ-साथ कमांड लाइन मापदंडों के साथ जेवीएम को खिलाता है। फिर हम इस सी-फ़ाइल को एक विशेष तरीके से लिंक करते हैं ताकि सब कुछ अपनी जगह पर हो, और परिणाम का आनंद लें।

2.3। नई परियोजना और पुस्तकालय

अब हम आगे के काम के लिए आवश्यक सभी घटकों के माध्यम से लाएंगे और सॉर्ट करेंगे। यहाँ मैं जो वर्णन करूँगा वह मेरा अपना दृष्टिकोण है। बेशक, आप अपनी इच्छानुसार चीजों को अलग तरीके से करने के लिए स्वतंत्र हैं। लेकिन अगर आप ठीक उसी तरह से प्राप्त करना चाहते हैं जो मैंने GitHub पर पोस्ट किया है (लिंक अंत में होगा), तो सब कुछ ठीक करने की कोशिश करें।

जहाँ भी हम चाहते हैं एक क्रॉसबेस फ़ोल्डर बनाएँ (मैंने इसे प्रोजेक्ट्स में बनाया है, एवियन और विन 32 के बगल में)

 > mkdir crossbase && cd crossbase 

अंदर, libs का एक सबफ़ोल्डर बनाएं

 > mkdir lib && cd lib 

अंदर, अपने वर्तमान ओएस के नाम के साथ एक सबफ़ोल्डर बनाएं। यह linux, win32 या osx होना चाहिए।

 > mkdir win-x86_64 && cd win-x86_64 

इस फ़ोल्डर में आपको libavian.a को कॉपी करना होगा, जिसे हमने पहले एकत्र किया था। यह मेरे लिए इस तरह दिखता है:

 > cp ../../../avian/build/windows-i386/libavian.a ./ 

इसके अलावा, एक विंडोज सिस्टम पर जहां zlib नहीं है, libz.a को भी उसी फ़ोल्डर में कॉपी करना होगा:

 > cp ../../../win-x86_64/lib/libz.a ./ 

इस प्रकार, हमने उन न्यूनतम पुस्तकालयों को एकत्र किया है जिनकी हमें आवश्यकता है। यह एक साधारण कार्यक्रम के लिए पर्याप्त है।

पुस्तकालयों के अतिरिक्त, हमें classpath.jar की आवश्यकता होगी, जिसे एवियन के साथ भी बनाया गया था।

 > cd .. > mkdir java && cd java > cp ../../../avian/build/windows-i386/classpath.jar ./ 

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

 > cd ../.. 

(हम उस क्रॉसबेस फ़ोल्डर में वापस आ गए हैं जहाँ हमने लिब बनाया है)

 > mkdir -p tools/win-x86_64 && cd tools/win-x86_64 

Win-x86_64 नाम आंतरिक फ़ोल्डर में पिछली बार की तरह ही असाइन किया गया है। यहां बाइनरीटॉबजेक्ट फेंको। (विंडोज पर, निश्चित रूप से, इसका एक्साई एक्सटेंशन है)

 > cp ../../../avian/build/windows-i386/binaryToObject/binaryToObject.exe ./ 

आप इसे चला सकते हैं और उपयोग देख सकते हैं:

 usage: c:\Users\imizus\Projects\crossbase\crossbase\tools\win32\binaryToObject.exe <input file> <output file> <start name> <end name> <platform> <architecture> [<alignment> [{writable|executable}...]] 

2.4। प्रोग्राम कोड

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

 > mkdir -p src/cpp && cd src/cpp 

अंदर, हम निम्नलिखित सामग्री के साथ main.cpp फ़ाइल बनाते हैं (मैं इसे इसकी संपूर्णता में दूंगा, और फिर मैं समझाऊंगा कि क्या है)।

 #include <stdint.h> #include <string.h> #ifdef __MINGW32__ #include <windows.h> #endif #include <jni.h> #if (defined __MINGW32__) # define EXPORT __declspec(dllexport) #else # define EXPORT __attribute__ ((visibility("default"))) \ __attribute__ ((used)) #endif #if (! defined __x86_64__) && (defined __MINGW32__) # define SYMBOL(x) binary_boot_jar_##x #else # define SYMBOL(x) _binary_boot_jar_##x #endif extern "C" { extern const uint8_t SYMBOL(start)[]; extern const uint8_t SYMBOL(end)[]; EXPORT const uint8_t* bootJar(unsigned* size) { *size = SYMBOL(end) - SYMBOL(start); return SYMBOL(start); } } // extern "C" int main(int argc, const char** argv) { #ifdef __MINGW32__ // For Windows: Getting command line as a wide string int wac = 0; wchar_t** wav; wav = CommandLineToArgvW(GetCommandLineW(), &wac); #else // For other OS: Getting command line as a plain string (encoded in UTF8) int wac = argc; const char** wav = argv; #endif JavaVMInitArgs vmArgs; vmArgs.version = JNI_VERSION_1_2; vmArgs.nOptions = 1; vmArgs.ignoreUnrecognized = JNI_TRUE; JavaVMOption options[vmArgs.nOptions]; vmArgs.options = options; options[0].optionString = const_cast<char*>("-Xbootclasspath:[bootJar]"); JavaVM* vm; void* env; JNI_CreateJavaVM(&vm, &env, &vmArgs); JNIEnv* e = static_cast<JNIEnv*>(env); jclass c = e->FindClass("crossbase/Application"); if (not e->ExceptionCheck()) { jmethodID m = e->GetStaticMethodID(c, "main", "([Ljava/lang/String;)V"); if (not e->ExceptionCheck()) { jclass stringClass = e->FindClass("java/lang/String"); if (not e->ExceptionCheck()) { jobjectArray a = e->NewObjectArray(wac - 1, stringClass, 0); if (not e->ExceptionCheck()) { for (int i = 1; i < wac; ++i) { #ifdef __MINGW32__ // For Windows: Sending wide string to Java int arglen = wcslen(wav[i]); jstring arg = e->NewString((jchar*) (wav[i]), arglen); #else // For other OS: Sending UTF8-encoded string to Java int arglen = strlen(wav[i]); jstring arg = e->NewStringUTF((char*) (wav[i])); #endif e->SetObjectArrayElement(a, i - 1, arg); } e->CallStaticVoidMethod(c, m, a); } } } } int exitCode = 0; if (e->ExceptionCheck()) { exitCode = -1; e->ExceptionDescribe(); } vm->DestroyJavaVM(); return exitCode; } 

__MINGW32__ एक प्रीप्रोसेसर प्रतीक है (अप्रत्याशित रूप से!) स्वचालित रूप से MinGW32 वातावरण के अंदर सेट किया गया है। यह हमें विंडोज के बीच अंतर करने की अनुमति देता है, जो कि, जैसा कि आप समझते हैं, पहले से ही नोटिस करने में कामयाब रहे हैं, अन्य सभी प्रणालियों के विपरीत है। विशेष रूप से, केवल विंडोज के तहत हमें एक विशेष सिस्टम एपीआई की आवश्यकता होगी, जिसे हम लाइन के साथ जोड़ते हैं #include <windows.h> । अन्य प्लेटफार्मों पर, हम मानक POSIX और ANSI C ++ पुस्तकालयों के साथ वितरित करते हैं। आपको इसकी आवश्यकता क्यों है? थोड़ी देर बाद यह स्पष्ट हो जाएगा। हम कोड को क्रम में देखेंगे।

 #if (defined __MINGW32__) # define EXPORT __declspec(dllexport) #else # define EXPORT __attribute__ ((visibility("default"))) \ __attribute__ ((used)) #endif 

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

अगला भाग अजीब जादू है:

 #if (! defined __x86_64__) && (defined __MINGW32__) # define SYMBOL(x) binary_boot_jar_##x #else # define SYMBOL(x) _binary_boot_jar_##x #endif extern "C" { extern const uint8_t SYMBOL(start)[]; extern const uint8_t SYMBOL(end)[]; EXPORT const uint8_t* bootJar(unsigned* size) { *size = SYMBOL(end) - SYMBOL(start); return SYMBOL(start); } } // extern "C" 

चलिए इसका पता लगाते हैं। हम एक निश्चित निर्यात फ़ंक्शन की घोषणा करते हैं (चलो extern "C" और EXPORT निर्देश देखें जो हमने अभी दर्ज किया है। फ़ंक्शन का नाम bootJar । इस नाम को bootJar और देखें कि यह क्या करता है। यदि आप मानसिक रूप से प्रीप्रोसेसर निर्देशों को पार्स करते हैं, तो हम देखेंगे कि यह दूरी की गणना करता है। कुछ _binary_boot_jar_start और _binary_boot_jar_end (MinGW32 में उनके पास शुरुआत में अंडरस्कोर नहीं होगा) के बीच। ये वर्ण खुद को बाहरी घोषित किए जाते हैं, अर्थात, उन्हें एक लिंकर द्वारा प्रतिस्थापित किया जाना चाहिए। यह एक रहस्यमय गतिविधि है, है ना?

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

 options[0].optionString = const_cast<char*>("-Xbootclasspath:[bootJar]"); 

अंत में, हम प्रवेश बिंदु पर पहुंच गए - main कार्य। उसके कार्य में शामिल हैं:

• पैरामीटर स्ट्रिंग पढ़ें
• डाउनलोड एवियन इसे कक्षा पुस्तकालय से गुजर रहा है
• Crossbase.Application वर्ग से मुख्य फ़ंक्शन को कॉल करें, इसे कमांड लाइन पैरामीटर पास करें
• उपरोक्त में से कोई भी विफल होने पर त्रुटि के साथ उड़ान भरना अच्छा है

चलो समारोह की शुरुआत से चलते हैं:

 #ifdef __MINGW32__ // For Windows: Getting command line as a wide string int wac = 0; wchar_t** wav; wav = CommandLineToArgvW(GetCommandLineW(), &wac); #else // For other OS: Getting command line as a plain string (encoded in UTF8) int wac = argc; const char** wav = argv; #endif 

यहां, हमेशा की तरह, विंडोज ने उत्कृष्ट प्रदर्शन किया। जब हर जगह पुराने असुविधाजनक सिंगल-बाइट एन्कोडिंग से अधिक जटिल लोगों पर स्विच करने का निर्णय लिया गया, तो सभी OS ने सुविधाजनक UTF-8 पर स्विच किया, और Microsoft का पसंदीदा ब्रेनचाइल्ड एक निश्चित दो-बाइट में बदल गया। हालांकि, उन्होंने इस बात की बिल्कुल भी परवाह नहीं की कि एन्कोडिंग का उपयोग क्या किया जाता है, उदाहरण के लिए, फ़ाइल नामों में। लेकिन एन्कोडिंग वास्तव में अब हमें परेशान नहीं करता है। हमें जावा में पैरामीटर स्ट्रिंग पास करने की आवश्यकता है (जो एक डबल-बाइट char भी स्वीकार करता है)। इसलिए, विंडोज के लिए, हम एपीआई फ़ंक्शन को कहते हैं (जिसके लिए हमने windows.h घसीटा है), जो हमें सही दो-बाइट एन्कोडिंग में एक पैरामीटर स्ट्रिंग देगा। इसलिए, हमें अवसर मिलता है, उदाहरण के लिए, नाम में सिरिलिक वर्णमाला के साथ फाइलें खोलने के लिए। अन्य सभी प्रणालियों पर, हम केवल तर्कों से लेकर main फ़ंक्शन तक के मापदंडों को पढ़ते हैं।

जावा वर्चुअल मशीन का निर्माण निम्नलिखित है:

 JavaVMInitArgs vmArgs; vmArgs.version = JNI_VERSION_1_2; vmArgs.nOptions = 1; vmArgs.ignoreUnrecognized = JNI_TRUE; JavaVMOption options[vmArgs.nOptions]; vmArgs.options = options; options[0].optionString = const_cast<char*>("-Xbootclasspath:[bootJar]"); JavaVM* vm; void* env; JNI_CreateJavaVM(&vm, &env, &vmArgs); JNIEnv* e = static_cast<JNIEnv*>(env); 

हम JNIEnv ऑब्जेक्ट के लिए एक पॉइंटर भी बाहर JNIEnv , जिसका उपयोग हम नए बनाए गए जावा मशीन को कमांड करने के लिए करेंगे।

आगे कोड मायाकोव्स्की की कविता के रूप में पढ़ता है, अगर केवल थोड़ा सा जेएनआई जानने के लिए।

 jclass c = e->FindClass("crossbase/Application"); if (not e->ExceptionCheck()) { jmethodID m = e->GetStaticMethodID(c, "main", "([Ljava/lang/String;)V"); if (not e->ExceptionCheck()) { jclass stringClass = e->FindClass("java/lang/String"); if (not e->ExceptionCheck()) { jobjectArray a = e->NewObjectArray(wac - 1, stringClass, 0); if (not e->ExceptionCheck()) { for (int i = 1; i < wac; ++i) { #ifdef __MINGW32__ // For Windows: Sending wide string to Java int arglen = wcslen(wav[i]); jstring arg = e->NewString((jchar*) (wav[i]), arglen); #else // For other OS: Sending UTF8-encoded string to Java int arglen = strlen(wav[i]); jstring arg = e->NewStringUTF((char*) (wav[i])); #endif e->SetObjectArrayElement(a, i - 1, arg); } e->CallStaticVoidMethod(c, m, a); } } } } int exitCode = 0; if (e->ExceptionCheck()) { exitCode = -1; e->ExceptionDescribe(); } 

crossbase/Application क्लास लें। यदि हम कर सकते हैं, तो हम इसे हस्ताक्षर के साथ main विधि ([Ljava/lang/String;)V यदि हम, मानक पुस्तकालय से java/lang/String वर्ग प्राप्त कर सकते हैं। यदि हम कर सकते हैं, तो इस वर्ग की वस्तुओं की एक सरणी बनाएं (वे पैरामीटर होंगे)। , java- , UTF-8 , Windows , .

- , .

, , « ». Java. , , crossbase.Application public static void main(String... args) .

crossbase/src java, — crossbase ( — ), Application.java :

 package crossbase; public class Application { public static void main(String... args) { System.out.println("This is a crossplatform monolith application with Java code inside. Freedom to Java apps!"); for (int i = 0; i < args.length; i++) { System.out.println("args[" + i + "] = " + args[i]); } } } 

Java, , , . , Avian ( , , OpenJDK).

2.5। सभा

. make, , gcc. , . वास्तव में नहीं। , make . Makefile crossbase :

 UNAME := $(shell uname) ARCH := $(shell uname -m) SRC = src BIN = bin OBJ = obj JAVA_SOURCE_PATH = $(SRC)/java JAVA_CLASSPATH = $(BIN)/java CPP_SOURCE_PATH = $(SRC)/cpp OBJECTS = $(OBJ) DEBUG_OPTIMIZE = -O3 #-O0 -g ifeq ($(UNAME), Darwin) # OS X PLATFORM_ARCH = darwin x86_64 PLATFORM_LIBS = osx-x86_64 PLATFORM_GENERAL_INCLUDES = -I"$(JAVA_HOME)/include" -I"$(JAVA_HOME)/include/darwin" PLATFORM_GENERAL_LINKER_OPTIONS = -framework Carbon PLATFORM_CONSOLE_OPTION = EXE_EXT= STRIP_OPTIONS=-S -x RDYNAMIC=-rdynamic else ifeq ($(UNAME) $(ARCH), Linux x86_64) # linux on PC PLATFORM_ARCH = linux x86_64 PLATFORM_LIBS = linux-x86_64 PLATFORM_GENERAL_INCLUDES = -I"$(JAVA_HOME)/include" -I"$(JAVA_HOME)/include/linux" PLATFORM_GENERAL_LINKER_OPTIONS = -lpthread -ldl PLATFORM_CONSOLE_OPTION = EXE_EXT= STRIP_OPTIONS=--strip-all RDYNAMIC=-rdynamic else ifeq ($(OS), Windows_NT) # Windows PLATFORM_ARCH = windows x86_64 PLATFORM_LIBS = win-x86_64 PLATFORM_GENERAL_INCLUDES = -I"$(JAVA_HOME)/include" -I"$(JAVA_HOME)/include/win32" PLATFORM_GENERAL_LINKER_OPTIONS = -static -lmingw32 -lmingwthrd -lws2_32 -mwindows -static-libgcc -static-libstdc++ PLATFORM_CONSOLE_OPTION = -mconsole EXE_EXT=.exe STRIP_OPTIONS=--strip-all RDYNAMIC= endif JAVA_FILES = $(shell cd $(JAVA_SOURCE_PATH); find . -name \*.java | awk '{ sub(/.\//,"") }; 1') JAVA_CLASSES := $(addprefix $(JAVA_CLASSPATH)/,$(addsuffix .class,$(basename $(JAVA_FILES)))) CPP_FILES = $(shell cd $(CPP_SOURCE_PATH); find . -name \*.cpp | awk '{ sub(/.\//,"") }; 1') CPP_OBJECTS := $(addprefix $(OBJECTS)/,$(addsuffix .o,$(basename $(CPP_FILES)))) all: $(BIN)/crossbase $(JAVA_CLASSPATH)/%.class: $(JAVA_SOURCE_PATH)/%.java @echo $(PLATFORM_GENERAL_INCLUDES) if [ ! -d "$(dir $@)" ]; then mkdir -p "$(dir $@)"; fi "$(JAVA_HOME)/bin/javac" -sourcepath "$(JAVA_SOURCE_PATH)" -classpath "$(JAVA_CLASSPATH)" -d "$(JAVA_CLASSPATH)" $< $(OBJ)/%.o: $(SRC)/cpp/%.cpp @echo $(PLATFORM_GENERAL_INCLUDES) mkdir -p $(OBJ) g++ $(DEBUG_OPTIMIZE) -D_JNI_IMPLEMENTATION_ -c $(PLATFORM_GENERAL_INCLUDES) $< -o $@ $(BIN)/crossbase: $(JAVA_CLASSES) $(CPP_OBJECTS) mkdir -p $(BIN); @echo $(PLATFORM_GENERAL_INCLUDES) # Extracting libavian objects ( \ cd $(OBJ); \ mkdir -p libavian; \ cd libavian; \ ar x ../../lib/$(PLATFORM_LIBS)/libavian.a; \ ) # Making the java class library cp lib/java/classpath.jar $(BIN)/boot.jar; \ ( \ cd $(BIN); \ "$(JAVA_HOME)/bin/jar" u0f boot.jar -C java .; \ ) # Making an object file from the java class library tools/$(PLATFORM_LIBS)/binaryToObject $(BIN)/boot.jar $(OBJ)/boot.jar.o _binary_boot_jar_start _binary_boot_jar_end $(PLATFORM_ARCH); \ g++ $(RDYNAMIC) $(DEBUG_OPTIMIZE) -Llib/$(PLATFORM_LIBS) $(OBJ)/boot.jar.o $(CPP_OBJECTS) $(OBJ)/libavian/*.o $(PLATFORM_GENERAL_LINKER_OPTIONS) $(PLATFORM_CONSOLE_OPTION) -lm -lz -o $@ strip $(STRIP_OPTIONS) $@$(EXE_EXT) clean: rm -rf $(OBJ) rm -rf $(BIN) .PHONY: all 

सावधान! , make , . , . - — :

 JAVA_FILES = $(shell cd $(JAVA_SOURCE_PATH); find . -name \*.java | awk '{ sub(/.\//,"") }; 1') JAVA_CLASSES := $(addprefix $(JAVA_CLASSPATH)/,$(addsuffix .class,$(basename $(JAVA_FILES)))) CPP_FILES = $(shell cd $(CPP_SOURCE_PATH); find . -name \*.cpp | awk '{ sub(/.\//,"") }; 1') CPP_OBJECTS := $(addprefix $(OBJECTS)/,$(addsuffix .o,$(basename $(CPP_FILES)))) 

unix- find .java $(JAVA_SOURCE_PATH) . . .class , $(JAVA_CLASSPATH) , , , .. . .cpp .o . makefile :

 $(JAVA_CLASSPATH)/%.class: $(JAVA_SOURCE_PATH)/%.java @echo $(PLATFORM_GENERAL_INCLUDES) if [ ! -d "$(dir $@)" ]; then mkdir -p "$(dir $@)"; fi "$(JAVA_HOME)/bin/javac" -sourcepath "$(JAVA_SOURCE_PATH)" -classpath "$(JAVA_CLASSPATH)" -d "$(JAVA_CLASSPATH)" $< $(OBJ)/%.o: $(SRC)/cpp/%.cpp @echo $(PLATFORM_GENERAL_INCLUDES) mkdir -p $(OBJ) g++ $(DEBUG_OPTIMIZE) -D_JNI_IMPLEMENTATION_ -c $(PLATFORM_GENERAL_INCLUDES) $< -o $@ 

, . , ,

 $(BIN)/crossbase: $(JAVA_CLASSES) $(CPP_OBJECTS) ... 

यहां हम सभी मिली फाइलों पर निर्भरता देखते हैं। यही है, मेकफाइल को इस तरह से लिखा जाता है जैसे सभी जावा और सीपीपी फ़ाइलों को सही फ़ोल्डर में प्रस्तुत करना।

अन्य महत्वपूर्ण बिंदु:

• -static-libgccऔर वे -static-libstdc++मिंगव में आवश्यक हैं ताकि इकट्ठे फ़ाइल में मानक सी और सी ++ लाइब्रेरी शामिल हों। अन्यथा, यह उनके साथ गतिशील रूप से जुड़ा होगा और उन्हें DLL के एक जोड़े को साथ खींचने की आवश्यकता होगी।
• -mconsoleविंडोज सिस्टम पर जरूरत है ताकि सिस्टम स्टार्टअप पर इनपुट / आउटपुट को सांत्वना दे। जीयूआई आवेदन के लिए इस पैरामीटर को हटा दिया जाना चाहिए।
• यह विकल्प -rdynamicप्लेटफ़ॉर्म सुविधाओं के कारण विंडोज के तहत जीसीसी द्वारा समर्थित नहीं है।

असेंबली नियम के आकस्मिक नियम से अधिक जाने दें - $(BIN)/crossbase: $(JAVA_CLASSES) $(CPP_OBJECTS) . libavian.a, . , . Windows - ( ). classpath.jar, bin/java bin/boot.jar. binaryToObject, boot.jar obj/boot.jar.o _binary_boot_jar_start _binary_boot_jar_end ( main.o). , , . , , strip, , , OS X, , MinGW Linux. — . crossbase 9 , — .

3. विजय का एक पल

क्रॉसबेस / बिन फ़ोल्डर में प्रवेश करने के बाद, हम अपने क्रॉसबेस को कंसोल से चलाते हैं, इसके लिए पैरामीटर पास करते हैं।

 > ./crossbase  ! This is a crossplatform monolith application with Java code inside. Freedom to Java apps! args[0] =  args[1] = ! 

परिणामी परियोजना मेरे GitHub पर है ।

4. परिणाम और अर्थ

. , , , , . , , , , C++. Java . C++, . ( ) Java. , , C++, C++ Java . , .

, «» SWT (, Eclipse), , . , . आपका ध्यान के लिए धन्यवाद!

पुनश्च
, . .