क्लोजर

Question

में जावा इंटरफ़ेस को मैं कैसे कार्यान्वित करूं? मैं क्लोजर ऑब्जेक्ट कैसे बना सकता हूं जो इस इंटरफ़ेस को लागू करता है और फिर जावा कोड से कॉल किया जाता है?

public interface Doer { 
    public String doSomethin(String input); 
} 

Doer clojureDoer = ?; 

String output = clojureDoer.doSomethin(input); 

Answer 1

reify दृढ़ता से इंटरफेस को लागू करने के लिए पसंद किया जाता है में जावा से इस्तेमाल किया जा रहा - proxy हेवी-ड्यूटी, वर्ष, और धीमी गति से है, इसलिए जब संभव बचा जाना चाहिए। एक कार्यान्वयन लगेगा जैसे:

(reify Doer 
    (doSomethin [this input] 
    (...whatever...))) 

ध्यान दें कि proxy उपयोग के बारे में मौजूदा जवाब, गलत वाक्यविन्यास है अगर तुम सब के बाद एक प्रॉक्सी के साथ जाने का निर्णय: प्रॉक्सी एक अंतर्निहित this तर्क है, न कि नामित पहला तर्क लेता है।

Answer 2

प्रॉक्सी

साथ proxy मैक्रो देखें। Clojure Docs कुछ उदाहरण हैं। यह Java Interop पृष्ठ पर भी शामिल है।

(proxy [Doer] [] 
    (doSomethin [input] 
    (str input " went through proxy"))) 

proxy एक वस्तु Doer को लागू करने देता है। अब, जावा में इसे एक्सेस करने के लिए आपको अपने क्लोजर कोड को जावा से कॉल करने योग्य बनाने के लिए gen-class का उपयोग करना होगा। यह "Calling clojure from java" प्रश्न के उत्तर में शामिल है।

जनरल स्तर के साथ

(ns doer-clj 
    (:gen-class 
    :name DoerClj 
    :implements [Doer] 
    :methods [[doSomethin [String] String]])) 

(defn -doSomethin 
    [_ input] 
    (str input " went through Clojure")) 

अब doer_clj.clj, mkdir classes के रूप में सहेज और अपने आरईपीएल (require 'doer-clj) (compile 'doer-clj) में फोन करके यह संकलन। आपको पता होना चाहिए DoerClj.class तैयार classes निर्देशिका

Answer 3

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

https://github.com/cemerick/clojure-type-selection-flowchart

Answer 4

तो doSomethin() अपने इंटरफ़ेस में परिभाषित किया गया है, तो आप :methods में इसका उल्लेख करना चाहिए। http://clojuredocs.org/clojure_core/clojure.core/gen-class से उद्धरण:

:methods [ [name [param-types] return-type], ...] 
The generated class automatically defines all of the non-private 
methods of its superclasses/interfaces. This parameter can be used 
to specify the signatures of additional methods of the generated 
class. Static methods can be specified with ^{:static true} in the 
signature's metadata. Do not repeat superclass/interface signatures 
here. 

Answer 5

Clojure 1.6 के रूप में, वरीय दृष्टिकोण इस प्रकार होगा। मान लें कि आप अपने classpath, Clojure 1.6 जार और निम्नलिखित clojure फ़ाइल (या इसके संकलित समकक्ष) पर है,:

package my.other.java.package.or.maybe.the.same.one; 

import my.java.package.Doer; 
import clojure.lang.IFn; 
import clojure.java.api.Clojure; 

public class ClojureDoerUser { 
    // First, we need to instruct the JVM to compile/load our 
    // Clojure namespace. This should, obviously, only be done once. 
    static { 
     IFn require = Clojure.var("clojure.core", "require"); 
     require.invoke(Clojure.read("my.clojure.namespace")); 
     // Clojure.var() does a somewhat expensive lookup; if we had more than 
     // one Clojure namespace to load, so as a general rule its result should 
     // always be saved into a variable. 
     // The call to Clojure.read is necessary because require expects a Clojure 
     // Symbol, for which there is no more direct official Clojure API. 
    } 

    // We can now lookup the function we want from our Clojure namespace. 
    private static IFn doerFactory = Clojure.var("my.clojure.namespace", "reify-doer"); 

    // Optionally, we can wrap the doerFactory IFn into a Java wrapper, 
    // to isolate the rest of the code from our Clojure dependency. 
    // And from the need to typecast, as IFn.invoke() returns Object. 
    public static Doer createDoer() { 
     return (Doer) doerFactory.invoke(); 
    } 
    public static void main(String[] args) { 
     Doer doer = (Doer) doerFactory.invoke(); 
     doer.doSomethin("hello, world"); 
    } 
}