Effektiv Java -utveckling för Raspberry Pi: 11 steg (med bilder)

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:37

Denna instruktör beskriver ett mycket effektivt tillvägagångssätt för att utveckla Java -program för Raspberry Pi. Jag har använt tillvägagångssättet för att utveckla Java-funktioner som sträcker sig från låg nivå enhetsstöd till flertrådade och nätverksbaserade program. Tillvägagångssättet är inte bara effektivt, det är gratis!

I grunden är tillvägagångssättet fjärrutveckling med NetBeans. NetBeans körs på en arbetsstation (en stationär eller bärbar dator, inte Raspberry Pi) ansluten via Wifi till Raspberry Pi. När allt är rätt konfigurerat kan du skriva ett Java -program i NetBeans och sedan ett enda klick kompilerar och bygger programmet på arbetsstationen, laddar ner programmet till Pi, kör programmet på Pi och levererar utmatning till NetBeans -konsolen. Magi! Du kan till och med felsöka det pågående programmet, ställa in brytpunkter och undersöka variabelvärden. Mer magi!

Resten av denna introduktion beskriver motivationen för att använda Java och för fjärrutveckling med NetBeans. Om du bryr dig om motivation, läs vidare. Om du inte bryr dig, gå till steg 1.

Varför använda Java på Raspberry Pi?

Det finns många programmeringsspråk tillgängliga för Raspberry Pi, men jag begränsar diskussionen till programmeringsspråk av "professionell kvalitet" som riktar sig till fristående program, stöder multi-tasking, tillåter hårdvara och nätverksåtkomst, etc. Det betyder Java, Python eller C/C ++. De senaste versionerna av Raspbian inkluderar utvecklings- och körtidsstöd för alla dessa språk.

Python är i själva verket "marknadsfört" för användning på Pi, åtminstone delvis för att det är lätt att lära sig för nya programmerare. Jag är en erfaren programmerare och är inte förtjust i Python på grund av en viss subjektiv motvilja mot ett antal av dess egenskaper, till exempel dynamisk typning. Det finns en egenskap hos Python som min ogillar är objektiv - prestanda. Denna källa visar att Java alltid är snabbare än Python 3, och faktiskt kan köra hundratals gånger snabbare, beroende på uppgiften.

C enligt min mening är ett "högt maskinspråk", det vill säga något som ligger mycket nära systemhårdvaran, eller åtminstone operativsystemet. Du kan göra i stort sett vad som helst, och du kan göra det ungefär så snabbt som möjligt; i själva verket föreslår denna källa att C kan köras upp till 7X så snabbt som Java. Jag är inte heller förtjust i C eftersom jag (subjektivt) ogillar vissa av dess egenskaper som jag tycker är ojämna, föråldrade eller båda; till exempel uttryckliga tips. Objektivt sett innebär det faktum att du kan göra vad som helst att du bara är en dunkel bugg (t.ex. dålig pekararitmetik eller en felaktig memcpy) från att skriva över minne och eventuellt krascha programmet eller till och med hela systemet. Java förhindrar sådana faror, så Java är säkrare. Jag känner att säkerheten också förbättrar programmerarens produktivitet. Jag betraktar C ++ som ett objektorienterat "omslag" runt C som inte gör något för att eliminera farorna med C.

Slutsatsen: Java är snabbare än Python. Java är säkrare än C.

Finns det begränsningar när du använder Java?

Hittills har jag kunnat göra allt i Java som jag kan göra i Python. Det finns saker som man kan göra i C som man inte kan göra i Java, men återigen, så långt har allt jag velat göra tagits upp av Java -fans i Pi -gemenskapen. Jag kommer att ge ett exempel i ett senare steg. Som sagt, jag har köpt sensorer från leverantörer som levererade "drivrutiner" för sensorerna endast i Python (eller C/C ++ för Arduino), så jag var tvungen att skriva Java -ekvivalenten; den extra ansträngningen är inte nödvändigtvis produktiv, men kan resultera i större insikt i en sensors funktion.

Varför fjärrutveckling baserad på NetBeans?

