Desenvolupament Java eficaç per al Raspberry Pi: 11 passos (amb imatges)

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:11

Aquesta instrucció descriu un enfocament molt eficient per desenvolupar programes Java per al Raspberry Pi. He utilitzat aquest enfocament per desenvolupar capacitats Java que van des del suport de dispositius de baix nivell fins a programes basats en xarxes i multi-threaded. L’enfocament no només és eficient, és gratuït.

Fonamentalment, l'enfocament és el desenvolupament remot mitjançant NetBeans. NetBeans funciona en una estació de treball (un ordinador de sobretaula o portàtil, no el Raspberry Pi) connectat mitjançant Wifi al Raspberry Pi. Una vegada que tot estigui configurat correctament, podeu escriure un programa Java a NetBeans i, a continuació, un sol clic compila i construeix el programa a l'estació de treball, descarrega el programa al Pi, executa el programa al Pi i lliura la sortida a la consola NetBeans. Màgia! Fins i tot podeu depurar el programa en execució, establir punts d'interrupció i examinar els valors de les variables. Més màgia!

La resta d'aquesta introducció descriu la motivació per utilitzar Java i per al desenvolupament remot mitjançant NetBeans. Si us interessa la motivació, seguiu llegint. Si no us interessa, aneu al pas 1.

Per què utilitzar Java al Raspberry Pi?

Hi ha molts llenguatges de programació disponibles per al Raspberry Pi, però limitaré la discussió a llenguatges de programació de "nivell professional" dirigits a programes independents, que admetin tasques múltiples, permetin l'accés al maquinari i a la xarxa, etc. Això vol dir que Java, Python o C / C ++. Les versions més recents de Raspbian inclouen desenvolupament i suport en temps d'execució per a tots aquests idiomes.

En realitat, Python està "promocionat" per al seu ús al Pi, almenys en part per la seva facilitat d'aprenentatge per a nous programadors. Sóc un programador experimentat i no m'agrada Python a causa d'una aversió, certament subjectiva, per algunes de les seves característiques, per exemple, la tipografia dinàmica. Hi ha una característica de Python per la qual la meva desagradabilitat és objectiva: el rendiment. Aquesta font mostra que Java sempre és més ràpid que Python 3 i, de fet, pot funcionar centenars de vegades més ràpid, segons la tasca.

Al meu entendre, C és un "llenguatge de màquina d'alt nivell", és a dir, una cosa que s'acosta molt al maquinari del sistema, o almenys al sistema operatiu. Podeu fer pràcticament qualsevol cosa i ho podeu fer el més ràpidament possible; de fet, aquesta font suggereix que C pot funcionar fins a 7 vegades més ràpid que Java. Tampoc no sóc aficionat a C ja que (subjectivament) no m'agraden algunes de les seves característiques que trobo arcanes, arcaiques o ambdues; per exemple, indicadors explícits. Objectivament, el fet que pugueu fer qualsevol cosa significa que només sou un error obscur (per exemple, una aritmètica del punter deficient o un memcpy errant) lluny de sobreescriure la memòria i, potencialment, de bloquejar el programa o fins i tot el sistema sencer. Java prevé aquests perills, de manera que Java és més segur. Crec que la seguretat també millora la productivitat del programador. Considero que C ++ és un "embolcall" orientat a objectes al voltant de C que no fa res per eliminar els perills de C.

La conclusió: Java és més ràpid que Python. Java és més segur que C.

Hi ha limitacions a l’hora d’utilitzar Java?

