Ang mga checked exception ng Java ay isang malaking pagbutihin kaysa sa C's error-management mechanism. Sa paglipas ng oras at karanasan nakumpleto, nakumpleto namin ang koleksyon na hindi namin pa rin. Gayunpaman, ang focus ng Java sa stability ay nangangailangan ng checked exception sa kanyang kasalukuyang API. Java 8 ibinigay ng lambdas pagkatapos ng "checked exceptions are great" trend. Walang sa mga functional interface methods ay sumali ng isang checked exception. Sa post na ito, ako ay mag-demonstrate ng tatlong iba't ibang paraan upang gumawa ng iyong legacy exception-throwing code compatible sa lambdas. Ang problema, sa code. Tingnan ang isang simple exception-throwing method. public class Foo {
    public String throwing(String input) throws IOException {
        return input;                          //1
    }
}
 
 
 Ang katawan ay dito para sa compilation purposes; ang kanyang eksaktong nilalaman ay hindi mahalaga. Ang metriko para sa espasyo-panahong Schwarz Ibalik ang a Ito ay may form ng isang Kung paano gamitin ito bilang isang bagay na ito: String String Function<I, O> var foo = new Foo();
List.of("One", "Two").stream()
    .map(string -> foo.throwing(string))
    .toList();
 Ang mga sumusunod na code ay hindi gumagana sa isang compilation error: unreported exception IOException; must be caught or declared to be thrown
            .map(string -> foo.throwing(string)).toList();
                                       ^
1 error
 Upang i-fix ang error, kailangan naming i-wrap ang throwing code sa isang try-catch block: List.of("One", "Two").stream()
    .map(string -> {
        try {
            return foo.throwing(string);
        } catch (IOException e) {
            return "";
        }
    }).toList();
 Sa kasalukuyang ito, ang code ay sumusunod, ngunit bumaba ang pangunahing layunin ng lambdas: maging sumusuportahan at makikita. Isang mas mahusay na approach. Pwede kang mag-hire ng isang mathematician if you like. Pagkatapos ng isang throwing . Function apply() interface ThrowingFunction<I, O, E extends Exception> {
    O apply(I i) throws E;
}
 Pagkatapos ay maaari naming magbibigay ng isang wrapper upang mag-transform ng isang bagay na ito. Sa isang regular . Function Function class LambdaUtils {
    public static <I, O, E extends Exception> Function<I, O> safeApply(ThrowingFunction<I, O, E> f) {
        return input -> {
            try {
                return f.apply(input);
            } catch (Exception e) {
                return "";
            }
        };
    }
}
 Sa pamamagitan ng karaniwang ito, ang code ng pag-call ay maaaring i-improve tulad ng ito: var foo = new Foo();
List.of("One", "Two").stream()
    .map(string -> LambdaUtils.safeApply(foo::throwing))     //1
    .toList();
 
 
 Ipinapakita ang code again Mga library para sa rescue. Ang pinaka simpleng paraan upang i-call exception-throwing code sa isang lambda ay gumagamit ng isang library. Dalawang mga library na alam ko ay nagbibigay ng ito: 
 
 
 Mga pahinang tumuturo sa Apache Commons Lang 3 ang vavr Narito ang kung paano maaari naming i-rewrite ang code sa itaas gamit ang Commons Lang 3 code: var foo = new Foo();
