Java 8 akışlarının içinden CHECKED istisnalarını nasıl atabilirim?

Java 8 akışlarının / lambdaslarının içinden CHECKED istisnalarını nasıl atabilirim?

Başka bir deyişle, bu derleme gibi kod yapmak istiyorum:

public List<Class> getClasses() throws ClassNotFoundException {     

    List<Class> classes = 
        Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
              .map(className -> Class.forName(className))
              .collect(Collectors.toList());                  
    return classes;
    }

Bu kod derlenmez, çünkü Class.forName()yukarıdaki yöntem ClassNotFoundExceptionkontrol edilir, atar .

İşaretli özel durumu bir çalışma zamanı özel durumunun içine sarmak istemiyorum ve bunun yerine sarılı denetlenmeyen özel durumu atmak istemiyorum. İşaretli istisnayı kendisi ve çirkin try/ catchesakışa eklemeden atmak istiyorum .

Sorunuzun basit cevabı şudur: Yapamazsınız, en azından doğrudan değil. Ve bu senin hatan değil. Oracle bunu berbat etti. Kontrol edilen istisnalar kavramına yapışırlar, ancak fonksiyonel arayüzleri, akarsuları, lambdaları vb. Tasarlarken kontrol edilen istisnalara dikkat etmeyi unuturlar.

Bence, bu çok büyük bir olduğu hata içinde API ve bir küçük hata dil şartname .

API'deki hata, kontrol edilen istisnaları iletmek için hiçbir olanak sağlamadığı ve bunun gerçekten fonksiyonel programlama için çok anlamlı olacağı yönündedir. Aşağıda göstereceğim gibi, böyle bir tesis kolayca mümkün olabilirdi.

Dil belirtimindeki hata, tür parametresinin yalnızca tür listesine izin verilen durumlarda ( throwscümle) kullanıldığı sürece, tür parametresinin tek bir tür yerine tür listesini çıkarmasına izin vermemesidir .

Java programcıları olarak beklentimiz şu kodun derlenmesi gerektiğidir:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class CheckedStream {
    // List variant to demonstrate what we actually had before refactoring.
    public List<Class> getClasses(final List<String> names) throws ClassNotFoundException {
        final List<Class> classes = new ArrayList<>();
        for (final String name : names)
            classes.add(Class.forName(name));
        return classes;
    }

    // The Stream function which we want to compile.
    public Stream<Class> getClasses(final Stream<String> names) throws ClassNotFoundException {
        return names.map(Class::forName);
    }
}

Ancak, verir:

cher@armor1:~/playground/Java/checkedStream$ javac CheckedStream.java 
CheckedStream.java:13: error: incompatible thrown types ClassNotFoundException in method reference
        return names.map(Class::forName);
                         ^
1 error

Fonksiyonel arayüzler tanımlandıkları yolu şu anda istisna iletmesini Compiler önler - söylerdim hiç bildirim yoksa Stream.map()eğer Function.apply() throws E, Stream.map() throws Eyanı.

Eksik olan, kontrol edilen istisnalardan geçmek için bir tür parametresinin bildirilmesidir. Aşağıdaki kod, böyle bir doğrudan geçiş tür parametresinin geçerli sözdizimiyle gerçekte nasıl bildirilebileceğini gösterir. Aşağıda tartışılan bir sınır olan işaretli satırdaki özel durum dışında, bu kod beklendiği gibi derlenir ve davranır.

import java.io.IOException;
interface Function<T, R, E extends Throwable> {
    // Declare you throw E, whatever that is.
    R apply(T t) throws E;
}   

interface Stream<T> {
    // Pass through E, whatever mapper defined for E.
    <R, E extends Throwable> Stream<R> map(Function<? super T, ? extends R, E> mapper) throws E;
}   

class Main {
    public static void main(final String... args) throws ClassNotFoundException {
        final Stream<String> s = null;

        // Works: E is ClassNotFoundException.
        s.map(Class::forName);

        // Works: E is RuntimeException (probably).
        s.map(Main::convertClass);

        // Works: E is ClassNotFoundException.
        s.map(Main::throwSome);

        // Doesn't work: E is Exception.
        s.map(Main::throwSomeMore);  // error: unreported exception Exception; must be caught or declared to be thrown
    }   

    public static Class convertClass(final String s) {
        return Main.class;
    }   

    static class FooException extends ClassNotFoundException {}

    static class BarException extends ClassNotFoundException {}

    public static Class throwSome(final String s) throws FooException, BarException {
        throw new FooException();
    }   

    public static Class throwSomeMore(final String s) throws ClassNotFoundException, IOException  {
        throw new FooException();
    }   
}   

Bu durumda kaçırılmayı throwSomeMoregörmek isteriz IOException, ama aslında özlüyor Exception.

Bu mükemmel değildir, çünkü istisnalar olsa bile tür çıkarımı tek bir tür arıyor gibi görünmektedir. Tür kesmesi tek tip gerektiğinden, Ebir ortak isteği ve kararı gerekiyor superarasında ClassNotFoundExceptionve IOExceptionhangi Exception.

Tür parametresinin izin verilebildiği yerde type parametresi kullanılırsa derleyicinin birden çok tür arayabilmesi için tür çıkarımı tanımında bir değişiklik yapılması gerekir ( throwsyan tümce). Sonra derleyici tarafından bildirilen kural dışı durum türü throws, tek bir tümünü yakalama süper türü değil, başvurulan yöntemin denetlenen kural dışı durumlarının özgün bildirimi kadar spesifik olacaktır .