Jag har funnit att NetBeans-baserad fjärrutveckling ökar produktiviteten kraftigt när jag använder Java för Raspberry Pi. Jag är övertygad om att du kan använda tillvägagångssättet för att skapa snabba och säkra program, på grund av de inneboende egenskaperna hos Java, medan du skriver, bygger och felsöker dem mycket snabbare än andra tillvägagångssätt jag har hittat, på grund av fjärrutveckling med hjälp av "professionella grad "NetBeans Integrated Development Environment (IDE).

Det kan vara användbart att kort diskutera dessa "andra tillvägagångssätt". Alla uppfyller de grundläggande kriterierna att Raspberry Pi inte har ett tangentbord, mus eller bildskärm ansluten. Det finns många anledningar till dessa kriterier, men min främsta anledning är att jag utvecklar mobila robotar, och jag vill inte att Pi ska vara ansluten till kringutrustning utom robotiska undersystem, inte ens under utveckling.

VNC -servern som ingår i Raspbian tillhandahåller ett grafiskt användargränssnitt på distans (GUI) som möjliggör en form för fjärrutveckling, där bara det fjärrgränssnittet körs på arbetsstationen och allt annat, skrivning, kompilering och byggande, sker på Pi. Med VNC är det enkelt att använda de Java-kompatibla utvecklingsverktygen som levereras i Raspbian, som BlueJ, Geany och Greenfoot. Några av dessa kan betraktas som en IDE; men jag finner dem långt ifrån professionella betyg.

Det är tekniskt möjligt att installera en professionell Java IDE som Eclipse eller NetBeans på Raspberry Pi och använda den på distans via VNC. Rapporter och sunt förnuft tyder på att resultaten skulle vara en besvikelse på grund av det stora minnesavtrycket och CPU -kraften som sådana IDE kräver, liksom nätverksfördröjning som introduceras av ett fjärrgränssnitt.

Både Eclipse och NetBeans fungerar mycket bra på en arbetsstation. Med Eclipse är att skriva kod en trevlig upplevelse, men att bygga programmet är inte; nedladdning av programmet måste ske utanför Eclipse; att köra programmet på Pi är helt oberoende av Eclipse. Det övergripande resultatet är en flerstegs, nästan smärtsam, process som inte kan stödja fjärrfelsökning. NetBeans har inbyggd kompilering, byggning, nedladdning, fjärrkörning och fjärrfelsökning, vilket gör det till en överlägsen metod.

Steg 1: Konfigurera Raspberry Pi

För att använda fjärrutvecklingsmetoden måste du börja med att konfigurera målet Raspberry Pi. Det finns många resurser, inklusive Instructables, tillgängliga för att hjälpa till med att konfigurera en Raspberry Pi. Se detta för grunderna för att konfigurera Pi (och mer).

Denna instruerbara antar dig

• installera den senaste Raspbian; Se till att du spelar in Pi -användar -ID och lösenord
• konfigurera Wifi och anslut till din router (se detta); se till att du spelar in Pi: s IP -adress
• aktivera SSH (se detta) för att tillåta fjärråtkomst till Pi från arbetsstationen

När du har slutfört installationen kan du stänga av och koppla bort skärmen, tangentbordet och musen från Pi. Detta är en av de viktigaste fördelarna med fjärrutveckling. Du måste lämna alla Wifi -donglar anslutna (behövs naturligtvis inte för en Pi -modell 3 eller Pi Zero W) och sedan kan du slå på Pi.

För att testa, öppna en ssh -klient på din arbetsstation, t.ex. Terminal på MacOS eller kitt på Windows. Ange sedan kommandot ssh (secure shell) med följande formulär:

ssh the_pi_ip_address -l the_pi_user_id

Du bör få en uppmaning att ange lösenordet för ditt Pi -användar -ID. Om ingen uppmaning visas kontrollerar du att du har angett rätt IP -adress i ssh -kommandot. Ange ditt lösenord (det kommer att vara dolt) och du bör då se Pi -skalet som visas ungefär så här:

pi@raspberrypi: ~ $

Kontrollera användar -ID och lösenord som du använde om du inte ser uppmaningen.

Nu måste du hitta sökvägen till Java -körtiden och bekräfta att standardversionen är Java 8 (borde vara sant för den senaste Raspbian). För att hitta sökvägen till Java -körning anger du kommandot i ssh -klienten

sudo update-alternativer-visa java

Du bör se ett svar med de två första raderna som ser ut som följande:

java - autoläge

länken bästa versionen är/usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java

