Java 8: ฉันจะทำงานกับเมธอดการโยนข้อยกเว้นในสตรีมได้อย่างไร

สมมติว่าฉันมีชั้นเรียนและวิธีการ

class A {
  void foo() throws Exception() {
    ...
  }
}

ตอนนี้ฉันต้องการเรียก foo สำหรับแต่ละอินสแตนซ์ที่Aส่งโดยสตรีมเช่น:

void bar() throws Exception {
  Stream<A> as = ...
  as.forEach(a -> a.foo());
}

คำถาม: ฉันจะจัดการข้อยกเว้นได้อย่างถูกต้องได้อย่างไร? รหัสไม่ได้รวบรวมในเครื่องของฉันเพราะฉันไม่จัดการข้อยกเว้นที่เป็นไปได้ที่สามารถโยนโดย foo () throws Exceptionของbarดูเหมือนว่าจะไร้ประโยชน์ที่นี่ ทำไมถึงเป็นอย่างนั้น?

คุณต้องปิดการเรียกใช้เมธอดของคุณเป็นอันอื่นโดยที่คุณไม่ต้องทำการยกเว้นข้อยกเว้นที่เลือก คุณยังสามารถขว้างสิ่งของที่เป็นคลาสย่อยRuntimeExceptionได้

สำนวนห่อปกติคืออะไร:

private void safeFoo(final A a) {
    try {
        a.foo();
    } catch (Exception ex) {
        throw new RuntimeException(ex);
    }
}

(ยกเว้น supertype Exceptionเป็นเพียงใช้เป็นตัวอย่างที่ไม่เคยพยายามที่จะจับมันด้วยตัวเอง)

as.forEach(this::safeFoo)จากนั้นคุณสามารถเรียกมันว่าด้วย:

หากสิ่งที่คุณต้องการคือการเรียกใช้fooและคุณต้องการเผยแพร่ข้อยกเว้นตามที่เป็น (โดยไม่ต้องล้อมรอบ) คุณสามารถใช้การforวนซ้ำของ Java แทน (หลังจากเปลี่ยน Stream ให้เป็น Iterable ด้วยกลอุบาย ):

for (A a : (Iterable<A>) as::iterator) {
   a.foo();
}

นี่คืออย่างน้อยสิ่งที่ฉันทำในการทดสอบ JUnit ของฉันที่ฉันไม่ต้องการผ่านปัญหาของการห่อข้อยกเว้นที่ตรวจสอบของฉัน

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

วิธีที่ดีที่สุดในความคิดของฉันคุณสามารถหาได้รับจาก Misha ที่นี่ ข้อยกเว้นรันไทม์รวมใน Java 8 สตรีม โดยเพียงแค่ดำเนินการใน "ฟิวเจอร์" ดังนั้นคุณสามารถเรียกใช้ส่วนการทำงานทั้งหมดและรวบรวมข้อยกเว้นที่ไม่ทำงานเป็นชิ้นเดียว มิฉะนั้นคุณสามารถรวบรวมพวกเขาทั้งหมดในรายการและดำเนินการในภายหลัง

วิธีการที่คล้ายกันมาจากBenji เวเบอร์ เขาแนะนำให้สร้างรูปแบบของตัวเองเพื่อรวบรวมชิ้นงานและไม่ทำงาน

ขึ้นอยู่กับสิ่งที่คุณต้องการบรรลุการแมปแบบง่าย ๆ ระหว่างค่าอินพุตและค่าผลลัพธ์ที่เกิดขึ้นข้อยกเว้นอาจใช้งานได้สำหรับคุณ

หากคุณไม่ชอบวิธีใด ๆ เหล่านี้ให้ลองใช้ (ขึ้นอยู่กับข้อยกเว้นดั้งเดิม) อย่างน้อยก็เป็นข้อยกเว้นของตัวเอง

ฉันแนะนำให้ใช้คลาส Google Guava Throwables

เผยแพร่ ( Throwable Throwable)

เผยแพร่ Throwable ตามที่เป็นอยู่หากเป็นอินสแตนซ์ของ RuntimeException หรือข้อผิดพลาดหรืออย่างอื่นเป็นทางเลือกสุดท้ายห่อใน RuntimeException แล้วจึงเผยแพร่ **

void bar() {
    Stream<A> as = ...
    as.forEach(a -> {
        try {
            a.foo()
        } catch(Exception e) {
            throw Throwables.propagate(e);
        }
    });
}

UPDATE:

ตอนนี้มันถูกเลิกใช้:

void bar() {
    Stream<A> as = ...
    as.forEach(a -> {
        try {
            a.foo()
        } catch(Exception e) {
            Throwables.throwIfUnchecked(e);
            throw new RuntimeException(e);
        }
    });
}

คุณสามารถห่อและแกะข้อยกเว้นด้วยวิธีนี้

class A {
    void foo() throws Exception {
        throw new Exception();
    }
};

interface Task {
    void run() throws Exception;
}

static class TaskException extends RuntimeException {
    private static final long serialVersionUID = 1L;
    public TaskException(Exception e) {
        super(e);
    }
}

void bar() throws Exception {
      Stream<A> as = Stream.generate(()->new A());
      try {
        as.forEach(a -> wrapException(() -> a.foo())); // or a::foo instead of () -> a.foo()
    } catch (TaskException e) {
        throw (Exception)e.getCause();
    }
}

static void wrapException(Task task) {
    try {
        task.run();
    } catch (Exception e) {
        throw new TaskException(e);
    }
}

คุณอาจต้องการทำอย่างใดอย่างหนึ่งต่อไปนี้:

• เผยแพร่ข้อยกเว้นตรวจสอบ
• ล้อมรอบและเผยแพร่ข้อยกเว้นที่ไม่ได้ตรวจสอบหรือ
• ตรวจจับข้อยกเว้นและหยุดการเผยแพร่

ห้องสมุดหลายแห่งให้คุณทำอย่างง่ายดาย ตัวอย่างด้านล่างเขียนโดยใช้ห้องสมุดNoExceptionของฉัน

// Propagate checked exception
as.forEach(Exceptions.sneak().consumer(A::foo));

// Wrap and propagate unchecked exception
as.forEach(Exceptions.wrap().consumer(A::foo));
as.forEach(Exceptions.wrap(MyUncheckedException::new).consumer(A::foo));

// Catch the exception and stop propagation (using logging handler for example)
as.forEach(Exceptions.log().consumer(Exceptions.sneak().consumer(A::foo)));

วิธีการอ่านเพิ่มเติม:

class A {
  void foo() throws MyException() {
    ...
  }
}

เพียงซ่อนไว้ในRuntimeExceptionเพื่อที่จะผ่านมันไปforEach()

  void bar() throws MyException {
      Stream<A> as = ...
      try {
          as.forEach(a -> {
              try {
                  a.foo();
              } catch(MyException e) {
                  throw new RuntimeException(e);
              }
          });
      } catch(RuntimeException e) {
          throw (MyException) e.getCause();
      }
  }

แม้ว่าจะมาถึงจุดนี้ฉันจะไม่จับใครบางคนถ้าพวกเขาพูดว่าข้ามลำธารและไปด้วยลูปเว้นแต่ว่า:

• คุณไม่ได้สร้างสตรีมโดยใช้Collection.stream()เช่นไม่ส่งต่อการแปลไปยังลูป for
• คุณกำลังพยายามใช้ parallelstream()