Kötü haber şu ki, Oracle bunu berbat etti. Kesinlikle kullanıcı-arazi kodunu kırmazlar, ancak mevcut işlevsel arabirimlere istisna türü parametreleri eklemek, bu arabirimleri açıkça kullanan tüm kullanıcı-arazi kodunun derlenmesini bozar. Bunu düzeltmek için yeni bir sözdizimi şekeri icat etmek zorunda kalacaklar.

Daha da kötüsü, bu konunun 2010 yılında Brian Goetz tarafından zaten tartışıldığı https://blogs.oracle.com/briangoetz/entry/exception_transparency_in_java (yeni bağlantı: http://mail.openjdk.java.net/pipermail/lambda -dev / 2010-Haziran / 001484.html ) ancak bu soruşturmanın sonuçta ortaya çıkmadığı ve Oracle'da kontrol edilen istisnalar ve lambdalar arasındaki etkileşimleri azaltmak için bildiğim güncel bir çalışma olmadığı konusunda bilgilendirildim.

Bu LambdaExceptionUtilyardımcı sınıf, Java akışlarında işaretli istisnaları şu şekilde kullanmanızı sağlar:

Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
      .map(rethrowFunction(Class::forName))
      .collect(Collectors.toList());

Kontrol edilen not Class::forNameatar . Akışın kendisi de atılır ve bazı kontrol edilmeyen istisna DEĞİLDİR.ClassNotFoundExceptionClassNotFoundException

public final class LambdaExceptionUtil {

@FunctionalInterface
public interface Consumer_WithExceptions<T, E extends Exception> {
    void accept(T t) throws E;
    }

@FunctionalInterface
public interface BiConsumer_WithExceptions<T, U, E extends Exception> {
    void accept(T t, U u) throws E;
    }

@FunctionalInterface
public interface Function_WithExceptions<T, R, E extends Exception> {
    R apply(T t) throws E;
    }

@FunctionalInterface
public interface Supplier_WithExceptions<T, E extends Exception> {
    T get() throws E;
    }

@FunctionalInterface
public interface Runnable_WithExceptions<E extends Exception> {
    void run() throws E;
    }

/** .forEach(rethrowConsumer(name -> System.out.println(Class.forName(name)))); or .forEach(rethrowConsumer(ClassNameUtil::println)); */
public static <T, E extends Exception> Consumer<T> rethrowConsumer(Consumer_WithExceptions<T, E> consumer) throws E {
    return t -> {
        try { consumer.accept(t); }
        catch (Exception exception) { throwAsUnchecked(exception); }
        };
    }

public static <T, U, E extends Exception> BiConsumer<T, U> rethrowBiConsumer(BiConsumer_WithExceptions<T, U, E> biConsumer) throws E {
    return (t, u) -> {
        try { biConsumer.accept(t, u); }
        catch (Exception exception) { throwAsUnchecked(exception); }
        };
    }

/** .map(rethrowFunction(name -> Class.forName(name))) or .map(rethrowFunction(Class::forName)) */
public static <T, R, E extends Exception> Function<T, R> rethrowFunction(Function_WithExceptions<T, R, E> function) throws E {
    return t -> {
        try { return function.apply(t); }
        catch (Exception exception) { throwAsUnchecked(exception); return null; }
        };
    }

/** rethrowSupplier(() -> new StringJoiner(new String(new byte[]{77, 97, 114, 107}, "UTF-8"))), */
public static <T, E extends Exception> Supplier<T> rethrowSupplier(Supplier_WithExceptions<T, E> function) throws E {
    return () -> {
        try { return function.get(); }
        catch (Exception exception) { throwAsUnchecked(exception); return null; }
        };
    }

/** uncheck(() -> Class.forName("xxx")); */
public static void uncheck(Runnable_WithExceptions t)
    {
    try { t.run(); }
    catch (Exception exception) { throwAsUnchecked(exception); }
    }

/** uncheck(() -> Class.forName("xxx")); */
public static <R, E extends Exception> R uncheck(Supplier_WithExceptions<R, E> supplier)
    {
    try { return supplier.get(); }
    catch (Exception exception) { throwAsUnchecked(exception); return null; }
    }

/** uncheck(Class::forName, "xxx"); */
public static <T, R, E extends Exception> R uncheck(Function_WithExceptions<T, R, E> function, T t) {
    try { return function.apply(t); }
    catch (Exception exception) { throwAsUnchecked(exception); return null; }
    }

@SuppressWarnings ("unchecked")
private static <E extends Throwable> void throwAsUnchecked(Exception exception) throws E { throw (E)exception; }

}

Nasıl kullanılacağı ile ilgili diğer birçok örnek (statik olarak içe aktarıldıktan sonra LambdaExceptionUtil):

@Test
public void test_Consumer_with_checked_exceptions() throws IllegalAccessException {
    Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
          .forEach(rethrowConsumer(className -> System.out.println(Class.forName(className))));

    Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
          .forEach(rethrowConsumer(System.out::println));
    }

@Test
public void test_Function_with_checked_exceptions() throws ClassNotFoundException {
    List<Class> classes1
          = Stream.of("Object", "Integer", "String")
                  .map(rethrowFunction(className -> Class.forName("java.lang." + className)))
                  .collect(Collectors.toList());

    List<Class> classes2
          = Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
                  .map(rethrowFunction(Class::forName))
                  .collect(Collectors.toList());
    }

@Test
public void test_Supplier_with_checked_exceptions() throws ClassNotFoundException {
    Collector.of(
          rethrowSupplier(() -> new StringJoiner(new String(new byte[]{77, 97, 114, 107}, "UTF-8"))),
          StringJoiner::add, StringJoiner::merge, StringJoiner::toString);
    }

@Test    
public void test_uncheck_exception_thrown_by_method() {
    Class clazz1 = uncheck(() -> Class.forName("java.lang.String"));

    Class clazz2 = uncheck(Class::forName, "java.lang.String");
    }

@Test (expected = ClassNotFoundException.class)
public void test_if_correct_exception_is_still_thrown_by_method() {
    Class clazz3 = uncheck(Class::forName, "INVALID");
    }    

NOT 1:rethrow yöntemleri LambdaExceptionUtilyukarıda sınıfının korkmadan kullanılır ve edilebilen herhangi bir durumda kullanılmak için OK . Son sorunu çözmeye yardımcı olan @PaoloC kullanıcısına büyük bir teşekkür: Şimdi derleyici sizden atma cümleleri eklemenizi isteyecek ve her şey Java 8 akışlarında yerel olarak kontrol edilmiş istisnalar atabileceğiniz gibi.

NOT 2:uncheck yöntemleri LambdaExceptionUtilyukarıda sınıfının prim yöntemleri vardır ve bunları kullanmak istemiyorsanız güvenle sınıftan onları kaldırılabilir. Bunları kullandıysanız, aşağıdaki kullanım durumlarını, avantajlarını / dezavantajlarını ve sınırlamalarını anlamadan önce dikkatli bir şekilde yapın:

• uncheckAsla beyan ettiği istisnayı alamayan bir yöntemi çağırıyorsanız yöntemleri kullanabilirsiniz . Örneğin: yeni Dize (byteArr, "UTF-8") UnsupportedEncodingException oluşturur, ancak UTF-8'in Java spec tarafından her zaman mevcut olması garanti edilir. Burada, fırlatma bildirimi bir sıkıntıdır ve minimal kazan plakası ile susturmak için herhangi bir çözüm kabul edilir:String text = uncheck(() -> new String(byteArr, "UTF-8"));

• uncheckBir atış bildirimi ekleme seçeneğinizin olmadığı ancak yine de bir istisna atmanın tamamen uygun olduğu katı bir arayüz uyguluyorsanız yöntemleri kullanabilirsiniz . Bir istisnayı sadece atma ayrıcalığını kazanmak için sarmak, gerçekte neyin yanlış gittiğine dair hiçbir bilgiye katkıda bulunmayan sahte istisnalar içeren bir yığın iziyle sonuçlanır. İşaretlenmiş istisnaları atmayan Runnable.run () iyi bir örnektir.

• Her durumda, uncheckyöntemleri kullanmaya karar verirseniz , CHECKED istisnalarını fırlatma cümlesi olmadan atmanın şu 2 sonucunun farkında olun: 1) Çağrı kodu, adı ile yakalayamaz (denerseniz, derleyici şunu söyleyecektir: istisna asla karşılık gelen try deyimi gövdesinde atılmaz). Kabarcık olacak ve muhtemelen ana program döngüsünde bazı "İstisna yakalamak" veya "Throwable yakalamak" tarafından yakalanır, bu da yine de istediğiniz gibi olabilir. 2) En az sürpriz ilkesini ihlal eder: RuntimeExceptionolası tüm istisnaları yakalamayı garanti etmek için artık yakalamak yeterli olmayacaktır. Bu nedenle, bunun çerçeve kodunda değil, yalnızca tamamen kontrol ettiğiniz iş kodunda yapılması gerektiğine inanıyorum.

• Referanslar:
  • http://www.philandstuff.com/2012/04/28/sneakily-throwing-checked-exceptions.html
  • http://www.mail-archive.com/javaposse@googlegroups.com/msg05984.html
  • Lombok Projesi ek açıklaması: @SneakyThrows
  • Brian Goetz (karşı) burada görüş: Java 8 akışlarının içinden CHECKED istisnalarını nasıl atabilirim?
  • /software/225931/workaround-for-java-checked-exceptions?newreg=ddf0dd15e8174af8ba52e091cf85688e *

Bunu güvenli bir şekilde yapamazsınız. Hile yapabilirsiniz, ama sonra programınız bozuldu ve bu kaçınılmaz olarak birisini ısırmaya geri dönecektir (bu siz olmalısınız, ancak genellikle hile bizim başka birisine patlar.)

İşte bunu yapmak için biraz daha güvenli bir yol (ama yine de bunu önermiyorum.)

class WrappedException extends RuntimeException {
    Throwable cause;

    WrappedException(Throwable cause) { this.cause = cause; }
}

static WrappedException throwWrapped(Throwable t) {
    throw new WrappedException(t);
}

try 
    source.stream()
          .filter(e -> { ... try { ... } catch (IOException e) { throwWrapped(e); } ... })
          ...
}
catch (WrappedException w) {
    throw (IOException) w.cause;
}

