Introduzione alla parola chiave nativa:
La parola chiave nativa agisce come un collegamento tra il linguaggio JAVA e pezzi di codice o libreria scritti in lingue diverse da JAVA, che forse dipendono dalla macchina su cui si sta operando. Se la parola chiave native è applicata a un metodo, allora significa che il metodo sarà implementato usando codice nativo scritto in qualche altro linguaggio (come C o C++) tramite JNI (JAVA native interface).
Sintassi:
La sintassi del codice nativo è la stessa della normale definizione di funzione con la parola chiave “native” aggiunta all’inizio della funzione.
Per esempio:
Pubblica classe testing
{pubblica nativa String testMethod (parametro String);}
Qui public è un modificatore di accesso. Dovrebbe essere pubblico in modo che un altro file possa usarlo. String è il tipo di dati di ritorno della funzione. Può essere intero, carattere o booleano a seconda della parola chiave. Anche il parametro passato a questa funzione è di tipo dati stringa. Tutto dovrebbe essere tenuto sotto la classe.
Dopo la dichiarazione della funzione chiamiamo questa funzione tramite l’oggetto creato e la libreria caricata.
public static void main(String args)
{
System.loadLibrary(“testing”);
testing testingnew = new testing();
Stringa output = testingnew.stringMethod(“NATIVE”);
}
La biblioteca definita sopra deve essere caricata per prima e poi viene creato il suo oggetto. Con l’aiuto di questo oggetto, viene chiamata la funzione nativa.
Come funziona la parola chiave nativa?
Ci dovrebbero essere due file. Uno contiene codice JAVA mentre l’altro dovrebbe avere codice legacy C/C++. Il codice Java sarà usato per chiamare il codice legacy. Questo codice legacy interagirà con l’hardware e restituirà l’output previsto.
Quando il codice legacy interagisce con l’hardware, non seguirà le linee guida stabilite da JAVA. Questo codice farà l’elaborazione desiderata per ottenere l’output e passerà i risultati a JNI. L’interfaccia nativa Java controllerà poi nella sua directory che contiene tutte le regole relative al codice nativo (questo viene sotto il file chiamato javah.exe nell’SDK). JNI è progettato come parte del toolkit Java. Dopo questa elaborazione il JAVA pubblicherà gli output nel linguaggio JAVA stesso. Quando stiamo creando un programma in JAVA, dobbiamo assicurarci che ci sia un collegamento variabile/flusso di dati tra il file JAVA e il file legacy in modo che ci sia un flusso fluido di dati tra entrambi.
I passi che spiegano come fare uso delle parole chiave native sono dati qui sotto:
- Scrivi il codice JAVA che contiene il metodo nativo, la libreria condivisa caricata e salvalo usando “filename.JAVA”.
- Compila il codice JAVA e converti il codice in bytecode.
- Crea il file di intestazione C/C++ contenente la firma della funzione nativa che deve essere chiamata.
- Scrivi il codice C/C++ con l’implementazione del metodo nativo.
- Fai girare il file eseguibile JAVA per vedere i risultati.
Esempi per mostrare l’implementazione della parola chiave nativa:
Dovremmo scrivere il codice in Eclipse ed eseguire il codice per creare una libreria utilizzando la quale poi il codice C sarà implementato.
Codice: package com.slackerOne;
public class JPP {
public static native void pAccess();
public static native int pRead();
public static native void pWrite(int port, int output);
static{
System.loadLibrary(“JPPlibs”);
}
public void jAccess(){
JPP.pAccess();
}
public intRead(){
return JPP.pRead();
}
public void jWrite(int port, int output){
JPP.pWrite(port, output);
}
}
Dopo aver salvato questo codice nella nuova “classe” del progetto java. Dobbiamo impostare l’ambiente di esecuzione per generare il file di intestazione.
Quando eseguiremo questo dovremmo ottenere una libreria generata.
Output:
Qui abbiamo creato il file di intestazione dal codice java che agirà come collegamento tra il codice nativo e il linguaggio java.
Vantaggi:
- Fornisce un ulteriore vantaggio a JAVA per interagire con il codice scritto in altre lingue e riduce il lavoro per avere lo stesso codice scritto in JAVA, riducendo così la ridondanza del codice.
- Migliora le prestazioni generali del codice. Poiché il codice scritto in altri linguaggi può essere più veloce quando lavora con il linguaggio macchina rispetto a JAVA. Possiamo quindi usare il programma JAVA per chiamare questo codice.
- Utilizzando questo approccio, possiamo dare direttamente le chiamate di sistema. Riducendo la probabilità di interferenze esterne e migliorando la velocità di esecuzione del codice.
- È possibile chiamare dinamicamente una libreria precaricata (scritta in qualsiasi lingua diversa da JAVA) utilizzando un codice di guida arbitrario scritto in JAVA e ottenere comunque una risposta in JAVA.
- Rende accessibile per JAVA raggiungere le risorse hardware che sono disponibili per essere utilizzate solo da altri linguaggi.
- Nel caso in cui tu abbia un codice dipendente dalla piattaforma già costruito per la tua applicazione e le cui caratteristiche non sono supportate da JAVA, in questo caso possiamo avere un codice nativo e collegare questo codice nativo a JAVA tramite la parola chiave nativa.
Regole:
- La parola chiave nativa deve essere usata prima del nome del metodo.
- La dichiarazione del metodo nativo non ha corpo e deve terminare con i due punti perché questi metodi non sono definiti in JAVA ma sono presenti nel linguaggio C/C++.
- I metodi nativi non possono essere dichiarati come metodi astratti.
- Siccome non c’è certezza che il vecchio codice precedente sia scritto secondo lo standard IEEE 754 (Lo standard IEEE per l’aritmetica a virgola mobile è uno standard tecnico per l’aritmetica a virgola mobile stabilito nel 1985 dall’Istituto degli ingegneri elettrici ed elettronici), non possiamo dichiarare questi metodi nativi come strictftp.
- La specifica Java Native Interface (JNI) è progettata da JAVA per definire le regole e le dichiarazioni per implementare i metodi nativi, come la conversione dei tipi di dati tra Java e il codice nativo.
Conclusione:
La parola chiave nativa è che fa da ponte tra i linguaggi nativi e JAVA. Questo può essere usato come un collegamento critico se l’interazione del nostro software con l’hardware è più per ottenere il codice efficiente usando il codice preesistente. Rende il lavoro di implementazione minore rispetto alla progettazione di un nuovo codice applicativo da zero dove potrebbe essere evitato.