"-8-" på den andra raden bekräftar att standardkörtiden är Java 8. Spela in sökvägen i den andra raden eftersom du behöver den för att konfigurera NetBeans för fjärrutveckling i ett senare steg.

Om standardkörtiden inte är Java 8 anger du följande kommando i ssh -klienten för att växla till Java 8 (förutsatt att den är installerad)

sudo update-alternativer --config java

Steg 2: Installera NetBeans på arbetsstationen

Nu måste du installera NetBeans på din arbetsstation. Rikta din arbetsstations webbläsare till NetBeans nedladdningssida. Du kommer att se flera möjliga buntar som stöder de två versionerna av Java såväl som andra språk. Allt du behöver för Java -utveckling för Raspberry Pi är Java SE, men du kan få Java EE -paketet eller Allt -paketet. När du bestämmer vilket paket du vill klicka på motsvarande nedladdningsknapp. Du kan hitta ytterligare installationsanvisningar för din arbetsstations OS här.

När du har installerat NetBeans, starta det (det kan göra det automatiskt efter installationen). Du bör se NetBeans huvudfönster som visas på bilden. Bilden togs på en Mac, och huvudfönstret kan se lite annorlunda ut i Windows.

När du har installerat och startat NetBeans, gå vidare till nästa steg.

Steg 3: Konfigurera Raspberry Pi som en fjärrplattform i NetBeans

Följande åtgärder konfigurerar Raspberry Pi som en fjärransluten Java SE -plattform för NetBeans. Detta gör att NetBeans kan ladda ner och köra Java -program på Pi. Du kan hitta en lite generisk beskrivning här.

OBS: I detta och följande steg visar jag värden som är specifika för min miljö för olika aspekter av konfiguration och kodning; din kommer uppenbarligen att vara annorlunda.

Så här konfigurerar du Pi som en fjärrplattform:

1. I NetBeans huvudmenyrad väljer du Verktyg -> Java -plattformar. Du kommer att se Java Platform Manager -popup -fönstret (bild ett).
2. Klicka på Lägg till plattform nere till vänster. Du kommer att se popupen Lägg till Java -plattform [plattformstyp] (bild två).
3. Välj Remote Java Standard Edition. Klicka på Nästa. Du kommer att se popupen Lägg till Java -plattform [konfigurera fjärrplattform] (bild tre visar popup -fönstret efter att jag angett rätt värden för min miljö i fälten).
4. I fältet Plattformsnamn anger du ett namn för Pi. Du kan använda i stort sett vad som helst, men det måste vara unikt.
5. I fältet Värd anger du IP -adressen för Pi som hittades i steg 1.
6. Ange användarnamnet som du använde i steg 1 i fältet Användarnamn.
7. Lämna Använd lösenordsautentisering markerad och ange lösenordet som du skapade i steg 1 i fältet Lösenord.
8. I fältet Remote JRE Path måste du ange det mesta av sökvägen till Java -körtiden på Pi. I steg 1 var det/usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java. Du måste dock släppa av /bin /java i fältvärdet.
9. NetBeans hämtar det körbara programmet till en fungerande katalog på Pi, identifierad i fältet Working Dir. Standard är/the_Pi_user_ID/NetBeansProjects/och det är helt acceptabelt. Du kan använda något annat om du vill, även om det måste vara tillgängligt för_Pi_user_ID (bild tre).
10. Klicka på Slutför längst ned till höger i popup -fönstret. Efter bearbetning bör du åter se popup -fönstret för Java Platform Manager. Nu ska du se din fjärr -Pi (under namnet du använde i åtgärd 4 ovan) under kategorin Remote Java SE (bild fyra).
11. Klicka på Testplattform nere till vänster för att testa anslutningen mellan NetBeans och din Pi. Du kommer först att se en popup som säger Verifiera fjärrplattform. Om det lyckas får du en andra popup som anger att anslutningen … har upprättats. Om inte, måste du kontrollera och korrigera informationen du angav i popup-menyn Lägg till Java-plattform [konfigurera fjärrplattform] i åtgärder 5-9 ovan. Du kan göra det från Java Platform Manager -popupen; välj helt enkelt din Pi -plattform och redigera sedan fälten till höger om popup -fönstret.
12. Efter en lyckad anslutning klickar du på Stäng i Java Platform Manager -popup -fönstret. Du kommer nu att se NetBeans huvudfönster.