Burada, yaptığınız şey, lambda'daki istisnayı yakalamak, akış boru hattından, hesaplamanın istisnai olarak başarısız olduğunu gösteren bir sinyal atmak, sinyali yakalamak ve temel istisna atmak için bu sinyale etki etmektir. Anahtar, kontrol edilen bir istisnanın istisna atıldığını bildirmeden sızmasına izin vermek yerine, her zaman sentetik istisnayı yakalamanızdır.

Yapabilirsin!

@Marcg 'lerin genişletilmesi UtilExceptionve throw Egerektiğinde eklenmesi : bu şekilde derleyici sizden atma cümleleri eklemenizi isteyecek ve her şey java 8'in akışlarına yerel olarak kontrol edilmiş istisnalar atabileceğiniz gibi olacak .

Talimatlar: IDE'nize kopyalayın / yapıştırın LambdaExceptionUtilve aşağıda gösterildiği gibi kullanın LambdaExceptionUtilTest.

public final class LambdaExceptionUtil {

    @FunctionalInterface
    public interface Consumer_WithExceptions<T, E extends Exception> {
        void accept(T t) throws E;
    }

    @FunctionalInterface
    public interface Function_WithExceptions<T, R, E extends Exception> {
        R apply(T t) throws E;
    }

    /**
     * .forEach(rethrowConsumer(name -> System.out.println(Class.forName(name))));
     */
    public static <T, E extends Exception> Consumer<T> rethrowConsumer(Consumer_WithExceptions<T, E> consumer) throws E {
        return t -> {
            try {
                consumer.accept(t);
            } catch (Exception exception) {
                throwActualException(exception);
            }
        };
    }

    /**
     * .map(rethrowFunction(name -> Class.forName(name))) or .map(rethrowFunction(Class::forName))
     */
    public static <T, R, E extends Exception> Function<T, R> rethrowFunction(Function_WithExceptions<T, R, E> function) throws E  {
        return t -> {
            try {
                return function.apply(t);
            } catch (Exception exception) {
                throwActualException(exception);
                return null;
            }
        };
    }

    @SuppressWarnings("unchecked")
    private static <E extends Exception> void throwActualException(Exception exception) throws E {
        throw (E) exception;
    }

}

Kullanım ve davranışları göstermek için bazı testler:

public class LambdaExceptionUtilTest {

    @Test(expected = MyTestException.class)
    public void testConsumer() throws MyTestException {
        Stream.of((String)null).forEach(rethrowConsumer(s -> checkValue(s)));
    }

    private void checkValue(String value) throws MyTestException {
        if(value==null) {
            throw new MyTestException();
        }
    }

    private class MyTestException extends Exception { }

    @Test
    public void testConsumerRaisingExceptionInTheMiddle() {
        MyLongAccumulator accumulator = new MyLongAccumulator();
        try {
            Stream.of(2L, 3L, 4L, null, 5L).forEach(rethrowConsumer(s -> accumulator.add(s)));
            fail();
        } catch (MyTestException e) {
            assertEquals(9L, accumulator.acc);
        }
    }

    private class MyLongAccumulator {
        private long acc = 0;
        public void add(Long value) throws MyTestException {
            if(value==null) {
                throw new MyTestException();
            }
            acc += value;
        }
    }

    @Test
    public void testFunction() throws MyTestException {
        List<Integer> sizes = Stream.of("ciao", "hello").<Integer>map(rethrowFunction(s -> transform(s))).collect(toList());
        assertEquals(2, sizes.size());
        assertEquals(4, sizes.get(0).intValue());
        assertEquals(5, sizes.get(1).intValue());
    }

    private Integer transform(String value) throws MyTestException {
        if(value==null) {
            throw new MyTestException();
        }
        return value.length();
    }

    @Test(expected = MyTestException.class)
    public void testFunctionRaisingException() throws MyTestException {
        Stream.of("ciao", null, "hello").<Integer>map(rethrowFunction(s -> transform(s))).collect(toList());
    }

}

Sadece NoException (projem), jOOλ'nın Kontrol Edilmemiş , fırlatma-lambdaları , Fırlatılabilir arayüzler veya Faux Pas'dan herhangi birini kullanın .

// NoException
stream.map(Exceptions.sneak().function(Class::forName));

// jOOλ
stream.map(Unchecked.function(Class::forName));

// throwing-lambdas
stream.map(Throwing.function(Class::forName).sneakyThrow());

// Throwable interfaces
stream.map(FunctionWithThrowable.aFunctionThatUnsafelyThrowsUnchecked(Class::forName));

// Faux Pas
stream.map(FauxPas.throwingFunction(Class::forName));

İşaretli istisnaları atmanıza izin vermek için Akış API'sını genişleten bir kütüphane yazdım . Brian Goetz'in hilesini kullanıyor.

Kodunuz

public List<Class> getClasses() throws ClassNotFoundException {     
    Stream<String> classNames = 
        Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String");

    return ThrowingStream.of(classNames, ClassNotFoundException.class)
               .map(Class::forName)
               .collect(Collectors.toList());
}

Bu cevap 17'ye benzer, ancak sarıcı istisna tanımından kaçınmak:

List test = new ArrayList();
        try {
            test.forEach(obj -> {

                //let say some functionality throws an exception
                try {
                    throw new IOException("test");
                }
                catch(Exception e) {
                    throw new RuntimeException(e);
                }
            });
        }
        catch (RuntimeException re) {
            if(re.getCause() instanceof IOException) {
                //do your logic for catching checked
            }
            else 
                throw re; // it might be that there is real runtime exception
        }

