हम क्लोजर लाइब्रेरी को एक जावा एप्लिकेशन में एकीकृत करते हैं

जावा के साथ क्लोजर भाषा का बहुत कड़ा एकीकरण है। क्लोजर पर एक आवेदन में जावा पुस्तकालय का प्रत्यक्ष उपयोग पूरी तरह से सरल और सांसारिक है। पिछड़ा एकीकरण थोड़ा अधिक जटिल है। यह लेख एक जावा एप्लिकेशन में क्लोजर कोड को एकीकृत करने के लिए कुछ विकल्पों की रूपरेखा तैयार करता है।

एक उदाहरण के रूप में निम्नलिखित कोड लें:

(ns clj-lib.core (:use clj-lib.util)) (defn prod ([x] (reduce * x)) ([sx] (reduce * sx))) (defprotocol IAppendable (append [this value])) (extend-protocol IAppendable Integer (append [this value] (+ this value)) String (append [this value] (str this "," value))) (defmulti pretty type) (defmethod pretty Integer [x] (str "int " x)) (defmethod pretty String [x] (str "str " x)) 

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

मानक जावा इंटरफेस

क्लोजर अपने स्वयं के इंटरफेस के साथ, मानक संरचनाओं के कार्यान्वयन का उपयोग करता है। अतिरिक्त सुविधा के लिए, सभी मानक संग्रह java.util से इंटरफेस को लागू करते हैं । * । उदाहरण के लिए, सभी अनुक्रम (सूची, वैक्टर, यहां तक ​​कि आलसी अनुक्रम) java.util.List इंटरफ़ेस को लागू करते हैं। बेशक, सभी "म्यूटिंग" तरीके ( जोड़ें , स्पष्ट , आदि) बस एक UnsupportedOperationException को फेंक दें। इसी तरह सेट और शब्दकोशों के साथ, वे क्रमशः सेट और मैप को लागू करते हैं।

सभी कार्य 2 मानक इंटरफ़ेस java.lang.Runnable और java.util.concurrent.Callable लागू करते हैं । यह java.lang.concurent के साथ सीधे काम करते समय सुविधाजनक हो सकता है (हालांकि, सबसे अधिक संभावना है, यह सीधे क्लोज़र से निष्पादकों के साथ काम करना बेहतर है)।

लंबे अंकगणित के साथ काम करते समय, यह याद रखना महत्वपूर्ण है कि क्लोजर के पास लंबे पूर्णांक clojure.lang.BigInt के लिए अपना स्वयं का प्रकार है। उसी समय, क्लॉजुर मानक java.util.math.BigInteger के साथ काम कर सकता है। लंबे वास्तविक लोगों के साथ ऐसा कोई "आश्चर्य" नहीं है - मानक java.util.math.BigDecimal का उपयोग किया जाता है। तर्कसंगत भिन्नों के लिए एक विशेष प्रकार का क्लोजर.लंग.रैटो भी है।

संकलन और जीन-वर्ग

संभवतः सबसे स्पष्ट विकल्प क्लोजर कोड को संकलित करना और क्लास फ़ाइलों का एक सेट प्राप्त करना है। हम अपने नाम स्थान की घोषणा के लिए जनरल-क्लास कमांड जोड़ते हैं, फ़ंक्शन के लिए हस्ताक्षर निर्दिष्ट करते हैं:

 (ns clj-lib.core (:use clj-lib.util) (:gen-class :main false :name "cljlib.CljLibCore" :prefix "" :methods [^:static [prod [Iterable] Number] ^:static [prod [Number Iterable] Number] ^:static [append [Object Object] Object] ^:static [pretty [Object] Object]])) ... 

यहां हमने Iterable को ठेस फ़ंक्शन के लिए तर्क प्रकार के रूप में निर्दिष्ट किया है । वास्तव में, आप ISeq , एक सरणी और यहां तक ​​कि स्ट्रिंग पास कर सकते हैं। लेकिन, सबसे अधिक संभावना है, जावा में यह इस इंटरफ़ेस के साथ काम करने के लिए अधिक सुविधाजनक होगा।

