ฉันสามารถขอซิงโครนัสกับวอลเลย์ได้หรือไม่?

สมมติว่าฉันอยู่ในบริการที่มีเธรดพื้นหลังอยู่แล้ว ฉันสามารถร้องขอโดยใช้วอลเลย์ในเธรดเดียวกันเพื่อให้การโทรกลับเกิดขึ้นพร้อมกันได้หรือไม่?

มี 2 ​​เหตุผลสำหรับสิ่งนี้: - ประการแรกฉันไม่ต้องการเธรดอื่นและจะเป็นการสิ้นเปลืองในการสร้าง - ประการที่สองถ้าฉันอยู่ใน ServiceIntent การดำเนินการของเธรดจะเสร็จสิ้นก่อนการติดต่อกลับและด้วยเหตุนี้ฉันจะไม่ได้รับคำตอบจาก Volley ฉันรู้ว่าฉันสามารถสร้าง Service ของตัวเองที่มีเธรดบางส่วนที่มี runloop ที่ฉันสามารถควบคุมได้ แต่ก็เป็นที่พึงปรารถนาที่จะมีฟังก์ชันนี้ในการวอลเลย์

ขอบคุณ!

ดูเหมือนว่าจะเป็นไปได้ด้วยRequestFutureคลาสของวอลเลย์ ตัวอย่างเช่นในการสร้างคำขอ JSON HTTP GET แบบซิงโครนัสคุณสามารถทำสิ่งต่อไปนี้:

RequestFuture<JSONObject> future = RequestFuture.newFuture();
JsonObjectRequest request = new JsonObjectRequest(URL, new JSONObject(), future, future);
requestQueue.add(request);

try {
  JSONObject response = future.get(); // this will block
} catch (InterruptedException e) {
  // exception handling
} catch (ExecutionException e) {
  // exception handling
}

หมายเหตุ @ แมทธิวส์คำตอบนั้นถูกต้อง แต่ถ้าคุณอยู่ในเธรดอื่นและคุณทำการโทรแบบวอลเลย์เมื่อคุณไม่มีอินเทอร์เน็ตการโทรกลับข้อผิดพลาดของคุณจะถูกเรียกในเธรดหลัก แต่เธรดที่คุณอยู่จะถูกบล็อกตลอดไป (ดังนั้นหากเธรดนั้นเป็น IntentService คุณจะไม่สามารถส่งข้อความอื่นไปหามันได้และบริการของคุณจะถูกปิดโดยทั่วไป)

ใช้เวอร์ชันget()ที่หมดเวลาfuture.get(30, TimeUnit.SECONDS)และตรวจจับข้อผิดพลาดเพื่อออกจากเธรดของคุณ