Yapamazsın.

Ancak, bu tür "fırlatma lambdaslarını" daha kolay manipüle etmenizi sağlayan projelerimden birine bakmak isteyebilirsiniz .

Sizin durumunuzda, bunu yapabilirsiniz:

import static com.github.fge.lambdas.functions.Functions.wrap;

final ThrowingFunction<String, Class<?>> f = wrap(Class::forName);

List<Class> classes =
    Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
          .map(f.orThrow(MyException.class))
          .collect(Collectors.toList());

ve yakala MyException.

Bu bir örnek. Başka bir örnek, .orReturn()varsayılan bir değer olabilmenizdir .

Bunun hala devam eden bir çalışma olduğunu unutmayın, daha fazlası gelecek. Daha iyi isimler, daha fazla özellik vb.

Gelişmiş çözümün üstündeki yorumları özetlemek, kurtarma, yeniden bağlama ve baskılama sağlayan API gibi oluşturucu ile kontrolsüz işlevler için özel bir sargı kullanmaktır.

Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
          .map(Try.<String, Class<?>>safe(Class::forName)
                  .handle(System.out::println)
                  .unsafe())
          .collect(toList());

Aşağıdaki kod, Tüketici, Tedarikçi ve İşlev arayüzleri için bunu göstermektedir. Kolayca genişletilebilir. Bu örnek için bazı genel anahtar kelimeler kaldırıldı.

Sınıf Try , istemci kodunun bitiş noktasıdır. Güvenli yöntemlerin her işlev türü için benzersiz bir adı olabilir. CheckedConsumer , CheckedSupplier ve CheckedFunction bağımsız kullanılabilir lib fonksiyonlarının analoglarını kontrol edilir deneyin

CheckedBuilder , bazı işaretli işlevlerde istisnaları işlemek için kullanılan arabirimdir. veya Dene , önceki başarısız olursa aynı türden başka bir işlevin yürütülmesine izin verir. tutamaç , özel durum türü filtreleme dahil olmak üzere özel durum işleme sağlar. İşleyicilerin sırası önemlidir. Yöntemleri güvenli olmayan şekilde azaltın ve yürütme zincirindeki son istisnayı yeniden bağlayın . Tüm işlevler başarısız olursa yöntemleri azaltın veya OrElse ve orElseGet, İsteğe bağlı olanlar gibi alternatif bir değer döndürür. Ayrıca yöntem baskılama vardır . CheckedWrapper , CheckedBuilder'ın ortak uygulamasıdır.

final class Try {

    public static <T> CheckedBuilder<Supplier<T>, CheckedSupplier<T>, T> 
        safe(CheckedSupplier<T> supplier) {
        return new CheckedWrapper<>(supplier, 
                (current, next, handler, orResult) -> () -> {
            try { return current.get(); } catch (Exception ex) {
                handler.accept(ex);
                return next.isPresent() ? next.get().get() : orResult.apply(ex);
            }
        });
    }

    public static <T> Supplier<T> unsafe(CheckedSupplier<T> supplier) {
        return supplier;
    }

    public static <T> CheckedBuilder<Consumer<T>, CheckedConsumer<T>, Void> 
        safe(CheckedConsumer<T> consumer) {
        return new CheckedWrapper<>(consumer, 
                (current, next, handler, orResult) -> t -> {
            try { current.accept(t); } catch (Exception ex) {
                handler.accept(ex);
                if (next.isPresent()) {
                    next.get().accept(t);
                } else {
                    orResult.apply(ex);
                }
            }
        });
    }

    public static <T> Consumer<T> unsafe(CheckedConsumer<T> consumer) {
        return consumer;
    }

    public static <T, R> CheckedBuilder<Function<T, R>, CheckedFunction<T, R>, R> 
        safe(CheckedFunction<T, R> function) {
        return new CheckedWrapper<>(function, 
                (current, next, handler, orResult) -> t -> {
            try { return current.applyUnsafe(t); } catch (Exception ex) {
                handler.accept(ex);
                return next.isPresent() ? next.get().apply(t) : orResult.apply(ex);
            }
        });
    }

    public static <T, R> Function<T, R> unsafe(CheckedFunction<T, R> function) {
        return function;
    }

    @SuppressWarnings ("unchecked")
    static <T, E extends Throwable> T throwAsUnchecked(Throwable exception) throws E { 
        throw (E) exception; 
    }
}

@FunctionalInterface interface CheckedConsumer<T> extends Consumer<T> {
    void acceptUnsafe(T t) throws Exception;
    @Override default void accept(T t) {
        try { acceptUnsafe(t); } catch (Exception ex) {
            Try.throwAsUnchecked(ex);
        }
    }
}

@FunctionalInterface interface CheckedFunction<T, R> extends Function<T, R> {
    R applyUnsafe(T t) throws Exception;
    @Override default R apply(T t) {
        try { return applyUnsafe(t); } catch (Exception ex) {
            return Try.throwAsUnchecked(ex);
        }
    }
}

@FunctionalInterface interface CheckedSupplier<T> extends Supplier<T> {
    T getUnsafe() throws Exception;
    @Override default T get() {
        try { return getUnsafe(); } catch (Exception ex) {
            return Try.throwAsUnchecked(ex);
        }
    }
}