FailableFunction<String, String, IOException> throwingFunction = foo::throwing; //1
List.of("One", "Two").stream()
    .map(throwingFunction)
    .recover(e -> "")                                                           //2
    .toList();
 
 
 
 Commons Lang 3 mga modelo a throwing Function recover() mimics ang halaga na itinatag sa previous catch block Ang mga library ay mapabuti sa aking kontroversial na disenyo sa itaas, ngunit ang ideya ay patuloy. Ang pagkakaiba upang i-roll out ang iyong sarili o gamitin ang isang library depende sa isang iba't ibang mga faktor na lumapit sa itaas ng post na ito. Para sa tulong mo. ilang mga criteria Ang mga checked exceptions Ang mga checked exception ay isang compile-time concern. Ang Java Language Specification ay nagpapakita: 
 
 
 Ang isang compiler para sa Java programming language ay nag-verify, sa oras ng compile, na ang isang programa ay naglalaman ng mga mananaliksik para sa checked exception, sa pamamagitan ng pag-analisa ng kung ano ang checked exception ay maaaring lumikha mula sa pag-execute ng isang paraan o constructor. Para sa bawat checked exception na ay isang posible na resulta, ang throw clause para sa paraan (§8.4.6) o constructor (§8.8.5) ay dapat ipinakita ang klase ng mga exception na ito o isa sa mga superclass ng klase ng exception na ito. 11.2 Compile-Time Check ng mga exception Ang isang compiler para sa Java programming language ay nag-verify, sa oras ng compile, na ang isang programa ay naglalaman ng mga managers para sa Ang maliliit na negosyo sa mga sumusunod na sektor ay kinakailangan: pagproseso ng produktong agrikultural ( Ang clause para sa method (§8.4.6) o constructor (§8.8.5) ay dapat na ibinigay ang klase ng exception na ito o isa sa mga superclass ng class ng exception na ito. Check ang exceptions throws 11.2 Compile-Time Check ng mga exception Maaari natin potentially hook sa compiler upang maiwasan ang check na ito sa pamamagitan ng isang compiler plugin. O maghahanap ng isang library na gumagana. Ito ay kapag Manifold pumunta sa scene. 
 
 
 
 
 Manifold ay isang Java compiler plugin. Gamitin ito upang bumuo ang iyong mga proyekto ng Java na may mataas na productive mga tampok. Ang mga potensyal na pagbutihin ng mga wika ay mapabuti ang productivity ng developer. 
 
 
 
 
 
 
 
 
 
 
 Ang mga extension True delegation Mga Property Ang mga optional na mga parameter (New!) Dalawang ekspresyon Mga Operator ng Overload Mga ekspresyon Tungkol sa Java Template Engine ang preprocessor at higit pa Ano ang Manifold Manifold ay isang Java compiler plugin. Gamitin ito upang bumuo ang iyong mga proyekto ng Java na may mataas na productive mga tampok. Ang mga potensyal na pagbutihin ng mga wika ay mapabuti ang productivity ng developer. 
 
 
 
 
 
 
 
 
 
 
 Ang mga extension Mga delegasyon Mga Property Ang mga optional na mga parameter (New!) Dalawang ekspresyon Mga Operator ng Overload Mga ekspresyon Tungkol sa Java Template Engine ang preprocessor at higit pa Ano ang Manifold Disclaimer: Hindi ako nag-advocate para sa paggamit ng Manifold. Ito ay gumagawa ng mga wika na magtrabaho sa Java. Sa punto na ito, ikaw ay mas mahusay upang gamitin Kotlin direkta. Ang paggamit ng Manifold upang i-suppress checked exceptions ay isang dalawang step na proseso. Ipinapakita namin ang Manifold runtime sa proyekto: <dependency>
    <groupId>systems.manifold</groupId>
    <artifactId>manifold-rt</artifactId>
    <version>${manifold.version}</version>
    <scope>provided</scope>
</dependency>
 Pagkatapos, i-configure ang compiler plugin: <build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.0</version>
            <configuration>
                <source>11</source>
                <target>11</target>
                <encoding>UTF-8</encoding>
                <compilerArgs>
                    <arg>-Xplugin:Manifold</arg>
                </compilerArgs>
                <annotationProcessorPaths>
                    <path>
                        <groupId>systems.manifold</groupId>
                        <artifactId>manifold-exceptions</artifactId>
                        <version>${manifold.version}</version>
                    </path>
                </annotationProcessorPaths>
            </configuration>
        </plugin>
    </plugins>
</build>
 Sa kasalukuyang ito, maaari naming i-treat checked exceptions bilang unchecked. var foo = new Foo();
List.of("One", "Two").stream()
        .map(string -> foo.throwing(string))       //1
        .toList();
 
 
 I-compilate sa walang problema Konklusyon Sa post na ito, tinutukoy ko ang problema ng pag-integrate checked exceptions sa lambdas sa Java. I-listed ang ilang mga pagpipilian: ang try-catch block, ang throwing function, ang library, at Manifold. I hope you can find one that fits your context sa pagitan ng mga ito. To go further: 
 
 
 
 
 
 
 Mga pahinang tumuturo sa Apache Commons Lang 3 ang vavr Mga pahinang tumuturo sa Java Lambda Expressions Mga Exceptions sa Lambda Expression gamit ang Vavr Say Goodbye sa checked exceptions Pag-revision ng Pag-resolve ng Scourge ng Java's Checked Exceptions Nai-publish sa A Java Geek sa Enero 18, 2026 Ang isang Java Geek

Read all my posts!

Read My Stories

Follow @nicolas_frankel on Twitter

Ang audio na ito ay ginawa sa orihinal na wika ng kuwento!

Paano Makagawa ang Iyong Legacy Exception-Throwing Code Compatible sa Lambdas

About Author

MGA KOMENTO

HANG TAGS

ANG ARTIKULONG ITO AY IPINAKITA SA

Related Stories

How I deployed my spark document classification(Logistic Regression) model/s as a standalone app…

Hosting a DNS domain on the blockchain

Encrypted Instant Messaging Recommendations January 2017

State of the Noonion: The Year of Profitability and Product Renaissance

How I deployed my spark document classification(Logistic Regression) model/s as a standalone app…

Hosting a DNS domain on the blockchain

Encrypted Instant Messaging Recommendations January 2017

State of the Noonion: The Year of Profitability and Product Renaissance

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps