मोंगोडीबी स्कैला चालक: पर्यवेक्षक कॉलबैक के साथ काम करते समय भविष्य को वापस करने का सबसे अच्छा तरीका क्या है?

Question

मैं स्काला ड्राइवर का उपयोग कर प्ले फ्रेमवर्क और मोंगोडीबी पर एक साधारण ब्लॉग लिख रहा हूं। तो यह काम करता है और मैं खुश हूं लेकिन मुझे लगता है कि मेरा कोड पर्याप्त नहीं है। तुम लोग निम्नलिखित स्निपेट जो मेरे मोंगो सेवा तरीकों में से एक है की समीक्षा करने और मुझे बता सकते हैं अगर वहाँ इसे और अधिक स्वच्छ बनाने के लिए एक तरीका है:

def findByTitle(title:String)(implicit ec:ExecutionContext):Future[Option[Document]] = { 
    val collection = db.getCollection("items") 
    val results = collection.find(equal("title", title)) 
    val contentPromise: Promise[Option[Document]] = Promise() 
    results.subscribe(new Observer[scala.Document] { 
     var empty: Boolean = true 
     override def onError(e: Throwable): Unit = println("Error") 

     override def onComplete(): Unit = { 
     if (empty) contentPromise.success(None) 
     } 

     override def onNext(result: scala.Document): Unit = { 
     empty = false 
     contentPromise.success(Some(result)) 
     } 
    }) 
    contentPromise.future 
    } 

मैं के बाद से वहाँ एक मौका हो सकता है Future[Option[Document]] लौटने का फैसला किया है कि वहाँ प्रदान किए गए शीर्षक से कुछ भी नहीं है। जहां तक ​​Observable के साथ काम करने का एकमात्र तरीका Observer कॉलबैक के माध्यम से है, मुझे Promise घोषित करने की आवश्यकता है और फिर onComplete() कॉलबैक में उस वचन को पूरा करने की आवश्यकता है। इस मामले को संभालने के लिए जब प्रदान किए गए शीर्षक से कोई दस्तावेज़ नहीं है, तो मेरे पास var empty: Boolean = true वैरिएबल घोषित करने और फिर onNext() और onComplete() कॉलबैक में इसका उपयोग करने के अलावा कोई विकल्प नहीं है।

प्रश्न: क्या का उपयोग किए बिना मेरे Observer उदाहरण के अंदर इसका उपयोग करने का कोई बेहतर तरीका है?

Answer 1

मुझे लगता है कि अब तक एक नमूदार के बजाय एक Future[T] के साथ काम आसान होगा:

import org.mongodb.scala.ObservableImplicits._ 

def findByTitle(title:String)(implicit ec:ExecutionContext): Future[Option[Document]] = { 
    val collection = db.getCollection("it") 
    collection.find(equal("title", title)) 
      .toFuture() 
      .recoverWith { case e: Throwable => { Log(e); Future.failed(e) } } 
      .map(_.headOption) 
} 

T भविष्य में वास्तव में एक Seq[T] है। इस तरह एक सरल जांच म्यूटेबल राज्य की आवश्यकता को खत्म कर सकती है।