Java Academy · Lektion

Downcall-handtag

Anropa native-funktioner.

Lektion 3 av 413 steg

Downcall-handtag är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Anropa nativefunktioner

Ett downcall är ett anrop från Java ned till nativekod. FFM representerar varje nativefunktion som ett MethodHandle som byggs med en Linker.

I den här lektionen går du igenom hur du hittar, beskriver och anropar en C-funktion.

Den native länkaren

Linker.nativeLinker() returnerar länkaren för den aktuella plattformen. Den känner till C:s anropskonvention och kan skapa handtag till nativefunktioner.

import java.lang.foreign.Linker;

public class Main {
    public static void main(String[] args) {
        Linker linker = Linker.nativeLinker();
        System.out.println("Got native linker: " + linker);
    }
}

Hitta en symbol

Du behöver funktionens adress. linker.defaultLookup() söker i C:s standardbibliotek; SymbolLookup.libraryLookup(name, arena) läser in ett specifikt delat bibliotek.

import java.lang.foreign.*;

public class Main {
    public static void main(String[] args) {
        Linker linker = Linker.nativeLinker();
        SymbolLookup stdlib = linker.defaultLookup();
        MemorySegment addr = stdlib.find("strlen").orElseThrow();
        System.out.println("strlen address found: " + addr);
    }
}

Beskriva signaturen

En FunctionDescriptor beskriver C-signaturen med hjälp av layouter. För size_t strlen(const char*) är returvärdet en long och argumentet en pekare (ADDRESS).

import java.lang.foreign.*;

public class Main {
    public static void main(String[] args) {
        FunctionDescriptor desc = FunctionDescriptor.of(
            ValueLayout.JAVA_LONG,   // return: size_t
            ValueLayout.ADDRESS);    // arg: const char*
        System.out.println("Descriptor: " + desc);
    }
}

Skapa handtaget

Kombinera symbolen och deskriptorn med downcallHandle för att få ett MethodHandle som du kan anropa som vilken Java-metod som helst.

import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;

public class Main {
    public static void main(String[] args) {
        Linker linker = Linker.nativeLinker();
        MethodHandle strlen = linker.downcallHandle(
            linker.defaultLookup().find("strlen").orElseThrow(),
            FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS));
        System.out.println("Handle ready: " + strlen.type());
    }
}

Anropa funktionen

För att anropa strlen skickar du en pekare till en native-sträng. Allokera strängen i en arena och anropa sedan handtaget med invoke. Resultatet returneras som en Java-long.

import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;

public class Main {
    public static void main(String[] args) throws Throwable {
        Linker linker = Linker.nativeLinker();
        MethodHandle strlen = linker.downcallHandle(
            linker.defaultLookup().find("strlen").orElseThrow(),
            FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS));
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment str = arena.allocateUtf8String("Hello, FFM");
            long len = (long) strlen.invoke(str);
            System.out.println("Length = " + len);
        }
    }
}

Mappa typer

Varje C-typ mappas till en layout:

int till ValueLayout.JAVA_INT
long/size_t till JAVA_LONG
double till JAVA_DOUBLE
alla pekare till ADDRESS

Det är avgörande att dessa blir rätt, annars skadas data vid anropet.

Funktioner som returnerar pekare

När en C-funktion returnerar en pekare returnerar handtaget ett MemorySegment med längden noll. Om du vill läsa längre än segmentets början måste du reinterpretera det till rätt storlek med reinterpret(byteSize).

Skicka många argument

FunctionDescriptor.of(returnLayout, arg1, arg2, ...) listar argumenten i ordning. För en void-funktion använder du FunctionDescriptor.ofVoid(args...) utan någon retur-layout.

import java.lang.foreign.*;

public class Main {
    public static void main(String[] args) {
        // int (*)(const char*, int)
        FunctionDescriptor two = FunctionDescriptor.of(
            ValueLayout.JAVA_INT, ValueLayout.ADDRESS, ValueLayout.JAVA_INT);
        // void (*)(int)
        FunctionDescriptor noReturn = FunctionDescriptor.ofVoid(ValueLayout.JAVA_INT);
        System.out.println(two + " / " + noReturn);
    }
}

Hantera fel med throws

Eftersom MethodHandle.invoke deklarerar throws Throwable måste den anropande metoden hantera eller deklarera detta. Därför deklarerar exemplen throws Throwable.

Cacha handtaget

Det är relativt kostsamt att skapa ett downcall-handtag, så gör det en gång och återanvänd det. Ett vanligt mönster är att binda handtaget i ett static final-fält när klassen initieras och sedan anropa det många gånger.

Själva handtaget är trådsäkert och kan anropas samtidigt från flera trådar.

Snabbtest

Kom ihåg hur ett C-pekareargument beskrivs.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du har lärt dig att anropa nativefunktioner:

Linker.nativeLinker() tillsammans med en SymbolLookup för att hitta symboler
FunctionDescriptor beskriver signaturen med layouter
downcallHandle ger ett MethodHandle som du invoke:ar
Pekare mappas till ADDRESS; invoke kastar Throwable

Nästa steg: beskriva komplexa nativedata med layouter och structar.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 104
Lektioner: 374

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Downcall-handtag” gratis?

Ja – hela texten till ”Downcall-handtag” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Downcall-handtag”?

Anropa native-funktioner. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Downcall-handtag”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Java Academy