interface ReduceFunction<TSafe, TUnsafe, R> {
    TSafe wrap(TUnsafe current, Optional<TSafe> next, 
            Consumer<Throwable> handler, Function<Throwable, R> orResult);
}

interface CheckedBuilder<TSafe, TUnsafe, R> {
    CheckedBuilder<TSafe, TUnsafe, R> orTry(TUnsafe next);

    CheckedBuilder<TSafe, TUnsafe, R> handle(Consumer<Throwable> handler);

    <E extends Throwable> CheckedBuilder<TSafe, TUnsafe, R> handle(
            Class<E> exceptionType, Consumer<E> handler);

    CheckedBuilder<TSafe, TUnsafe, R> handleLast(Consumer<Throwable> handler);

    <E extends Throwable> CheckedBuilder<TSafe, TUnsafe, R> handleLast(
            Class<E> exceptionType, Consumer<? super E> handler);

    TSafe unsafe();
    TSafe rethrow(Function<Throwable, Exception> transformer);
    TSafe suppress();
    TSafe orElse(R value);
    TSafe orElseGet(Supplier<R> valueProvider);
}

final class CheckedWrapper<TSafe, TUnsafe, R> 
        implements CheckedBuilder<TSafe, TUnsafe, R> {

    private final TUnsafe function;
    private final ReduceFunction<TSafe, TUnsafe, R> reduceFunction;

    private final CheckedWrapper<TSafe, TUnsafe, R> root;
    private CheckedWrapper<TSafe, TUnsafe, R> next;

    private Consumer<Throwable> handlers = ex -> { };
    private Consumer<Throwable> lastHandlers = ex -> { };

    CheckedWrapper(TUnsafe function, 
            ReduceFunction<TSafe, TUnsafe, R> reduceFunction) {
        this.function = function;
        this.reduceFunction = reduceFunction;
        this.root = this;
    }

    private CheckedWrapper(TUnsafe function, 
            CheckedWrapper<TSafe, TUnsafe, R> prev) {
        this.function = function;
        this.reduceFunction = prev.reduceFunction;
        this.root = prev.root;
        prev.next = this;
    }

    @Override public CheckedBuilder<TSafe, TUnsafe, R> orTry(TUnsafe next) {
        return new CheckedWrapper<>(next, this);
    }

    @Override public CheckedBuilder<TSafe, TUnsafe, R> handle(
            Consumer<Throwable> handler) {
        handlers = handlers.andThen(handler);
        return this;
    }

    @Override public <E extends Throwable> CheckedBuilder<TSafe, TUnsafe, R> 
        handle(Class<E> exceptionType, Consumer<E> handler) {
        handlers = handlers.andThen(ex -> {
            if (exceptionType.isInstance(ex)) {
                handler.accept(exceptionType.cast(ex));
            }
        });
        return this;
    }

    @Override public CheckedBuilder<TSafe, TUnsafe, R> handleLast(
            Consumer<Throwable> handler) {
        lastHandlers = lastHandlers.andThen(handler);
        return this;
    }

    @Override public <E extends Throwable> CheckedBuilder<TSafe, TUnsafe, R> 
        handleLast(Class<E> exceptionType, Consumer<? super E> handler) {
        lastHandlers = lastHandlers.andThen(ex -> {
            if (exceptionType.isInstance(ex)) {
                handler.accept(exceptionType.cast(ex));
            }
        });
        return this;
    }

    @Override public TSafe unsafe() {
        return root.reduce(ex -> Try.throwAsUnchecked(ex));
    }

    @Override
    public TSafe rethrow(Function<Throwable, Exception> transformer) {
        return root.reduce(ex -> Try.throwAsUnchecked(transformer.apply(ex)));
    }

    @Override public TSafe suppress() {
        return root.reduce(ex -> null);
    }

    @Override public TSafe orElse(R value) {
        return root.reduce(ex -> value);
    }

    @Override public TSafe orElseGet(Supplier<R> valueProvider) {
        Objects.requireNonNull(valueProvider);
        return root.reduce(ex -> valueProvider.get());
    }

    private TSafe reduce(Function<Throwable, R> orResult) {
        return reduceFunction.wrap(function, 
                Optional.ofNullable(next).map(p -> p.reduce(orResult)), 
                this::handle, orResult);
    }

    private void handle(Throwable ex) {
        for (CheckedWrapper<TSafe, TUnsafe, R> current = this; 
                current != null; 
                current = current.next) {
            current.handlers.accept(ex);
        }
        lastHandlers.accept(ex);
    }
}

TL; DR Sadece Lombok'u kullan@SneakyThrows .

Christian Hujer, bir akıştan kontrol edilen istisnaları atmanın neden Java'nın sınırlamaları nedeniyle mümkün olmadığını ayrıntılı olarak açıkladı.

Diğer bazı cevaplar, dilin sınırlamalarını aşmak için püf noktaları açıkladı, ancak yine de "kontrol edilen istisnanın kendisini ve çirkin çirkin denemeleri / yakalamaları eklemeden" atma gereksinimini yerine getirebiliyorlar , bazıları da onlarca ek satır gerektiriyor kazanı.

Bunu yapmak için IMHO'nun diğerlerinden çok daha temiz olduğunu vurgulamak için başka bir seçeneği vurgulayacağım: Lombok's @SneakyThrows. Diğer cevaplardan geçerken bahsedildi, ancak gereksiz birçok ayrıntı altında biraz gömüldü.