Nu kan det riktigt roliga börja!

Steg 4: Skapa ett Java -projekt på arbetsstationen

Detta är inte avsett att vara en fullständig förklaring till hur man använder NetBeans eller Java, men jag kommer att beskriva de minimala åtgärderna för att skriva ett program i NetBeans på arbetsstationen och så småningom köra programmet på distans på Raspberry Pi.

I NetBeans måste du först skapa ett projekt för att hålla Java -klassen för programmet. Vidare finns klasser i Java i paket för att stödja organisation och säkerhet. För att skapa projektet och eventuellt skapa ett paket och en klassfil:

1. I NetBeans huvudfönster klickar du på den nya projektikonen (2: a från vänster). Du kommer att se popup -fönstret Nytt projekt [välj projekt] (bild ett).
2. Standardinställningarna (kategori: Java, projekt: Java -program) är korrekta för det här exemplet, så klicka helt enkelt på Nästa. Du kommer att se popup -fönstret Nya Java -program [namn och plats] (bild två visar värden för mitt exempel). OBS: Jag har redigerat min användarinformation med de färgade rektanglarna.
3. I fältet Projektnamn anger du ett giltigt Java -projektnamn du väljer. Namnet måste börja med stor bokstav och konventionen föreslår kamelfall när ord sammanfogas.
4. Fältet Projektplats styr var projektet finns i ditt filsystem. Standarden varierar beroende på operativsystem, men är säkert att acceptera.
5. I fältet Projektmapp kan du styra projektets mappnamn. Jag tycker att det är bäst att använda standard, som är en sammanfogning av platsfältet och fältet Namn.
6. När kryssrutan Skapa huvudklass är markerad skapar NetBeans automatiskt ett paket och en huvudklassfil (ett program som kan köras från kommandoraden) med samma namn som projektet. Jag tror att det vanligtvis borde vara avmarkerat, men i det här fallet kommer jag att låta det vara kontrollerat vilket eliminerar specifika åtgärder som annars behövs för att göra det (bild två).
7. Klicka på Slutför för att skapa projektet, ett paket och en huvudklassfil. Nu visar den övre vänstra rutan i NetBeans huvudfönster ditt projekt, som innehåller ett enda paket, som i sin tur innehåller en enda klassfil med en huvudmetod (). Den övre högra rutan innehåller standardkällkoden för huvudklassen (programmet) som genereras automatiskt av NetBeans (bild tre).

Vid denna tidpunkt kan du skriva lite kod i huvudmetoden och köra den på arbetsstationen. Det kan ibland vara önskvärt, men det är onödigt för denna instruerbara, så fortsätt till nästa steg.

Steg 5: Konfigurera NetBeans -projektet så att det kan köras på distans på Raspberry Pi

Gör följande för att konfigurera NetBeans -projektet och ett program som det innehåller för att köras på distans på Raspberry Pi:

1. Klicka med höger eller två fingrar (beror på arbetsstationens operativsystem) på projektet i projektfönstret i NetBeans huvudfönster för att öppna projektmenyn och klicka på Egenskaper. Du kommer att se popup -fönstret Projektegenskaper (bilden visar popupen med rätt värden för mitt exempel).
2. Välj Kör under Kategorier till vänster.
3. Klicka på Ny till höger om konfigurationsfältet. I den resulterande popup -menyn Skapa ny konfiguration anger du ett namn för konfigurationen och klickar på OK. Namnet kan vara vad som helst; Jag har precis återanvänt namnet på plattformen ("My Pi"). Återigen ser du popup -fönstret Projektegenskaper.
4. Klicka på rullgardinsikonen till höger om Runtime Platform -fältet. Välj den fjärrplattform du skapade tidigare i listan i popup -fönstret (i min miljö, "My Pi").
5. Klicka på OK för att konfigurera fjärrplattformen för projektet. Du kommer igen att se huvudfönstret.

Du är nu redo att skriva kod och köra programmet på distans.

Steg 6: Skriv ett Java -program på arbetsstationen och kör det på Raspberry Pi

Den högra panelen i NetBeans huvudfönster visar huvudklassfilen som skapats av NetBeans. Skriv en enkel utskrift i huvudmetoden för klassfilen (bild ett). Det är nu ett komplett Java -program som gör något, men något väldigt enkelt.

För att köra programmet på Pi, klicka på ikonen Kör (den gröna vänsterpekade pilen) i huvudfönstret. NetBeans sammanställer koden, bygger en burkfil, hämtar burkfilen till Raspberry Pi som identifieras av fjärrplattformen, kör programmet på Pi, fångar programmets utdata (System.out) och ekar den utmatningen till NetBeans Utmatningsfönster längst ner till höger i huvudfönstret (bild två).

Du har nu väsentligt utökat din kompetens för att utveckla projekt på Raspberry Pi! Men vänta…. Det finns mer!

Steg 7: Debug Java -programmet med NetBeans

En av de mest kraftfulla funktionerna i en industriell styrka Integrerad utvecklingsmiljö som NetBeans är möjligheten att felsöka programmet medan det körs. Med NetBeans kan du utnyttja hela paketet med felsökningsverktyg medan du kör på distans. Detta inkluderar att ställa in brytpunkter på "viktiga" eller "besvärliga" platser i programmet och undersöka värdet på variabler vid det aktuella körningstillståndet.

Det enkla programmet i det sista steget är för enkelt för att demonstrera felsökning, så jag lade till ytterligare kod till programmet. Tilläggskoden lägger till två variabler.

För att utnyttja felsökningsverktygen måste du först ange en eller flera brytpunkter. För att ställa in en brytpunkt, klicka på det radnummer där du vill avbryta körningen; en röd rektangelikon visas och hela raden får en röd bakgrund (bild ett).

För att felsöka programmet som körs på Pi, klicka på felsökningsikonen (omedelbart till höger om ikonen Kör) i NetBeans huvudfönster. Precis som med vanligt körning sammanställer, bygger, hämtar, hämtar, kör, Netbeans utdata och ekar utmatningen. Men med felsökning stoppar NetBeans körningen vid brytpunkter och låter dig undersöka körningstillståndet (bild två, som visar fönstret Variabler längst ned till höger).

Utförandet stoppas vid brytpunkten innan instruktionen utförs på linjen med brytpunkten. Den gröna bakgrunden anger nästa sats som ska utföras. Således i mitt exempel, med en brytpunkt vid rad 9, finns variabel a ännu inte, mycket mindre har ett värde.

För muspekaren över ikonen för felsökning i huvudfönstret (den första dubbelpilen nedåt till höger om felsökningsikonen) och klicka på ikonen Steg över (den har ett blått dokument i bakgrunden och en grön pil moturs) i förgrunden). [OBS: om du gör ditt NetBeans -huvudfönster tillräckligt stort, expanderar felsökningsmenyn och felsökningsikonerna visas till höger om felsökningsikonen.] NetBeans kör meddelandet vid brytpunkten och stoppar körningen före nästa uttalande. Du kommer nu att se att variabeln a existerar och har det förväntade värdet (bild tre).

Klicka på ikonen Step Over två gånger. Du kommer att se att alla tre variablerna har värden; notera att c fortfarande är noll (bild fyra).

Klicka på Step Over -ikonen en gång. Du kommer att se att variabeln c nu har rätt värde, dvs summan av variablerna a och b (bild fem).

Slutligen, i felsökningsmenyn, klicka på ikonen Kör (en grön cirkel med en vit pil). Det gör att körningen fortsätter till nästa brytpunkt, eller till slutet av programmet, beroende på vad som inträffar först. Nu visas utmatningsfönstret och visar samma utdata som vid normalt körning, i detta fall texten i utskriftsuttalandet.

Steg 8: Kör programmet oberoende av NetBeans

Tiden kan komma när du vill köra ditt program på Raspberry Pi, utan "hjälp" eller "störning" från NetBeans. Det är väldigt enkelt. Öppna först en ssh -klient till din Pi.

Kom ihåg från steg 3 att NetBeans placerar din projektburk i en fungerande katalog på Pi. Standardbasen är/home/pi/NetBeansProjects för user pi. Den specifika katalogen har samma namn som ditt projekt. NetBeans placerar burken i en underkatalog som kallas dist. För mitt exempel är hela sökvägen/home/pi/NetBeansProjects/MyRemoteProg/dist. I ssh -klienten på Pi, för att köra programmet kan du använda java -kommandot med alternativet 'jar':

