ऊंट - जावा डीएसएल का विस्तार?

Question

मैं अपने मार्गों में एक दोहराई पैटर्न मिल गया है - एक निश्चित प्रोसेसर की जरूरत है एक ही 3 हेडर हर बार जब मैं इसे कहते निर्धारित करते हैं, तो मैं 10+ के बारे में कई बार मेरी मार्गों में निम्नलिखित कोड मिल गया है:

.whatever() 
.setHeader("foo1", "bar1") 
.setHeader("foo2", "bar2") 
.setHeader("foo3", "bar3") 
.processRef("processorBazThatNeedsHeaders") 
.whatever() 

हेडर हर बार अलग-अलग आबादी वाले होते हैं, इसलिए इसे एक सबराउट में समेकित करना वास्तव में मुझे कुछ भी नहीं खरीदता है।

मैं क्या करने में सक्षम होना प्यार उपवर्ग RouteDefinition है मेरी डीएसएल में एक और तरीका है कि मुझे ऐसा करने की अनुमति होगी के लिए:

.whatever() 
.bazProcessor("bar1", "bar2", "bar3") 
.whatever() 

और 'bazProcessor', में हेडर सेट और प्रोसेसर फोन ।

मैंने ऐसा करने की कोशिश की है, लेकिन ऐसा लगता है कि यह कुछ गंभीर संभवतः भविष्य में प्रूफ सर्जरी के साथ ही संभव है, और ऐसा लगता है कि others have had similar luck।

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

क्या इस तरह कुछ हासिल करने के लिए कुछ छिपी सुविधा है?

Answer 1

RouteDefinition उप-वर्गीकरण करके आपका एक्सटेंशन केवल from(...) के बाद सीधे दिखाई देगा। यदि आप filter(...) DSL के बाद उदाहरण के लिए डीएसएल एक्सटेंशन का उपयोग करना चाहते हैं तो यह एक सीमा हो सकती है।

एक सरल तरीका कहीं तर्क संपुटित करने के लिए, और एक वर्ग है कि org.apache.camel.Processor इंटरफ़ेस लागू करता है में इसका इस्तेमाल करते हैं, और उसके बाद मार्ग में .process(...) की एक अधिभार, या bean(...) फोन तर्क का उपयोग करने के लिए होगा। यदि आप Processor उदाहरण या एक विधि के लिए अर्थपूर्ण नाम का उपयोग करते हैं, तो आप वास्तव में बहुत ही बंद हो जाएंगे, जो Processor उदाहरण देता है। यहां एक example of the suggested approach है। बस में संदर्भ के लिए

.whatever()
.process (setTheHeadersForBaz)
.whatever()

: अंत में, अपने कोड की तरह लग सकता है अगर तुम सच में करने की जरूरत है एक डीएसएल करें, एक परियोजना है जो Camel DSL based on Groovy फैली हुई है। मुझे लगता है कि ऊंट स्कैला डीएसएल के आधार पर एक स्कैला रास्ता भी एक विकल्प हो सकता है।

Answer 2

तो आप केवल हेडर सेट करते हैं क्योंकि आप चाहते हैं कि प्रोसेसर उन मानों तक पहुंच प्राप्त करे?

यदि ऐसा है तो एक सरल एक फैक्टरी का उपयोग कर उदाहरण ऐसा दिखाई दे सकता:

whatever() 
    .process(BazProcessorFactory.instance("bar1", "bar2", "bar3")) 
    .whatever() 

कहाँ BazProcessorFactory सिर्फ अपने प्रोसेसर के चारों ओर एक आवरण है:

public class BazProcessorFactory { 
    public Processor instance(final String...vals) { 
    return new Processor() { 
     @Override 
     public void process(Exchange exchange) throws Exception { 
     //access your array of values here 
     System.out.println("Foo1 = "+vals[0]); 
     } 
    } 
    } 
} 

Answer 3

हालांकि थोड़ा अप्रासंगिक, निम्नलिखित एक है स्कैला डीएसएल का विस्तार करने का उदाहरण।

हम एक निहित वर्ग के माध्यम से डीएसएल विशेषता के लिए एक निहित तरीकों का निर्माण कर सकते हैं।

object DSLImplicits { 
    implicit class RichDSL(val dsl: DSL) { 
    def get = dsl.setHeader(Exchange.HTTP_METHOD, _ => HttpMethods.GET.name) 

    def post = dsl.setHeader(Exchange.HTTP_METHOD, _ => HttpMethods.POST.name) 
    } 
} 

और इसे इस तरह उपयोग करें।

import DSLImplicits.RichDSL 
//---------------------------- 
from("someWhere") 
    //Do some processing 
    .get.to("http://somewhere.com") 

अधिक जानकारी @ http://siliconsenthil.in/blog/2013/07/11/apache-camel-with-scala-extending-dsl/