अक्का और केक पैटर्न

Question

मैं उलझन में हूं कि यह सुनिश्चित करने के लिए कि मेरे अभिनेताओं के पास केक पैटर्न का उपयोग करके उपयुक्त निर्भरताएं हैं। मैं अभी भी इस के साथ पकड़ने के लिए मिल रहा है, और मुझे कहीं भी कोई उदाहरण नहीं मिल रहा है। मैं मूल रूप से बस एक ट्यूटोरियल/संसाधन का पालन करने के लिए देख रहा हूँ।

चीयर्स, क्रिस। निर्भरता के रूप में

Answer 1

अभिनेता:

trait DBComponent { 
    def db: ActorRef // no compile time guarantees 

    type K 
    type V 

    object DBActor { 
     case class Put(key: K, value: V) 
     case class Get(key: K) 
    } 

    class DBActor { 
     import DBActor._ 
     val db = scala.collection.mutable.Map.empty[K, V] 
     def receive = { 
     case Put(k, v) => db.put(k, v) 
     case Get(k) => sender ! db.get(k) 
     } 
    } 
} 

trait ServiceComponent { 
    this: DBComponent => 

    import DBActor._ 

    // you could be talking to deadLetters for all you know 
    def put(k: K, v: V): Unit = db ! Put(k, v) 
    def get(k: K): Option[V] = { 
     implicit val timeout = Timeout(5 seconds) 
     val future = ask(actor, Get(k)).mapTo[Option[V]] 
     Await.result(future, timeout.duration) 
    } 
} 

होने निर्भरता (जहां यह करने के लिए कुछ खास नहीं है) अभिनेता:

trait DBComponent { 
    def db: DB 

    type K 
    type V 

    trait DB { 
     def put(key: K, value: V): Unit 
     def get(key: K): Option[V] 
    } 
} 

trait ServiceComponent { 
    this: DBComponent => 

    object ServiceActor { 
     case class Put(key: K, value: V) 
     case class Get(key: K) 
    } 

    class ServiceActor { 
     import ServiceActor._ 
     def receive = { 
     case Put(k, v) => db.put(k, v) // db is in scope 
     case Get(k) => sender ! db.get(k) 
     } 
    } 
} 

Answer 2

एक अतिरिक्त पकड़ लिया, के रूप में ओवेन द्वारा ने कहा, कि का उपयोग कर बनाने अभिनेताओं है actorOf(Props[MyClass]) आंतरिक कक्षाओं के लिए काम नहीं करेगा। अर्थात्: निम्नलिखित असफल हो जायेगी:

trait MyComponent { 
    class MyActor { 
    def receive = ... 
    } 
} 

new MyComponent { 
    val myActorRef = system.actorOf(Props[MyActor]) 
} 

http://doc.akka.io/docs/akka/snapshot/scala/actors.html पर दस्तावेज़ के अनुसार,

अगर वे एक उच्च-स्तरीय वस्तु के भीतर तो घोषित नहीं कर रहे हैं enclosing उदाहरण इस संदर्भ के रूप में पारित किया जा करने की जरूरत है है पहला तर्क

हालांकि, यह स्केलैड प्रोप्स विधि हस्ताक्षर द्वारा समर्थित नहीं प्रतीत होता है। मैंने पाया कि इसके आस-पास एकमात्र तरीका प्रॉप (अभिनेता: अभिनेता) कन्स्ट्रक्टर का उपयोग करना था, अभिनेता mysql को तत्काल बनाना और इसे प्रॉप्स में भेजना था।

val myActorRef = system.actorOf(Props(new MyActor(arg1, arg2))) 

.. वहाँ एक बेहतर तरीका है पता करने के लिए रुचि रखते हैं