java -jar /home/pi/NetBeansProjects/MyRemoteProg/dist/MyRemoteProg.jar

Du kommer att se resultatet av körningen i ssh -klienten; i mitt exempel blir utdata

Hej från Raspberry Pi!

Detta fungerar eftersom informationen i burkfilen identifierar vilken huvudklass i burken som ska köras.

Du kan också ändra arbetskatalogen (via cd) till platsen för jarfilen och sedan utfärda ett kortare kommando för att få samma resultat.

java -jar MyRemoteProg.jar

Steg 9: Bygg och ladda ner, men kör inte programmet via NetBeans

Det finns situationer där du vill att NetBeans ska bygga och ladda ner ditt program, men inte köra det. En sådan situation uppstår när ditt program behöver tangentbordsinmatning. Om så är fallet, med hjälp av tekniken i föregående steg, när du har byggt och laddat ner, kör programmet på Raspberry Pi och förväntar sig så tangentbordsinmatning från Pi, men det finns naturligtvis inget tangentbord anslutet till Pi, så programmet hänger - inte bra.

Du måste använda en något annorlunda teknik för att köra programmet. I grunden skapar du en "dummy" huvudklassfil som i princip inte gör någonting, och identifierar den som programmet som ska köras efter nedladdning. I det här fallet körs "dummy", och du kan sedan köra ditt "riktiga" program direkt på Pi.

För att använda denna teknik, skapa först en ny huvudklass:

1. Öppna projektmenyn som i steg 5 och klicka på New-> Java Main Class. Du kommer att se den nya Java Main Class -popupen.
2. Ange ett namn i fältet Klassnamn. Namnet kan vara vad du vill; Jag använde "Dummy". I fältet Paket kan du identifiera klassens paket; du väljer paket med rullgardinsmenyn till höger om fältet. Klassen kan vara i samma paket som ditt "riktiga" program eller i ett annat paket; Jag satte den nya klassen i samma paket. Klicka på Slutför. Du kommer nu att se NetBeans huvudfönster med den nya filen i den övre högra panelen (bild ett). Jag lade till ett enkelt utskriftsuttalande om att köra på Pi, men inget behövs verkligen.

För att köra "Dummy" efter nedladdning måste du göra det till "huvudklassen att köra som standard" för projektet:

1. Öppna projektegenskaperna som i steg 5. Välj kategorin Kör. Klicka på Bläddra till höger om fältet Huvudklass. Du kommer att se popup -fönstret Bläddra i huvudklasser (bild två).
2. Välj klassen "Dummy". Klicka på Välj huvudklass. Du kommer igen att se projektegenskaperna.
3. Klicka på OK. Du kommer tillbaka till huvudfönstret.

Nu när du klickar på Kör -ikonen följer/bygger NetBeans hela projektet, laddar ner burken som innehåller alla klassfiler till Pi och kör "Dummy" -klassen (bild tre).

För att köra ditt riktiga program på Pi måste du nu använda java -kommandot med alternativet 'classpath', vilket kräver att du uttryckligen identifierar huvudklassen som ska köras. Från en ssh -klient går du till dist -katalogen för ditt projekt. Det rätta kommandot har följande form:

java -cp projektnamn.jar paketnamn.klassnamn

Projektnamnet avser uppenbarligen projektet; som bara ändras när man hanterar ett nytt projekt. Paketnamnet hänvisar naturligtvis till paketet, och klassnamnet hänvisar till huvudklassen som ska köras. Som sagt tidigare kan ett projekt innehålla många paket. På samma sätt kan ett paket innehålla många klasser, och alla kan vara huvudklasser eller program som kan köras från kommandoraden. Således är "klassväg" -tekniken ganska användbar för att utveckla sofistikerade program med många klasser, varav några är huvudklasser endast för att hjälpa enhetstestning.

Följande kommando kör mitt exempelprogram:

java -cp MyRemoteProg.jar myremoteprog. MyRemoteProg

Steg 10: Utnyttja NetBeans Library Management

En av de tuffaste men viktigaste aspekterna av sofistikerade program är att hantera bibliotek, det vill säga kod någon annan redan har skrivit. NetBeans gör ett beundransvärt jobb med att ta bort det mesta av smärtan vid bibliotekshantering.