เพื่อให้ตรงกับคำตอบของ @Mathews:

        try {
            return future.get(30, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            // exception handling
        } catch (ExecutionException e) {
            // exception handling
        } catch (TimeoutException e) {
            // exception handling
        }

ด้านล่างฉันห่อด้วยวิธีการและใช้คำขออื่น:

   /**
     * Runs a blocking Volley request
     *
     * @param method        get/put/post etc
     * @param url           endpoint
     * @param errorListener handles errors
     * @return the input stream result or exception: NOTE returns null once the onErrorResponse listener has been called
     */
    public InputStream runInputStreamRequest(int method, String url, Response.ErrorListener errorListener) {
        RequestFuture<InputStream> future = RequestFuture.newFuture();
        InputStreamRequest request = new InputStreamRequest(method, url, future, errorListener);
        getQueue().add(request);
        try {
            return future.get(REQUEST_TIMEOUT, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            Log.e("Retrieve cards api call interrupted.", e);
            errorListener.onErrorResponse(new VolleyError(e));
        } catch (ExecutionException e) {
            Log.e("Retrieve cards api call failed.", e);
            errorListener.onErrorResponse(new VolleyError(e));
        } catch (TimeoutException e) {
            Log.e("Retrieve cards api call timed out.", e);
            errorListener.onErrorResponse(new VolleyError(e));
        }
        return null;
    }

ขอแนะนำให้ใช้ Futures แต่ถ้าคุณไม่ต้องการด้วยเหตุผลใดก็ตามแทนที่จะทำสิ่งปิดกั้นที่ซิงโครไนซ์ของคุณเองคุณควรใช้ a java.util.concurrent.CountDownLatch. จึงจะได้ผลเช่นนี้ ..

//I'm running this in an instrumentation test, in real life you'd ofc obtain the context differently...
final Context context = InstrumentationRegistry.getTargetContext();
final RequestQueue queue = Volley.newRequestQueue(context);
final CountDownLatch countDownLatch = new CountDownLatch(1);
final Object[] responseHolder = new Object[1];

final StringRequest stringRequest = new StringRequest(Request.Method.GET, "http://google.com", new Response.Listener<String>() {
    @Override
    public void onResponse(String response) {
        responseHolder[0] = response;
        countDownLatch.countDown();
    }
}, new Response.ErrorListener() {
    @Override
    public void onErrorResponse(VolleyError error) {
        responseHolder[0] = error;
        countDownLatch.countDown();
    }
});
queue.add(stringRequest);
try {
    countDownLatch.await();
} catch (InterruptedException e) {
    throw new RuntimeException(e);
}
if (responseHolder[0] instanceof VolleyError) {
    final VolleyError volleyError = (VolleyError) responseHolder[0];
    //TODO: Handle error...
} else {
    final String response = (String) responseHolder[0];
    //TODO: Handle response...
}

เนื่องจากผู้คนดูเหมือนจะพยายามทำสิ่งนี้จริง ๆ และพบปัญหาบางอย่างฉันจึงตัดสินใจว่าจะให้ตัวอย่างการใช้งาน "ในชีวิตจริง" ของสิ่งนี้ที่ใช้งานจริง นี่คือhttps://github.com/timolehto/SynchronousVolleySample

ถึงแม้ว่าโซลูชันจะใช้ได้ผล แต่ก็มีข้อ จำกัด บางประการ ที่สำคัญที่สุดคือคุณไม่สามารถเรียกมันบนเธรด UI หลักได้ Volley ดำเนินการตามคำขอบนพื้นหลัง แต่โดยค่าเริ่มต้น Volley จะใช้Looperแอปพลิเคชันหลักในการส่งคำตอบ สิ่งนี้ทำให้เกิดการหยุดชะงักเนื่องจากเธรด UI หลักกำลังรอการตอบสนอง แต่ไฟล์LooperกำลังรอonCreateให้เสร็จสิ้นก่อนประมวลผลการจัดส่ง หากคุณต้องการทำสิ่งนี้จริงๆคุณสามารถทำได้แทนที่จะใช้วิธีการผู้ช่วยแบบคงที่ให้สร้างอินสแตนซ์ของRequestQueueคุณเองโดยExecutorDeliveryเชื่อมโยงกับการHandlerใช้Looperเธรดที่เชื่อมโยงกับเธรดอื่นจากเธรด UI หลัก

ในฐานะที่เป็นข้อสังเกตเสริมสำหรับทั้งคำตอบของ @Blundells และ @Mathews ฉันไม่แน่ใจว่ามีการโทรไปยังสิ่งใดนอกจากเธรดหลักโดย Volley

แหล่งที่มา

เมื่อดูการRequestQueueใช้งานดูเหมือนว่าRequestQueueกำลังใช้ a NetworkDispatcherเพื่อดำเนินการตามคำขอและ a ResponseDeliveryเพื่อส่งมอบผลลัพธ์ ( ResponseDeliveryจะถูกฉีดเข้าไปในNetworkDispatcher) ResponseDeliveryเป็นในทางกลับสร้างขึ้นด้วยHandlerวางไข่จากหัวข้อหลัก (บางรอบเส้น 112 ในRequestQueueการดำเนินงาน)

บางแห่งเกี่ยวกับบรรทัด 135 ในการNetworkDispatcherใช้งานดูเหมือนว่าผลลัพธ์ที่ประสบความสำเร็จจะถูกส่งผ่านเช่นเดียวResponseDeliveryกับข้อผิดพลาดใด ๆ อีกครั้ง; กResponseDeliveryขึ้นอยู่กับการHandlerวางไข่จากหัวข้อหลัก

เหตุผล

สำหรับกรณีการใช้งานที่ต้องทำคำขอจากไฟล์ IntentServiceมันเป็นธรรมที่จะถือว่าเธรดของบริการควรบล็อกจนกว่าเราจะได้รับคำตอบจาก Volley (เพื่อรับประกันขอบเขตรันไทม์ที่มีชีวิตเพื่อจัดการกับผลลัพธ์)

วิธีแก้ปัญหาที่แนะนำ

แนวทางหนึ่งคือการแทนที่วิธีเริ่มต้นที่RequestQueueสร้างขึ้นโดยที่ใช้คอนสตรัคเตอร์ทางเลือกแทนโดยฉีดสิ่งResponseDeliveryที่เกิดจากเธรดปัจจุบันแทนที่จะเป็นเธรดหลัก อย่างไรก็ตามฉันยังไม่ได้ตรวจสอบผลกระทบของสิ่งนี้

ฉันต้องการเพิ่มบางอย่างในคำตอบที่ยอมรับของมัทธิว ในขณะที่RequestFutureอาจดูเหมือนจะโทรแบบซิงโครนัสจากเธรดที่คุณสร้างขึ้น แต่ก็ไม่ได้ แต่การเรียกจะดำเนินการบนเธรดพื้นหลัง

จากสิ่งที่ฉันเข้าใจหลังจากอ่านไลบรารีคำขอในห้องสมุดRequestQueueจะถูกส่งด้วยstart()วิธีการ:

    public void start() {
        ....
        mCacheDispatcher = new CacheDispatcher(...);
        mCacheDispatcher.start();
        ....
           NetworkDispatcher networkDispatcher = new NetworkDispatcher(...);
           networkDispatcher.start();
        ....
    }

ตอนนี้ทั้งสองCacheDispatcherและNetworkDispatcherชั้นเรียนขยายเธรด ดังนั้นเธรดผู้ปฏิบัติงานใหม่จึงถูกสร้างขึ้นอย่างมีประสิทธิภาพสำหรับการยกเลิกคิวการร้องขอและการตอบกลับจะถูกส่งกลับไปยังความสำเร็จและตัวฟังข้อผิดพลาดที่ดำเนินการภายในโดยRequestFutureคิวการร้องขอและการตอบสนองจะถูกส่งกลับไปสู่ความสำเร็จและความผิดพลาดฟังการดำเนินการภายในโดย

แม้ว่าจุดประสงค์ที่สองของคุณจะบรรลุ แต่จุดประสงค์แรกของคุณไม่ใช่เนื่องจากเธรดใหม่จะเกิดขึ้นเสมอไม่ว่าคุณจะดำเนินการจากเธรดใดก็ตาม RequestFutureใดก็ตาม

ในระยะสั้นการร้องขอแบบซิงโครนัสที่แท้จริงเป็นไปไม่ได้กับไลบรารี Volley เริ่มต้น แก้ไขฉันถ้าฉันผิด

ฉันใช้การล็อคเพื่อให้ได้เอฟเฟกต์นั้นตอนนี้ฉันสงสัยว่ามันถูกต้องตามที่ใคร ๆ ต้องการแสดงความคิดเห็นหรือไม่?

// as a field of the class where i wan't to do the synchronous `volley` call   
Object mLock = new Object();


// need to have the error and success listeners notifyin
final boolean[] finished = {false};
            Response.Listener<ArrayList<Integer>> responseListener = new Response.Listener<ArrayList<Integer>>() {
                @Override
                public void onResponse(ArrayList<Integer> response) {
                    synchronized (mLock) {
                        System.out.println();
                        finished[0] = true;
                        mLock.notify();

                    }


                }
            };

            Response.ErrorListener errorListener = new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError error) {
                    synchronized (mLock) {
                        System.out.println();
                        finished[0] = true;
                        System.out.println();
                        mLock.notify();
                    }
                }
            };