Ortaya çıkan kod aşağıdaki kadar basittir:

public List<Class> getClasses() throws ClassNotFoundException {
    List<Class> classes =
        Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
                .map(className -> getClass(className))
                .collect(Collectors.toList());
    return classes;
}

@SneakyThrows                                 // <= this is the only new code
private Class<?> getClass(String className) {
    return Class.forName(className);
}

Biz sadece bir ihtiyaç Extract Method(IDE tarafından yapılan) üstlenmeden ve bir ek çizgi @SneakyThrows. Ek açıklama, kontrol edilen istisnanızı bir RuntimeExceptionsargıya sarmadan ve açıkça bildirmeye gerek kalmadan atabileceğinizden emin olmak için tüm kazan plakasını eklemeye özen gösterir .

Ayrıca, denetlenmeyen istisnaları sarmak için bir sarıcı yöntemi yazabilir ve hatta başka bir işlevsel arabirimi (aynı dönüş türü R ile ) temsil eden ek parametre ile sarıcıyı geliştirebilirsiniz . Bu durumda, istisnalar durumunda yürütülecek ve döndürülecek bir işlevi iletebilirsiniz. Aşağıdaki örneğe bakın:

private void run() {
    List<String> list = Stream.of(1, 2, 3, 4).map(wrapper(i ->
            String.valueOf(++i / 0), i -> String.valueOf(++i))).collect(Collectors.toList());
    System.out.println(list.toString());
}

private <T, R, E extends Exception> Function<T, R> wrapper(ThrowingFunction<T, R, E> function, 
Function<T, R> onException) {
    return i -> {
        try {
            return function.apply(i);
        } catch (ArithmeticException e) {
            System.out.println("Exception: " + i);
            return onException.apply(i);
        } catch (Exception e) {
            System.out.println("Other: " + i);
            return onException.apply(i);
        }
    };
}

@FunctionalInterface
interface ThrowingFunction<T, R, E extends Exception> {
    R apply(T t) throws E;
}

İşte orijinal sorun için farklı bir görüş veya çözüm. Burada, istisna atıldığında durumları algılama ve işleme seçeneği ile yalnızca geçerli bir değerler alt kümesini işleyecek bir kod yazma seçeneğimiz olduğunu gösteriyor.

    @Test
    public void getClasses() {

        String[] classNames = {"java.lang.Object", "java.lang.Integer", "java.lang.Foo"};
        List<Class> classes =
                Stream.of(classNames)
                        .map(className -> {
                            try {
                                return Class.forName(className);
                            } catch (ClassNotFoundException e) {
                                // log the error
                                return null;
                            }
                        })
                        .filter(c -> c != null)
                        .collect(Collectors.toList());

        if (classes.size() != classNames.length) {
            // add your error handling here if needed or process only the resulting list
            System.out.println("Did not process all class names");
        }

        classes.forEach(System.out::println);
    }

Yukarıdaki yorumları kabul ediyorum, Stream.map'i kullanırken İstisnalar atmayan Fonksiyonu uygulamakla sınırlısınız.

Ancak aşağıdaki gibi atanan kendi Fonksiyonel Arayüzünüzü oluşturabilirsiniz.

@FunctionalInterface
public interface UseInstance<T, X extends Throwable> {
  void accept(T instance) throws X;
}

daha sonra aşağıda gösterildiği gibi Lambdas veya referanslar kullanarak uygulayın.

import java.io.FileWriter;
import java.io.IOException;

//lambda expressions and the execute around method (EAM) pattern to
//manage resources

public class FileWriterEAM  {
  private final FileWriter writer;

  private FileWriterEAM(final String fileName) throws IOException {
    writer = new FileWriter(fileName);
  }
  private void close() throws IOException {
    System.out.println("close called automatically...");
    writer.close();
  }
  public void writeStuff(final String message) throws IOException {
    writer.write(message);
  }
  //...

  public static void use(final String fileName, final UseInstance<FileWriterEAM, IOException> block) throws IOException {

    final FileWriterEAM writerEAM = new FileWriterEAM(fileName);    
    try {
      block.accept(writerEAM);
    } finally {
      writerEAM.close();
    }
  }

  public static void main(final String[] args) throws IOException {

    FileWriterEAM.use("eam.txt", writerEAM -> writerEAM.writeStuff("sweet"));

    FileWriterEAM.use("eam2.txt", writerEAM -> {
        writerEAM.writeStuff("how");
        writerEAM.writeStuff("sweet");      
      });

    FileWriterEAM.use("eam3.txt", FileWriterEAM::writeIt);     

  }


 void writeIt() throws IOException{
     this.writeStuff("How ");
     this.writeStuff("sweet ");
     this.writeStuff("it is");

 }

}

Bir mapişlem tarafından atılabilen kontrol edilen istisnaları işlemenin tek yerleşik yolu, bunları bir CompletableFuture. ( Optionalİstisnayı korumanız gerekmiyorsa An , daha basit bir alternatiftir.) Bu sınıflar, koşullu işlemleri işlevsel bir şekilde temsil etmenize izin vermeyi amaçlamaktadır.

