वास्तव में इस तरह के कई तरीकों से आप जा सकते हैं। मैं ओओ से दो सूचीबद्ध करूंगा (जैसा कि @ रैंडल शूलज़ सुझाव दे रहा है) और 1 और कार्यात्मक तरीका है। पहले संभव समाधान के लिए, आप कुछ इस तरह सरल कर सकता है:
case class MessageA(s:String)
case class MessageB(i:Int)
case class MessageC(d:Double)
trait MyActor extends Actor{
def receive = {
case a:MessageA =>
handleMessageA(a)
case b:MessageB =>
handleMessageB(b)
case c:MessageC =>
handleMessageC(c)
}
def handleMessageA(a:MessageA)
def handleMessageB(b:MessageB) = {
//do handling here
}
def handleMessageC(c:MessageC)
}
class MyActor1 extends MyActor{
def handleMessageA(a:MessageA) = {}
def handleMessageC(c:MessageC) = {}
}
class MyActor2 extends MyActor{
def handleMessageA(a:MessageA) = {}
def handleMessageC(c:MessageC) = {}
}
इस दृष्टिकोण के साथ, आप मूल रूप से एक अमूर्त अभिनेता impl जहां receive समारोह सभी संदेशों को नियंत्रित किया जाता है के लिए परिभाषित किया गया है परिभाषित करते हैं। संदेश def एस पर दिए गए हैं जहां वास्तविक व्यापार तर्क होगा। दो अमूर्त हैं, ठोस वर्गों को हैंडलिंग को परिभाषित करने दें और एक ऐसे मामले के लिए पूरी तरह लागू किया गया है जहां तर्क को अलग करने की आवश्यकता नहीं है।
अब इस दृष्टिकोण रणनीति पैटर्न का उपयोग करने पर एक संस्करण:
trait MessageHandlingStrategy{
def handleMessageA(a:MessageA)
def handleMessageB(b:MessageB) = {
//do handling here
}
def handleMessageC(c:MessageC)
}
class Strategy1 extends MessageHandlingStrategy{
def handleMessageA(a:MessageA) = {}
def handleMessageC(c:MessageC) = {}
}
class Strategy2 extends MessageHandlingStrategy{
def handleMessageA(a:MessageA) = {}
def handleMessageC(c:MessageC) = {}
}
class MyActor(strategy:MessageHandlingStrategy) extends Actor{
def receive = {
case a:MessageA =>
strategy.handleMessageA(a)
case b:MessageB =>
strategy.handleMessageB(b)
case c:MessageC =>
strategy.handleMessageC(c)
}
}
यहाँ दृष्टिकोण निर्माण के दौरान एक रणनीति वर्ग है कि एक और ग के लिए से निपटने को परिभाषित करता है में पारित करने के लिए है, ख के साथ फिर से एक ही संभाला जा रहा परवाह किए बिना। दोनों दृष्टिकोण बहुत समान हैं और एक ही लक्ष्य को पूरा करते हैं। पिछले दृष्टिकोण आंशिक समारोह श्रृंखलन का उपयोग करता है और ऐसा दिखाई दे सकता:
trait MessageAHandling{
self: Actor =>
def handleA1:Receive = {
case a:MessageA => //handle way 1
}
def handleA2:Receive = {
case a:MessageA => //handle way 2
}
}
trait MessageBHandling{
self: Actor =>
def handleB:Receive = {
case b:MessageB => //handle b
}
}
trait MessageCHandling{
self: Actor =>
def handleC1:Receive = {
case c:MessageC => //handle way 1
}
def handleC2:Receive = {
case c:MessageC => //handle way 2
}
}
class MyActor1 extends Actor with MessageAHandling with MessageBHandling with MessageCHandling{
def receive = handleA1 orElse handleB orElse handleC1
}
class MyActor2 extends Actor with MessageAHandling with MessageBHandling with MessageCHandling{
def receive = handleA2 orElse handleB orElse handleC2
}
यहाँ, कुछ लक्षण सेटअप है कि 3 संदेश प्रकारों के संदेश से निपटने व्यवहार को परिभाषित कर रहे हैं। ठोस कलाकार उन लक्षणों में मिश्रण करते हैं और फिर आंशिक फ़ंक्शन चेनिंग का उपयोग कर अपने receive फ़ंक्शन का निर्माण करते समय वे कौन से व्यवहार चाहते हैं।
आप जो भी चाहते हैं उसे करने के लिए शायद कई अन्य तरीके हैं, लेकिन मुझे लगा कि मैं आपके लिए कुछ विकल्प निकाल दूंगा। आशा करता हूँ की ये काम करेगा।
मुझे मिली दो सबसे प्रासंगिक पोस्टों में शामिल हैं, आंशिक कार्यों की श्रृंखला को दिखाते हुए, कम से कम स्कैला कलाकारों के लिए: http://www.kotancode.com/2011/07/19/traits-multiple- विरासत -और-अभिनेता-इन-स्कैला/... और फिर यह एक, एक रैपर को कॉल करके स्टेकेबल प्राप्त करने के लिए एक पैटर्न दिखा रहा है: http://grokbase.com/t/gg/akka-user/12ckfs8r7g/stackable-actor -ट्रेट्स ... मुझे लगता है कि दोनों की अपनी ताकत है, लेकिन मुझे नहीं पता कि वे संदर्भ का उपयोग कैसे करेंगे। – sdanzig