// after adding the Request to the volley queue
synchronized (mLock) {
            try {
                while(!finished[0]) {
                    mLock.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

คุณสามารถทำการร้องขอการซิงค์กับวอลเลย์ได้ แต่คุณต้องเรียกใช้เมธอดในเธรดอื่นมิฉะนั้นแอปที่ทำงานอยู่ของคุณจะบล็อกมันควรเป็นดังนี้:

public String syncCall(){

    String URL = "http://192.168.1.35:8092/rest";
    String response = new String();



    RequestQueue requestQueue = Volley.newRequestQueue(this.getContext());

    RequestFuture<JSONObject> future = RequestFuture.newFuture();
    JsonObjectRequest request = new JsonObjectRequest(Request.Method.GET, URL, new JSONObject(), future, future);
    requestQueue.add(request);

    try {
        response = future.get().toString();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    } catch (JSONException e) {
        e.printStackTrace();
    }

    return response;


}

หลังจากนั้นคุณสามารถเรียกใช้เมธอดในเธรด:

 Thread thread = new Thread(new Runnable() {
                                    @Override
                                    public void run() {

                                        String response = syncCall();

                                    }
                                });
                                thread.start();

คุณบรรลุเป้าหมายนี้ด้วยคอตลินโครูทีน

implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.7"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.7"

private suspend fun request(context: Context, link : String) : String{
   return suspendCancellableCoroutine { continuation ->
      val queue = Volley.newRequestQueue(context)
      val stringRequest = StringRequest(Request.Method.GET, link,
         { response ->
            continuation.resumeWith(Result.success(response))
         },
          {
            continuation.cancel(Exception("Volley Error"))
         })

      queue.add(stringRequest)
   }
}

และโทรติดต่อกับ

CoroutineScope(Dispatchers.IO).launch {
    val response = request(CONTEXT, "https://www.google.com")
    withContext(Dispatchers.Main) {
       Toast.makeText(CONTEXT, response,Toast.LENGTH_SHORT).show()
   }
}