उसके बाद, आपको नामस्थान को संकलित करने की आवश्यकता है। हम REPL'e में निष्पादित करते हैं:

 (compile 'clj-lib.core) 

हमें कक्षाएं / cljlib / CljLibCore.class फ़ाइल मिलती है , जिसका उपयोग सीधे हमारे आवेदन में किया जा सकता है। लेकिन आरईपीएल का संकलन स्पष्ट रूप से असुविधाजनक है, इसलिए एक लेनिंग प्रोजेक्ट स्थापित करना बेहतर है:

 (defproject clj-lib ... :aot [my-app.core], ... ) 

अब एक जार बनाते समय, लेनिंगेन स्वचालित रूप से निर्दिष्ट नाम स्थान का संकलन करेगा। हम कमांड निष्पादित करते हैं:

 lein jar 

हम अपने Java प्रोजेक्ट के लिए my-lib.jar और clojure.jar को जोड़ते हैं और उपयोग करते हैं:

 import java.math.BigDecimal; import java.util.Arrays; import java.util.List; import clj_lib.core.IAppendable; import cljlib.CljLibCore; public class Program { static void pr(Object v) { System.out.println(v); } static class SomeClass implements IAppendable { public Object append(Object value) { // some code return null; } } public static void main(String[] args) throws Exception { pr(CljLibCore.pretty(1)); pr(CljLibCore.pretty("x")); Integer x = (Integer) CljLibCore.append(-1, 1); pr(CljLibCore.append(x, 1)); pr(CljLibCore.append(new SomeClass(), new SomeClass())); List<Integer> v = Arrays.asList(1, 2, 3, 4, 5); pr(CljLibCore.prod(v)); pr(CljLibCore.prod(BigDecimal.ONE, v)); } } 

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

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

हम clojure.lang.RT का उपयोग करते हैं

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

• Var var (स्ट्रिंग ns, स्ट्रिंग नाम) - अपने पूर्ण नाम से एक var-cell देता है;
• कीवर्ड कीवर्ड (स्ट्रिंग ns, स्ट्रिंग नाम) - रिटर्न कीवर्ड (पहला पैरामीटर शून्य हो सकता है);
• शून्य लोड (स्ट्रिंग पथ) - निर्दिष्ट पथ पर clj स्क्रिप्ट लोड करता है।

और कई और, कार्यान्वयन के लिए मुड़ना आसान है। आप इस तरह से एक मनमाना कार्य कह सकते हैं:

 RT.var("clojure.core", "eval").invoke("(+ 1 2)"); 

हम आरटी वर्ग का उपयोग करके उपरोक्त उदाहरण को फिर से लिखते हैं:

 import java.math.BigDecimal; import clojure.lang.RT; import clojure.lang.Sequential; import clojure.lang.Var; public class Program { static void pr(Object v) { System.out.println(v); } public static void main(String[] args) throws Exception { Var pretty = RT.var("clj-lib.core", "pretty"); Var append = RT.var("clj-lib.core", "append"); Var prod = RT.var("clj-lib.core", "prod"); pr(pretty.invoke(1)); pr(pretty.invoke("x")); Integer x = (Integer) append.invoke(-1, 1); pr(append.invoke(x, 1)); Sequential v = RT.vector(1, 2, 3, 4, 5); pr(prod.invoke(v)); pr(prod.invoke(BigDecimal.ONE, v)); } } 

अब हम जावा से सीधे प्रोटोकॉल का विस्तार नहीं कर सकते हैं - IAppendable इंटरफ़ेस रनटाइम में बनाया गया है और हमारी जावा फ़ाइल को संकलित करते समय उपलब्ध नहीं है। लेकिन एओटी की कोई आवश्यकता नहीं है।

जावा इंटरफ़ेस और पुनरीक्षण

वास्तव में, यह एक अलग तरीका नहीं है, बल्कि लाइब्रेरी के साथ बातचीत की व्यवस्था करने का विकल्प है। हम जावा इंटरफ़ेस लिखते हैं:

 public interface ICljLibCore { Number prod(Iterable x); Number prod(Number s, Iterable x); Object append(Object self, Object value); String pretty(Object x); } 

उसके बाद, क्लोजर में एक समान फ़ंक्शन बनाएं:

 (defn get-lib [] (reify ICljLibCore (prod [_ x] (prod x)) (prod [_ sx] (prod x)) (append [_ tv] (append tv)) (pretty [_ x] (pretty x)))) 

पुस्तकालय तक पहुँचने के दौरान, हम ICljLibCore का एक उदाहरण बनाते हैं और इसे एक स्थिर क्षेत्र में लिखते हैं:

  public static final ICljLibCore CLJ_LIB_CORE = (ICljLibCore) RT.var("clj-lib.core", "get-lib").invoke(); ... CLJ_LIB_CORE.pretty("1"); 

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

निष्कर्ष

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