Fins ara, he pogut fer tot el que puc fer a Java a Python. Hi ha coses que es poden fer en C que no es poden fer a Java, però, de nou, fins ara tot el que volia fer ha estat abordat pels fans de Java de la comunitat Pi. Oferiré un exemple en un pas posterior. Dit això, he comprat sensors de proveïdors que subministraven "controladors" per als sensors només a Python (o C / C ++ per a l'Arduino), així que vaig haver d'escriure l'equivalent de Java; l'esforç addicional no és necessàriament productiu, però pot donar lloc a una millor comprensió del funcionament d'un sensor.

Per què el desenvolupament remot basat en NetBeans?

He descobert que el desenvolupament remot basat en NetBeans augmenta considerablement la productivitat quan s’utilitza Java per al Raspberry Pi. Estic segur que podeu utilitzar l'enfocament per crear programes ràpids i segurs, a causa de les característiques inherents a Java, mentre els escriviu, construïu i depureu molt més ràpidament que altres enfocaments que he trobat, a causa del desenvolupament remot que utilitza el "professional". de nivell "NetBeans Integrated Development Environment (IDE).

Pot ser útil discutir breument aquests "altres enfocaments". Tots compleixen els criteris bàsics perquè el Raspberry Pi no tingui connectat cap teclat, ratolí ni pantalla. Hi ha moltes raons per a aquest criteri, però el meu principal motiu és que desenvolupo robots mòbils i no vull que el Pi estigui connectat a cap perifèric, tret dels subsistemes robòtics, fins i tot durant el desenvolupament.

El servidor VNC inclòs a Raspbian proporciona una interfície gràfica d'usuari remota (GUI) que permet una forma de desenvolupament remot, on només la GUI remota s'executa a l'estació de treball i tota la resta, escriptura, compilació i construcció, té lloc al Pi. Amb VNC és fàcil utilitzar les eines de desenvolupament compatibles amb Java que s’inclouen a Raspbian, com BlueJ, Geany i Greenfoot. Alguns d'aquests es poden considerar un IDE; no obstant això, els trobo lluny del grau professional.

Tècnicament és possible instal·lar un IDE Java de qualitat professional com Eclipse o NetBeans al Raspberry Pi i utilitzar-lo remotament mitjançant VNC. Els informes i el sentit comú suggereixen que els resultats serien decebedors, a causa de la gran petjada de memòria i la potència de la CPU que necessiten aquests IDE, així com la latència de xarxa introduïda per una interfície gràfica d’usuari remota.

Tant Eclipse com NetBeans funcionen molt bé en una estació de treball. Amb Eclipse, escriure codi és una experiència agradable, però no és així construir el programa; la descàrrega del programa s'ha de fer fora d'Eclipse; executar el programa al Pi és completament independent d'Eclipse. El resultat general és un procés de diversos passos, gairebé dolorós, que no pot suportar la depuració remota. NetBeans ha incorporat compilació, compilació, descàrrega, execució remota i depuració remota, cosa que el converteix en un enfocament superior.

Pas 1: configureu el Raspberry Pi

Per utilitzar l'enfocament de desenvolupament remot, heu de començar configurant el Raspberry Pi objectiu. Hi ha molts recursos, inclosos Instructables, disponibles per ajudar-vos a configurar un Raspberry Pi. Vegeu això per conèixer els conceptes bàsics de configuració del Pi (i molt més).

Aquest instructable us assumeix

• instal·leu el darrer Raspbian; assegureu-vos d’enregistrar l’identificador d’usuari Pi i la contrasenya
• configureu Wifi i connecteu-vos al vostre encaminador (vegeu això); assegureu-vos d’enregistrar l’adreça IP del Pi
• activeu SSH (vegeu això) per permetre l'accés remot al Pi des de l'estació de treball

Un cop hàgiu completat la configuració, podeu apagar i desconnectar la pantalla, el teclat i el ratolí del Pi. Aquest és un dels avantatges clau del desenvolupament remot. Heu de deixar connectat qualsevol dongle Wifi (no cal, per descomptat, per a un model Pi 3 o Pi Zero W) i, a continuació, podeu encendre el Pi.

Per provar, obriu un client ssh a l'estació de treball, per exemple, Terminal a MacOS o massilla a Windows. A continuació, introduïu l'ordre ssh (shell segur) amb el formulari següent:

ssh the_pi_ip_address -l the_pi_user_id

Haureu de rebre una sol·licitud per introduir la contrasenya de l’identificador d’usuari Pi. Si no apareix cap missatge, comproveu que hàgiu introduït l'adreça IP adequada a l'ordre ssh. Introduïu la vostra contrasenya (estarà amagada) i hauríeu de veure el missatge de shell de Pi que apareix així:

pi @ raspberrypi: ~ $

Si no veieu la sol·licitud, comproveu l'identificador d'usuari i la contrasenya que heu utilitzat.

Ara heu de trobar el camí cap al temps d’execució de Java i confirmar que la versió per defecte és Java 8 (hauria de ser cert per a l’última versió de Raspbian). Per trobar el camí d’execució de Java, al client ssh introduïu l’ordre

sudo update-alternatives --display java

Hauríeu de veure una resposta amb les dues primeres línies que semblen les següents:

java - mode automàtic

La millor versió de l'enllaç és / usr / lib / jvm / jdk-8-oracle-arm32-vfp-hflt / jre / bin / java

El "-8-" de la segona línia confirma que el temps d'execució per defecte és Java 8. Anoteu el camí a la segona línia, ja que el necessitareu per configurar NetBeans per al desenvolupament remot en un pas posterior.

Si el temps d'execució per defecte no és Java 8, al client ssh introduïu l'ordre següent per canviar a Java 8 (suposant que estigui instal·lat)

sudo update-alternatives --config java

Pas 2: instal·leu NetBeans a l'estació de treball

Ara cal instal·lar NetBeans a la vostra estació de treball. Dirigiu el navegador de l'estació de treball a la pàgina de descàrrega de NetBeans. Veureu diversos paquets possibles que admeten les dues edicions de Java i altres idiomes. Tot el que necessiteu per al desenvolupament de Java per al Raspberry Pi és Java SE, però podeu obtenir el paquet Java EE o el paquet All. Un cop decidiu quin paquet voleu fer clic al botó de baixada corresponent. Aquí podeu trobar instruccions d’instal·lació addicionals per al sistema operatiu de l’estació de treball.

Un cop instal·lat NetBeans, inicieu-lo (pot fer-ho automàticament després de la instal·lació). Hauríeu de veure la finestra principal de NetBeans com es mostra a la imatge. La imatge es va fer en un Mac i la finestra principal pot semblar una mica diferent a Windows.

Un cop hàgiu instal·lat i iniciat NetBeans amb èxit, continueu amb el pas següent.

Pas 3: configureu el Raspberry Pi com a plataforma remota a NetBeans

Les accions següents configuren el Raspberry Pi com una plataforma remota de Java SE per a NetBeans. Això permet a NetBeans descarregar i executar programes Java al Pi. Podeu trobar una descripció una mica genèrica aquí.

NOTA: En aquest pas i en els següents, mostro valors específics del meu entorn per a diversos aspectes de configuració i codificació; el vostre serà, òbviament, diferent.

Per configurar el Pi com a plataforma remota:

1. A la barra de menú principal de NetBeans, seleccioneu Eines -> Plataformes Java. Veureu la finestra emergent del gestor de plataformes Java (imatge primera).
2. Feu clic a Afegeix plataforma a la part inferior esquerra. Veureu la finestra emergent Afegeix una plataforma Java [tipus de plataforma] (imatge segona).
3. Trieu Remote Java Standard Edition. Feu clic a Següent. Veureu la finestra emergent Afegeix una plataforma Java [configureu la plataforma remota] (la imatge tres mostra la finestra emergent després d’haver introduït els valors adequats per al meu entorn als camps).
4. Al camp Nom de la plataforma, introduïu un nom per al Pi. Podeu fer servir gairebé qualsevol cosa, però ha de ser únic.
5. Al camp Amfitrió, introduïu l'adreça IP del Pi que es troba al pas 1.
6. Al camp Nom d’usuari, introduïu el nom d’usuari que heu utilitzat al pas 1.
7. Deixeu l'opció Utilitza autenticació de contrasenya seleccionada i al camp Contrasenya introduïu la contrasenya que heu creat al pas 1.
8. Al camp Camí JRE remot, heu d'introduir la major part del camí d'accés al temps d'execució de Java al Pi. Al pas 1, era / usr / lib / jvm / jdk-8-oracle-arm32-vfp-hflt / jre / bin / java. Tanmateix, heu de deixar / bin / java al valor del camp.
9. NetBeans descarrega el programa executable a un directori de treball del Pi, identificat al camp Working Dir. El valor per defecte és / the_Pi_user_ID / NetBeansProjects / i és perfectament acceptable. Podeu fer servir alguna cosa diferent si ho desitgeu, tot i que ha d’estar disponible per a l’identificador_Pi_user_ID (imatge tres).
10. Feu clic a Finalitza a la part inferior dreta de la finestra emergent. Després de processar-lo, heu de tornar a veure la finestra emergent del Gestor de plataformes Java. Ara hauríeu de veure el vostre Pi remot (sota el nom que heu utilitzat a l’acció 4 anterior) a la categoria Remote Java SE (imatge quatre).
11. Feu clic a Prova la plataforma a la part inferior esquerra per provar la connexió entre NetBeans i el vostre Pi. Primer veureu una finestra emergent que diu Verificar la plataforma remota. Si té èxit, obtindreu una segona finestra emergent que indica la connexió … establerta correctament. Si no, heu de comprovar i corregir la informació que heu introduït a la finestra emergent Afegeix una plataforma Java [configura una plataforma remota] a les accions 5-9 anteriors. Podeu fer-ho des de la finestra emergent Java Platform Manager; simplement seleccioneu la vostra plataforma Pi i, a continuació, editeu els camps de la part dreta de la finestra emergent.
12. Després d'una connexió correcta, feu clic a Tanca a la finestra emergent del Gestor de plataformes Java. Ara veureu la finestra principal de NetBeans.

Ara pot començar la diversió!

Pas 4: creeu un projecte Java a l'estació de treball

No pretén ser una explicació completa de com utilitzar NetBeans o Java, però descriuré les accions mínimes per escriure un programa a NetBeans a l’estació de treball i, eventualment, executar el programa remotament al Raspberry Pi.

A NetBeans, primer heu de crear un projecte per contenir les classes Java del programa. A més, a Java, les classes resideixen en paquets per donar suport a l'organització i la seguretat. Per crear el projecte i, opcionalment, crear un paquet i un fitxer de classe:

1. A la finestra principal de NetBeans, feu clic a la icona del projecte nou (segona a l'esquerra). Veureu la finestra emergent Nou projecte [tria projecte] (imatge primera).
2. Els valors predeterminats (Categoria: Java, Projecte: Aplicació Java) són correctes per a aquest exemple, així que feu clic a Següent. Veureu la finestra emergent Nova aplicació Java [nom i ubicació] (la imatge dos mostra valors per al meu exemple). NOTA: He redactat la informació de l’usuari amb els rectangles de colors.
3. Al camp Nom del projecte, introduïu un nom de projecte Java vàlid que trieu. El nom ha de començar amb majúscula i la convenció suggereix majúscules i minúscules quan es concatenen paraules.
4. El camp Ubicació del projecte controla on resideix el projecte al vostre sistema de fitxers. El valor per defecte varia segons el sistema operatiu, però és segur d’acceptar.
5. El camp Carpeta del projecte us permet controlar el nom de la carpeta del projecte. Trobo que és millor utilitzar el valor per defecte, que és una concatenació del camp Ubicació i del camp Nom.
6. Quan la casella de selecció Crea classe principal NetBeans crea automàticament un paquet i un fitxer de classe principal (un programa que es pot executar des de la línia d'ordres) amb el mateix nom que el projecte. Crec que normalment no s'hauria de marcar, però en aquest cas ho deixaré marcat, cosa que elimina les accions explícites necessàries per fer-ho (imatge segona).
7. Feu clic a Finalitza per crear el projecte, un paquet i un fitxer de classe principal. Ara, el tauler superior esquerre de la finestra principal de NetBeans mostra el vostre projecte, que conté un sol paquet, que al seu torn conté un fitxer de classe única amb un mètode main (). El tauler superior dret conté el codi font per defecte de la classe principal (el programa) generat automàticament per NetBeans (imatge tres).

En aquest moment, podeu escriure algun codi al mètode principal i executar-lo a l’estació de treball. Això pot ser desitjable de vegades, però no és necessari per a aquesta instrucció, per tant, passeu al següent pas.

Pas 5: configureu el Projecte NetBeans perquè s'executi de forma remota al Raspberry Pi

Per configurar el projecte NetBeans i un programa que conté, per executar-se remotament al Raspberry Pi, feu el següent:

1. Feu clic amb el botó dret o amb dos dits (depèn del sistema operatiu de l'estació de treball) al projecte al panell Projectes de la finestra principal de NetBeans per obrir el menú del projecte i feu clic a Propietats. Veureu la finestra emergent Propietats del projecte (la imatge mostra la finestra emergent amb els valors adequats per al meu exemple).
2. A Categories a l'esquerra, seleccioneu Executa.
3. Feu clic a Nou a la dreta del camp Configuració. A la finestra emergent Crea nova configuració resultant, introduïu un nom per a la configuració i feu clic a D'acord. El nom pot ser qualsevol cosa; Acabo de reutilitzar el nom de la plataforma ("My Pi"). Una vegada més, veureu la finestra emergent Propietats del projecte.
4. Feu clic a la icona desplegable a la dreta del camp Plataforma d'execució. A la llista de la finestra emergent, seleccioneu la plataforma remota que heu creat anteriorment (al meu entorn, "El meu Pi").
5. Feu clic a D'acord per configurar la plataforma remota per al projecte. Tornareu a veure la finestra principal.

Ja esteu a punt per escriure codi i executar el programa de forma remota.

Pas 6: escriviu un programa Java a l'estació de treball i executeu-lo al Raspberry Pi

El tauler dret de la finestra principal de NetBeans mostra el fitxer de classe principal generat per NetBeans. Escriviu una declaració d'impressió simple al mètode principal del fitxer de classe (imatge primera). Ara és un programa Java complet que fa alguna cosa, tot i que és molt senzill.

Per executar el programa al Pi, feu clic a la icona Executa (la fletxa verda cap a l'esquerra) a la finestra principal. NetBeans compila el codi, crea un fitxer jar, descarrega el fitxer jar al Raspberry Pi identificat per la plataforma remota, executa el programa al Pi, captura la sortida (System.out) del programa i fa ressò de la sortida a NetBeans Tauler de sortida a la part inferior dreta de la finestra principal (imatge dos).

Ara heu ampliat significativament les vostres habilitats per desenvolupar projectes al Raspberry Pi. Però espera…. Hi ha més!

Pas 7: depureu el programa Java amb NetBeans

Una de les funcions més potents d'un entorn de desenvolupament integrat industrial com NetBeans és la capacitat de depurar el programa mentre s'executa. NetBeans us permet aprofitar el conjunt complet d’eines de depuració mentre s’executa de forma remota. Això inclou establir punts d'interrupció en ubicacions "importants" o "problemàtiques" del programa i examinar el valor de les variables en l'estat d'execució actual.

El programa senzill de l'últim pas és massa senzill per demostrar la depuració, de manera que he afegit un codi addicional al programa. El codi addicional afegeix dues variables.

Per aprofitar les eines de depuració, primer heu d’establir un o més punts d’interrupció. Per establir un punt d'interrupció, feu clic al número de línia on voleu suspendre l'execució; apareix una icona de rectangle vermell i tota la línia adquireix un fons vermell (imatge primera).

Per depurar el programa que s’executa al Pi, feu clic a la icona de depuració (immediatament a la dreta de la icona Executa) a la finestra principal de NetBeans. Com passa amb l'execució normal, NetBeans compila, crea, descarrega, executa, captura la sortida i fa ressò d'aquesta sortida. Però amb la depuració, NetBeans atura l'execució als punts d'interrupció i us permet examinar l'estat d'execució (imatge dos, mostrant el tauler Variables a la part inferior dreta).

L’execució s’atura al punt d’interrupció abans d’executar la instrucció a la línia amb el punt d’interrupció. El fons verd indica la següent instrucció que cal executar. Així, en el meu exemple, amb un punt d’interrupció a la línia 9, la variable a encara no existeix i molt menys té un valor.

Passa el cursor per sobre de la icona del menú de depuració de la finestra principal (la primera icona de doble fletxa cap avall a la dreta de la icona de depuració) i fes clic a la icona Pas per sobre (té un document blau al fons i una fletxa verda en sentit antihorari) en primer pla). [NOTA: si feu que la finestra principal de NetBeans sigui prou àmplia, el menú de depuració s’expandeix i les icones d’acció de depuració apareixen a la dreta de la icona de depuració.] NetBeans executa la sentència al punt de ruptura i atura l’execució abans de la següent sentència. Ara veureu que la variable a existeix i té el valor esperat (imatge tres).

Feu clic a la icona Pas per sobre dues vegades. Veureu que les tres variables tenen valors; tingueu en compte que c segueix sent zero (imatge quatre).

Feu clic a la icona Pas per sobre una vegada. Veureu que la variable c ara té el valor adequat, és a dir, la suma de les variables a i b (imatge cinc).

Finalment, al menú de depuració, feu clic a la icona Executa (un cercle verd amb una fletxa blanca). Això fa que l'execució continuï fins al següent punt d'interrupció o fins al final del programa, el que passi primer. Ara apareix el panell de sortida i mostra la mateixa sortida que amb l'execució normal, en aquest cas el text de la declaració d'impressió.

Pas 8: executeu el programa independent de NetBeans

Pot arribar el moment en què vulgueu executar el vostre programa al Raspberry Pi, sense "ajuda" ni "interferència" de NetBeans. És molt senzill. Primer, obriu un client ssh al vostre Pi.

Recordeu des del pas 3 que NetBeans col·loca el vostre pot del projecte en un directori de treball al Pi. La base per defecte és / home / pi / NetBeansProjects per a l'usuari pi. El directori específic té el mateix nom que el vostre projecte. NetBeans col·loca el pot en un subdirectori anomenat dist. Per al meu exemple, el camí complet és / home / pi / NetBeansProjects / MyRemoteProg / dist. Al client ssh del Pi, per executar el programa podeu utilitzar l'ordre java amb l'opció 'jar':

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

Veureu els resultats de l'execució al client ssh; en el meu exemple, la sortida serà

Hola a Raspberry Pi!

Això funciona perquè la informació del fitxer jar identifica la classe principal del jar que cal executar.

També podeu canviar el directori de treball (mitjançant CD) a la ubicació del fitxer jar i, a continuació, emetre una ordre més curta per obtenir els mateixos resultats.

java -jar MyRemoteProg.jar

Pas 9: Compreu i descarregueu, però no executeu el programa mitjançant NetBeans

Hi ha situacions en què voleu que NetBeans construeixi i descarregui el vostre programa, però no l'executi. Una d'aquestes situacions es produeix quan el vostre programa necessita l'entrada de teclat. Si aquest és el cas, utilitzant la tècnica del pas anterior, una vegada que construïu i descarregueu, el programa s’executa al Raspberry Pi i, per tant, espera l'entrada del teclat del Pi, però, per descomptat, no hi ha cap teclat connectat al Pi, de manera que el programa es penja, no és bo.

Heu d’utilitzar una tècnica una mica diferent per executar el programa. Fonamentalment, creeu un fitxer de classe principal "fictici" que bàsicament no fa res i l'identifiqueu com el programa que s'executarà després de la descàrrega. En aquest cas, el "maniquí" s'executa i, a continuació, podeu executar el vostre programa "real" directament al Pi.

Per utilitzar aquesta tècnica, primer creeu una nova classe principal:

1. Obriu el menú del projecte com al pas 5 i feu clic a Nou-> Java Main Class. Veureu la finestra emergent New Java Main Class.
2. Al camp Nom de classe, introduïu un nom. El nom pot ser qualsevol cosa que vulgueu; He utilitzat "Dummy". El camp Paquet us permet identificar el paquet de la classe; seleccioneu el paquet mitjançant el menú desplegable situat a la dreta del camp. La classe pot estar al mateix paquet que el vostre programa "real" o en un paquet diferent; Vaig posar la nova classe al mateix paquet. Feu clic a Finalitza. Ara veureu la finestra principal de NetBeans amb el nou fitxer al tauler superior dret (imatge primera). Vaig afegir una declaració simple d’impressió sobre l’execució al Pi, però realment no cal res.

Per executar "Dummy" després de la descàrrega, heu de convertir-la en la "classe principal per executar per defecte" per al projecte:

1. Obriu les propietats del projecte com al pas 5. Seleccioneu la categoria Executa. Feu clic a Navega a la dreta del camp Classe principal. Veureu la finestra emergent Examinar classes principals (imatge segona).
2. Seleccioneu la classe "Dummy". Feu clic a Selecciona la classe principal. Tornareu a veure les propietats del projecte.
3. Feu clic a D'acord. Tornareu a la finestra principal.

Ara, quan feu clic a la icona Executa, NetBeans compleix / construeix tot el projecte, descarrega el contenidor que conté tots els fitxers de classe al Pi i executa la classe "Dummy" (imatge tres).

Per executar el vostre programa real al Pi, ara heu d'utilitzar l'ordre java amb l'opció 'classpath', que requereix que identifiqueu explícitament la classe principal que s'executarà. Des d'un client ssh, aneu al directori dist del vostre projecte. El comandament adequat té la forma següent:

java -cp nom_projecte.jar nom_ paquet.nom_classe

El nom_projecte es refereix òbviament al projecte; això només canvia quan es tracta d'un nou projecte. Per descomptat, package_name es refereix al paquet i class_name es refereix a la classe principal a executar. Com s’ha dit anteriorment, un projecte pot contenir molts paquets. De la mateixa manera, un paquet pot contenir moltes classes i totes podrien ser classes principals o programes que es poden executar des de la línia d'ordres. Per tant, la tècnica "classpath" és força útil per desenvolupar programes sofisticats amb moltes classes, algunes de les quals són classes principals només per ajudar a provar unitats.

L'ordre següent executa el meu programa d'exemple:

java -cp MyRemoteProg.jar myremoteprog. MyRemoteProg

Pas 10: aprofiteu la gestió de biblioteques de NetBeans

Un dels aspectes més difícils però importants dels programes sofisticats és tractar amb les biblioteques, és a dir, codificar una altra persona que ja ha escrit. NetBeans fa una feina admirable d’eliminar la major part del dolor de la gestió de biblioteques.

Utilitzaré com a exemple Pi4J, que dóna accés als programes Java al Raspberry Pi GPIO, al bus I2C i a altres E / S de maquinari. Pi4J és només un exemple de suport per fer moltes coses divertides al Pi amb Java.

Primer heu de descarregar la biblioteca a la vostra estació de treball. Consulteu la pàgina de descàrrega de Pi4J. Com que no esteu instal·lant Pi4J al Pi, descarregueu el zip a la vostra estació de treball. És possible que hagueu de descomprimir explícitament un cop descarregat el fitxer zip.

Ara heu de crear una "biblioteca global" a NetBeans:

1. Al menú principal de NetBeans, feu clic a Eines -> Biblioteques. Veureu la finestra emergent del Gestor de biblioteques Ant (imatge primera).
2. Feu clic a Biblioteca nova a la part inferior esquerra. Veureu la finestra emergent Nova biblioteca (imatge segona).
3. Escriviu el nom significatiu que vulgueu utilitzar i feu clic a D'acord. Tornareu a veure la finestra emergent del Gestor de biblioteca de formigues. Ara mostra la nova biblioteca que heu creat (imatge tres).
4. Feu clic a Afegeix JAR / carpeta a la dreta. Veureu la finestra emergent Examinar JAR / Carpeta (imatge quatre).
5. Aneu a i seleccioneu pi4j-core.jar. A continuació, feu clic a Afegeix JAR / carpeta. Tornareu a la finestra emergent Administrador de biblioteca de formigues.
6. A la finestra emergent Gestor de biblioteques de formigues, feu clic a D'acord. Tornareu a la finestra principal de NetBeans.

Heu afegit la biblioteca perquè es pugui utilitzar en qualsevol projecte. Ara heu d'afegir la biblioteca al vostre projecte:

1. Obriu la finestra emergent Propietats del projecte (vegeu el pas 5) i seleccioneu la categoria Biblioteques (imatge cinc).
2. Feu clic a Afegeix biblioteca a la part dreta de la finestra emergent. Veureu la finestra emergent Afegeix biblioteca (imatge sis).
3. Aneu a la biblioteca i seleccioneu-la. A continuació, feu clic a Afegeix biblioteca. Tornareu a veure la finestra emergent Propietats del projecte. La biblioteca apareix ara a la llista de biblioteques en temps de compilació de la finestra emergent.
4. A la finestra emergent Propietats del projecte, feu clic a D'acord. Tornareu a la finestra principal.

Heu afegit la biblioteca al vostre projecte perquè el vostre programa el pugui utilitzar. Podeu fer la mateixa seqüència d'accions per a totes les biblioteques que necessiteu per a un programa.

Hi ha tres vegades que necessiteu la biblioteca: compilar, construir i executar. Afortunadament, amb NetBeans, s'afegeix la biblioteca tal com es mostra anteriorment, es gestiona tot. Per confirmar-ho, he creat una altra classe principal que fa el mínim absolut necessari per utilitzar la capacitat I2C a Pi4J (imatge set). El fet que no es mostrin errors significa que es compila la classe TestPi4J. Si feu clic a Executa, es construeixen i es descarreguen amb èxit; NetBeans descarrega la biblioteca a més del fitxer jar, de manera que el programa s’executarà. Per verificar aquest últim, podeu utilitzar la tècnica al pas 9 i al client ssh introduïu l'ordre següent (del directori dist):

java -cp MyRemoteProg.jar myremoteprog. TestPi4J

És instructiu entendre com NetBeans gestiona les biblioteques. Mentre esteu al directori dist per al vostre projecte, enumereu el contingut del directori (utilitzeu l'ordre ls) i veureu un subdirectori lib. Enumereu el contingut d’aquest directori i veureu el fitxer jar identificat a la biblioteca global, que al meu exemple és pi4j-core.jar. Totes les biblioteques que afegiu al projecte apareixeran al directori lib i, per tant, estan disponibles per a tots els programes del fitxer jar del projecte.

Pas 11: Aneu a passar-ho bé

He descrit un enfocament per aconseguir un desenvolupament Java molt eficient per al Raspberry Pi. El Raspberry Pi és una tecnologia molt popular per a un ampli espectre de projectes. Java és un llenguatge de programació de nivell professional que ofereix avantatges de rendiment respecte a Python i ofereix avantatges de seguretat respecte a C / C ++. NetBeans és un IDE de grau professional que augmenta considerablement la productivitat del programador.

Crec que la combinació és força convincent. Ara, ves a divertir-te utilitzant la combinació per als teus projectes.