Jag kommer att använda som ett exempel Pi4J, vilket ger Java -program åtkomst till Raspberry Pi GPIO, I2C -bussen och annan hårdvaru -I/O. Pi4J är bara ett exempel på stöd för att göra många roliga saker på Pi med Java.

Du måste först ladda ner biblioteket till din arbetsstation. Se nedladdningssidan för Pi4J. Eftersom du inte installerar Pi4J på Pi, ladda ner zip till din arbetsstation. Du kanske eller inte behöver uttryckligen packa upp zip -filen när zip -filen är nedladdad.

Nu måste du skapa ett "globalt bibliotek" i NetBeans:

1. Klicka på Verktyg -> Bibliotek i huvudmenyn i NetBeans. Du kommer att se popup -fönstret Ant Library Manager (bild ett).
2. Klicka på Nytt bibliotek längst ned till vänster. Du kommer att se popup -fönstret Nya biblioteket (bild två).
3. Skriv in ett meningsfullt namn som du vill använda och klicka på OK. Du kommer igen att se popup -fönstret Ant Library Manager. Det visar nu det nya biblioteket du skapade (bild tre).
4. Klicka på Lägg till JAR/mapp till höger. Du kommer att se popup -fönstret Browse JAR/Folder (bild fyra).
5. Navigera till och välj sedan pi4j-core.jar. Klicka sedan på Lägg till JAR/mapp. Du kommer tillbaka till popup -fönstret Ant Library Manager.
6. Klicka på OK i popup -fönstret Ant Library Manager. Du kommer tillbaka till NetBeans huvudfönster.

Du har lagt till biblioteket så att det kan användas i alla projekt. Nu måste du lägga till biblioteket i ditt projekt:

1. Öppna popup -fönstret Projektegenskaper (se steg 5) och välj kategorin bibliotek (bild fem).
2. Klicka på Lägg till bibliotek på höger sida av popup -fönstret. Du kommer att se popup -fönstret Lägg till bibliotek (bild sex).
3. Navigera till biblioteket och välj det. Klicka sedan på Lägg till bibliotek. Du kommer igen att se popup -fönstret Projektegenskaper. Biblioteket visas nu i listan över kompileringstidsbibliotek i popup-fönstret.
4. Klicka på OK i popup -fönstret Projektegenskaper. Du kommer tillbaka till huvudfönstret.

Du har lagt till biblioteket i ditt projekt så att ditt program kan använda det. Du kan utföra samma sekvens av åtgärder för alla bibliotek du behöver för ett program.

Det finns tre gånger du behöver biblioteket - kompilera, bygga och köra. Lyckligtvis, med NetBeans, hanterar allt bibliotek som visas ovan. För att bekräfta detta har jag skapat en annan huvudklass som gör det absoluta minimum som krävs för att använda I2C -funktionen i Pi4J (bild sju). Det faktum att det inte finns några fel som visar betyder att klassen TestPi4J kompilerar. Genom att klicka på Kör byggs och hämtas framgångsrikt. NetBeans laddar ner biblioteket utöver jar -filen, så programmet körs. För att verifiera det senare kan du använda tekniken i steg 9 och i ssh -klienten anger du följande kommando (från dist -katalogen):

java -cp MyRemoteProg.jar myremoteprog. TestPi4J

Det är lärorikt att förstå hur NetBeans hanterar bibliotek. I distkatalogen för ditt projekt listar du innehållet i katalogen (använd kommandot ls) så ser du en lib -underkatalog. Lista innehållet i den katalogen så ser du jarfilen som identifieras i det globala biblioteket, som i mitt exempel är pi4j-core.jar. Alla bibliotek som du lägger till i projektet visas i lib -katalogen och är därmed tillgängliga för alla program i projektburkfilen.

Steg 11: Go Have Fun

Jag har beskrivit ett tillvägagångssätt för att uppnå mycket effektiv Java -utveckling för Raspberry Pi. Raspberry Pi är en oerhört populär teknik för ett brett spektrum av projekt. Java är ett programmeringsspråk av professionell kvalitet som erbjuder prestandafördelar jämfört med Python och erbjuder säkerhetsfördelar jämfört med C/C ++. NetBeans är en professionell IDE som ökar programmerarens produktivitet kraftigt.

Jag tycker att kombinationen är ganska övertygande. Nu, ha kul med kombinationen för dina projekt.