Birkaç önemsiz yardımcı yöntem gereklidir, ancak yine de akışınızın sonucunun mapbaşarıyla tamamlanan işleme bağlı olduğunu açıkça gösterirken, nispeten özlü bir koda ulaşabilirsiniz . İşte böyle görünüyor:

    CompletableFuture<List<Class<?>>> classes =
            Stream.of("java.lang.String", "java.lang.Integer", "java.lang.Double")
                  .map(MonadUtils.applyOrDie(Class::forName))
                  .map(cfc -> cfc.thenApply(Class::getSuperclass))
                  .collect(MonadUtils.cfCollector(ArrayList::new,
                                                  List::add,
                                                  (List<Class<?>> l1, List<Class<?>> l2) -> { l1.addAll(l2); return l1; },
                                                  x -> x));
    classes.thenAccept(System.out::println)
           .exceptionally(t -> { System.out.println("unable to get class: " + t); return null; });

Bu, aşağıdaki çıktıyı üretir:

[class java.lang.Object, class java.lang.Number, class java.lang.Number]

applyOrDieYöntem alır Functioniçine bir istisna atar, ve dönüşürse bunu bir Functiondöner o halihazırda tamamlanmış CompletableFuture- ya orijinal işlevin sonuçla normalde tamamlanan veya atılmış istisna ile son derece tamamladı.

İkinci mapişlem, artık Stream<CompletableFuture<T>>sadece a yerine bir tane aldığını göstermektedir Stream<T>. CompletableFuturebu işlemi yalnızca yukarı akış işlemi başarılı olursa gerçekleştirir. API bu açıklamayı yapar, ancak nispeten ağrısızdır.

Bu collectaşamaya gelene kadar . Oldukça önemli bir yardımcı yönteme ihtiyaç duyduğumuz yer burası. Biz, "lift" normal toplama işlemi (bu durumda, istediğiniz toList()"içinde") CompletableFuture- cfCollector()sağlar bize ne olduğunu kullanılarak supplier, accumulator, combinerve finisheryaklaşık hiç bir şey bilmek gerekmez CompletableFuture.

Yardımcı yöntemler MonadUtilssınıfımda GitHub'da bulunabilir , ki bu hala devam eden bir çalışmadır.

Muhtemelen, daha iyi ve daha işlevsel bir yol, istisnaları sarmak ve bunları akışta daha da yaymaktır. Örneğin, Try Vavr türüne bir göz atın .

Misal:

interface CheckedFunction<I, O> {
    O apply(I i) throws Exception; }

static <I, O> Function<I, O> unchecked(CheckedFunction<I, O> f) {
    return i -> {
        try {
            return f.apply(i);
        } catch(Exception ex) {

            throw new RuntimeException(ex);
        }
    } }

fileNamesToRead.map(unchecked(file -> Files.readAllLines(file)))

VEYA

@SuppressWarnings("unchecked")
private static <T, E extends Exception> T throwUnchecked(Exception e) throws E {
    throw (E) e;
}

static <I, O> Function<I, O> unchecked(CheckedFunction<I, O> f) {
    return arg -> {
        try {
            return f.apply(arg);
        } catch(Exception ex) {
            return throwUnchecked(ex);
        }
    };
}

2. uygulama, istisnayı a RuntimeException. throwUncheckedhemen hemen her zaman tüm genel istisnalar java'da işaretlenmemiş olarak kabul edilir.

Bu tür sarma istisnası kullanıyorum:

public class CheckedExceptionWrapper extends RuntimeException {
    ...
    public <T extends Exception> CheckedExceptionWrapper rethrow() throws T {
        throw (T) getCause();
    }
}

Bu istisnaların statik olarak ele alınmasını gerektirecektir:

void method() throws IOException, ServletException {
    try { 
        list.stream().forEach(object -> {
            ...
            throw new CheckedExceptionWrapper(e);
            ...            
        });
    } catch (CheckedExceptionWrapper e){
        e.<IOException>rethrow();
        e.<ServletExcepion>rethrow();
    }
}

Çevrimiçi deneyin!

Her ne kadar istisna ilk rethrow()arama sırasında yeniden atılacak olsa da (oh, Java jenerikleri ...), bu şekilde olası istisnaların katı bir statik tanımını almanızı sağlar (bunları beyan etmek gerekir throws). Ve hayır instanceofya da bir şey gerekli.

Bu yaklaşımın doğru olduğunu düşünüyorum:

public List<Class> getClasses() throws ClassNotFoundException {
    List<Class> classes;
    try {
        classes = Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String").map(className -> {
            try {
                return Class.forName(className);
            } catch (ClassNotFoundException e) {
                throw new UndeclaredThrowableException(e);
            }
        }).collect(Collectors.toList());
    } catch (UndeclaredThrowableException e) {
        if (e.getCause() instanceof ClassNotFoundException) {
            throw (ClassNotFoundException) e.getCause();
        } else {
            // this should never happen
            throw new IllegalStateException(e.getMessage(), e);
        }
    }
    return classes;
}

İşaretli özel durumu Callable bir de UndeclaredThrowableException(Bu özel durum için kullanma durumu var) ve dış unwrapping.

Evet, çirkin buluyorum ve bu durumda lambdaların kullanılmasına karşı öneriyorum ve paralel bir akışla çalışmadığınız ve paralellizasyon kodun okunamazlığını haklı kılan nesnel bir fayda getirmediği sürece iyi bir eski döngüye geri döneceğim.

Diğerlerinin de belirttiği gibi, bu duruma çözümler var ve umarım bunlardan biri Java'nın gelecekteki bir sürümüne dönüşür.