Java-Anwendung wurde in einer Google Drive-Datenbank ausgeführt - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:20

Wollten Sie schon immer eine Anwendung erstellen, die auf einer dynamischen Datenbank läuft, mit der einfach zu arbeiten ist, die es technisch nicht versierten Benutzern ermöglicht, Daten einzugeben und die Unternehmensressourcen nicht erschöpft? Nun, dann habe ich eine Lösung für Sie. Heute werden wir eine Anwendung erstellen, die auf Google Drive (genauer gesagt Google Sheets) läuft und für eine Vielzahl von verschiedenen Zwecken verwendet werden kann. Obwohl sich dieses Tutorial auf die Erstellung einer ereignisbasierten App konzentriert, um eine Liste von Ereignissen auf einem College-Campus anzuzeigen, kann dieses Projekt leicht so umgeschrieben werden, dass es auf vielfältige Weise funktioniert, sei es eine Taschenrechner-App oder eine App, die überwacht Lagerbestände für Produkte. Ich habe eine Kopie meiner Bewerbung beigefügt, wenn Sie sehen möchten, was wir machen werden. Entpacken Sie die Zip-Datei und führen Sie das darin enthaltene JAR aus. Und jetzt, ohne weiteres, fangen wir an!

Schritt 1: Was Sie brauchen

Um mit diesem Projekt zu beginnen, benötigen Sie die folgenden Ressourcen:

• Netzbohnen

  Ich empfehle den Java EE-Download, da er Serverunterstützung bietet, aber wenn Sie keine unnötigen Dateien oder zusätzlichen Speicherplatz benötigen, funktioniert auch Java SE. Netbeans wird als unsere IDE zum Codieren und Kompilieren unserer Anwendung dienen

• Jsuppe

  Ich habe dies in den Instructables für Sie zum Download enthalten. Es ist ein HTML-Parser, mit dem wir Informationen aus der veröffentlichten Tabelle abrufen können

• Java-SDK (V8)

  Laden Sie die Datei herunter, die zu Ihrem System passt. Wenn Sie das Java SDK bereits in einer früheren Version haben, empfehle ich ein Update. Einige meiner Funktionen verwenden neue native Lambda-Ausdrücke von v8, und der Code funktioniert möglicherweise nicht ohne sie, je nachdem, was Sie tun

• Visual Studio (optional)

  Völlig optional. Obwohl NetBeans beim Kompilieren und Verpacken unserer App hervorragend funktioniert, bin ich kein großer Fan des Entwicklungsstudios. Ich ziehe es vor, in VS zu programmieren, da es eine schönere Oberfläche hat. Wenn Ihnen das nicht gefällt, gibt es viele andere IDEs online, also finden Sie, was Ihnen am besten gefällt

• Startcode

  Ich habe den Startercode in die Ressourcen dazu aufgenommen und auch auf GitHub veröffentlicht. Darin habe ich die Hauptdatei (Event), die die Struktur für die Datei bereitstellt, die die App tatsächlich ausführt, sowie EventTester, der JavaFX verwendet, um die GUI für die App zu erstellen. Wenn Sie die volle Erfahrung machen möchten, empfehle ich das Kopieren und Einfügen nicht. Nehmen Sie sich Zeit und lesen Sie sich das durch

Andere:

Grundkenntnisse in Java. Es ist hilfreich, Java-Kenntnisse zu haben, z. B. Funktionen schreiben, Objekte erstellen usw

Schritt 2: Einrichten Ihrer Datenbank

Um das Projekt zu starten, müssen wir zuerst in Google Drive gehen und das Blatt erstellen, das wir zum Ausführen unserer Anwendung verwenden. Gehen Sie zu drive.google.com und klicken Sie oben links auf das Symbol "Neu" und wählen Sie darunter "Tabellen".

Sobald Ihr Blatt geladen ist, benennen Sie es in einen leicht erkennbaren Namen um. Fahren Sie anschließend fort und füllen Sie die oberste Zeile mit Ihren Datennamen aus, z. B. den Dingen, die Sie in jede Spalte einfügen. Wenn ich mir mein Beispiel hier anschaue, habe ich die obere Zeile mit Dingen wie "Ereignisname", "Datum" usw. beschriftet.

Beginnen Sie anschließend damit, Ihre Tabelle mit den Daten zu füllen, die Sie ausfüllen möchten. Denken Sie daran, alle Ihre Daten ähnlich zu formatieren, damit der Code damit arbeiten kann, ohne Fehler auszulösen. Wenn Sie beispielsweise Datumsangaben in Ihrem Code verwenden möchten, achten Sie darauf, jedes Datum gleich zu formatieren, da sonst der Code es nicht analysieren kann.

Nachdem Sie Ihre Daten eingegeben haben, veröffentlichen Sie die Tabelle, indem Sie auf "Datei" -> "Im Web veröffentlichen" klicken. Von hier aus sollten Sie das gesamte Dokument auswählen und sicherstellen, dass es als HTML-Datei veröffentlicht wird, damit unsere App die Daten korrekt zeichnen kann. Nachdem Sie Ihre Tabelle veröffentlicht haben, notieren Sie sich den darin enthaltenen Link. Dies wird später in der App benötigt.

Schritt 3: NetBeans einrichten

Da wir nun unsere Tabelle haben, ist es an der Zeit, NetBeans einzurichten, damit wir mit dem Codieren beginnen können. Nachdem Sie NetBeans und Ihr Java SDK heruntergeladen und installiert haben, können Sie ein neues Projekt erstellen. Wählen Sie bei der Auswahl eines Typs die Kategorie "Java" und das Projekt "Java-Anwendung". Wählen Sie aus, wie Ihr Projekt heißen soll (ich habe meins einfach "Event" genannt). Aktivieren Sie das Kontrollkästchen neben "Dedizierten Ordner zum Speichern von Bibliotheken verwenden" sowie das Kontrollkästchen neben "Hauptklasse erstellen". Danach sollte NetBeans ein Projekt und ein Projektverzeichnis erstellen, in dem wir mit der Arbeit beginnen können, ähnlich dem abgebildeten.

Bevor wir mit dem Programmieren beginnen, müssen wir auch sicherstellen, dass NetBeans über die JSoup-Bibliothek verfügt, die es zum Parsen unserer Tabelle benötigt. Klicken Sie in NetBeans mit der rechten Maustaste auf das Symbol "Bibliotheken" unter Ihrem Projektverzeichnis. Wählen Sie im Popup-Menü die Schaltfläche aus, um eine.jar-Datei hinzuzufügen. Navigieren Sie nun zu dem Ort, an dem Sie Ihren jsoup-Download abgelegt haben (höchstwahrscheinlich Ihr Downloads-Ordner, es sei denn, Sie haben an anderer Stelle angegeben). Wählen Sie diese Datei aus und fügen Sie sie der Bibliothek hinzu. Wenn Sie Ihren Libraries-Ordner in NetBeans erweitern, sollten Sie jetzt die jsoup.jar in diesem Bereich sehen. Nachdem wir dies getan haben, können wir nun mit der Programmierung unserer App beginnen.

Schritt 4: Codierung unserer Hauptklasse

Der erste Schritt beim Codieren unserer App besteht also darin, Ihre Hauptklasse zu erstellen. In Ihrer Hauptklasse erstellen wir unsere Objekte, haben die Methoden, die mit JSoup interagieren, und mehr. Angenommen, jeder, der dies liest, hat Erfahrung mit dem Programmieren, fahren Sie fort und verwenden Sie die folgenden Importe:

java.util. Collections importieren;

java.util. List importieren;

import java.util. ArrayList;

java.util. Datum importieren;

java.util.stream. Stream importieren;

java.util.stream. Collectors importieren;

import java.text. SimpleDateFormat;

import java.text. ParseException;

import org.jsoup. Jsoup;

org.jsoup.nodes. Document importieren;

import org.jsoup.nodes. Element;

import org.jsoup.select. Elements;

import javafx.beans.property. SimpleStringProperty;

Dies mag viel erscheinen, und je nach Ihrem Projekt ist möglicherweise nicht alles erforderlich. Während wir weiter codieren, werden Sie von NetBeans benachrichtigt, wenn Sie ungenutzte Importe haben, damit wir sie später jederzeit löschen können. Dies ist jedoch das, was wir jetzt brauchen.

Nachdem wir unsere Import-Anweisungen erhalten haben, deklarieren wir unsere Klasse. Wenn Sie bei der Entwicklung Ihres klassenspezifischen Objekts Dates oder ein anderes nicht grundlegendes Objekt verwenden möchten, empfehle ich, Ihrer Klassendeklaration ein "implements Comparable" hinzuzufügen. Auf diese Weise können Sie Objekte vergleichen, wodurch Sie später eine Liste von Klassenobjekten sortieren können. Fahren Sie anschließend fort und deklarieren Sie alle benötigten Instanzvariablen. Für jeden öffentlichen String, den Sie erstellen, müssen Sie auch SimpleStringProperty dafür erstellen. Dies sind JavaFX-Objekte, die es uns ermöglichen, später mit unseren Hauptklassenobjekten zu arbeiten.

Machen Sie jetzt weiter und deklarieren Sie Ihre Zugriffsfunktionen. Was Ihre grundlegenden Variablen betrifft, können Sie Ihre Funktionen nach Belieben benennen. Für Ihre SSP-Zugriffsfunktionen müssen Sie jedoch das Format getFunctionNameHere() verwenden. Dies liegt daran, dass wir später JavaFX verwenden werden, um eine Verbindung zu diesen Funktionen herzustellen, und die Funktionen, die wir verwenden werden, erfordern, dass wir unsere SSP-Funktionen mit get beginnen. Ein Beispiel sehen Sie oben.

Nachdem Sie alle Ihre Zugriffsvariablen definiert haben, legen Sie alle anderen Funktionen fest, die Sie möglicherweise benötigen. Dies ist sehr benutzerspezifisch, da die benötigten Funktionen von Projekt zu Projekt unterschiedlich sind. Wenn Sie Inspiration brauchen, sehen Sie sich mein Javadoc oder den aktuellen Code an und sehen Sie sich einige der von mir erstellten Funktionen an. Ich habe zum Beispiel eine Sortierfunktion erstellt, die eine Liste nach Datum sortiert, sowie Funktionen, die nur Ereignisse mit dem Gruppenstatus "öffentlich" zurückgegeben haben, und mehr. Obwohl es in Ordnung ist, diese statisch zu machen, damit Sie einige Tests durchführen können, empfehle ich, nach dem Debuggen keine statischen Methoden zu verwenden, um Fehler beim nächsten Schritt des Projekts zu vermeiden.

Schritt 5: Definieren unserer Create()-Methode

Jetzt kommt der möglicherweise wichtigste Teil des Codes, in dem wir unsere create()-Methode definieren werden, die tatsächlich auf unsere Webseite zugreift und uns die Daten liefert. Es ist wichtig zu beachten, dass Sie Ihrer Methodendeklaration eine Zeile throws Exception hinzufügen müssen, damit wir keine try-Blöcke in unseren Code schreiben müssen. Um zu beginnen, fahren Sie fort und deklarieren Sie eine leere Liste Ihres Objekts. In meinem Fall sah es so aus

Ereignisereignisse = neue ArrayList()).

Suchen Sie nun die URL, die Sie zuvor in die veröffentlichte Tabelle kopiert haben. Deklarieren Sie diesen Link in Java als String und nennen Sie ihn wie immer Sie wollen. Fahren Sie nun fort und deklarieren Sie ein neues Jsoup-Dokument. Sie können dies tun, indem Sie ein neues Dokumentobjekt erstellen, wie z

Dokumentdokument = neues Dokument();

Fahren Sie jetzt fort und stellen Sie Ihr Dokument so ein, dass es eine Verbindung zu unserer URL herstellt und die Daten erhält. Versuchen Sie dazu:

Dokument doc = Jsoup.connect(url).get();

Jetzt müssen wir den Textkörper unseres Dokuments abrufen, in dem die tatsächlichen Daten gespeichert werden.

String-Körper = doc.body().text();

Jetzt müssen wir damit beginnen, Daten aus dem Körper zu ziehen. Da sich unsere Daten in einer Tabelle befinden (da es sich um eine Tabelle handelte), müssen wir die Tabelle aus dem Körper ziehen. Lass es uns versuchen

Elementtabelle = doc.select("Tabelle").get(0);

Dadurch wird die erste Tabelle ausgewählt. In diesem Fall gibt es nur einen. Geben Sie jetzt ein

Elemente Zeilen = table.select("tr");

Dadurch erhalten wir alle Zeilen in der Tabelle.

Nun befinden sich alle unsere Daten in dieser Zeilenvariablen. Das ist gut und alles, aber der springende Punkt beim Schreiben dieser Funktion innerhalb dieser Klasse besteht darin, dass wir daraus Objekte erstellen können. Bevor wir dies zurückgeben können, müssen wir eine Liste aus unseren Zeilen erstellen. Dazu können wir eine for-Schleife verwenden. Ich muss anmerken, dass ich ein wenig Versuch und Irrtum brauchte, um das richtig zu machen. Ich habe festgestellt, dass beim Ziehen aus den Zeilen einige unserer Daten für diese Situation nicht nützlich sind, da sie Dinge wie den Namen des einzelnen Blatts, die erste Zeile mit unseren Datenideen usw. bereitstellen. Am Ende setze ich die Initiale Geben Sie die Zahl für die for-Schleife auf 2 ein, damit diese Elemente umgangen werden und unsere Elemente erstellt werden können. Am Ende habe ich einen Look mit dem Code entwickelt

for (int i = 2; i < rows.size(); i++) {

Elementzeile = rows.get(i);

Elemente cols = row.select("td");

Um nun ein Objekt zu erstellen, tun Sie etwas wie

Objektname = neues Objekt(cols.get(0).text());

Im Wesentlichen holt cols.get(0) die Daten aus row(i) column(0) und wandelt sie in einen String um, der dann an den Konstruktor des Objekts übergeben werden kann.

Nachdem Sie Ihre Konstruktion eingerichtet haben, fügen Sie sie der zuvor mit list.add() erstellten Liste hinzu, z. B.

events.add(Name);

Schließen Sie nun Ihre for-Schleife und rufen Sie alle Funktionen auf, die Sie jetzt möglicherweise benötigen. Zum Beispiel habe ich meine Sortierfunktion aufgerufen, um die Ereignisse nach Datum zu ordnen. Geben Sie danach Ihre Liste zurück und Sie sind mit diesem Abschnitt fertig!

Schritt 6: Codieren unserer Anwendung

Erstellen Sie eine neue Datei und benennen Sie sie nach Belieben. Sie benötigen folgende Importe:

java.util. List importieren;

import java.util. ArrayList;

java.util. Datum importieren;

javafx.geometry. Pos importieren;

javafx.scene.layout. HBox importieren;

javafx.application. Application importieren;

import javafx.collections.transformation. FilteredList;

javafx.scene.text. Font importieren; javafx.scene.control.* importieren;

import javafx.collections. FXCollections;

import javafx.collections. ObservableList;

javafx.geometry. Insets importieren;

javafx.scene. Group importieren;

javafx.scene. Scene importieren;

import javafx.scene.control. Label;

import javafx.scene.control.cell. PropertyValueFactory;

javafx.scene.layout. VBox importieren;

javafx.stage. Stage importieren;

Ich weiß, das mag viel erscheinen, aber glauben Sie mir, sie sind notwendig, damit wir unsere Anwendung erstellen können. Fahren Sie fort und deklarieren Sie Ihre Klasse und stellen Sie sicher, dass sie Application erweitert, da dies eine notwendige Komponente des Projekts ist. Deklarieren Sie zu Beginn eine neue Instanzvariable, die eine TableView Ihres Objekts ist, wie z

private TableView-Tabelle = new TableView();

Deklarieren Sie außerdem eine Hauptmethode, mit der wir die App starten. Im Wesentlichen sollte es wie auf dem Bild oben aussehen.

Jetzt müssen wir unsere Startmethode erstellen. Stellen Sie sicher, dass Exception ausgelöst wird, da wir die create()-Methode unserer früheren Klasse aufrufen. Erstellen Sie ein neues Ereignis mit leeren Parametern, einfach damit wir die Methode create damit aufrufen können. Definieren Sie eine neue Liste und setzen Sie sie gleich dem Ergebnis von create(). Erstellen Sie nun eine neue ObservableList, die verwendet wird, um unsere Tabelle mit unseren Daten zu füllen. Definiere es wie folgt:

ObservableList-Daten = FXCollections.observableArrayList();

Erstellen Sie nun eine neue Szene mit:

Szenenszene = neue Szene (neue Gruppe ());

Legen Sie den Titel, die Breite, die Höhe und alles andere fest, was Sie für alles benötigen, was für Sie funktioniert. Sie können meine Werte im Bild oben sehen. Nun können wir mit dem Aufbau unseres Tisches beginnen. Erstellen Sie für alle Informationen, die Sie anzeigen möchten, eine TableColumn wie:

TableColumn eventCol = new TableColumn("Ereignisname");eventCol.setMinWidth(100); eventCol.setCellValueFactory(new PropertyValueFactory("sName"));

Der Parameter "sName" sollte mit dem Namen Ihrer SSP-Zugriffsfunktionen gefüllt werden, damit er die Werte erhalten kann, die Sie für die angegebenen Objekte benötigen. Erstellen Sie so viele Spalten, wie Sie benötigen, und fügen Sie sie dann mit zu einer Tabelle hinzu

FilteredList flEvent = new FilteredList(data, p -> true);

table.setItems(flEvent);

table.getColumns().addAll(eventCol, statCol, groupCol, datingCol, descCol, locationCol);

Wenn Sie wie ich eine Suchleiste hinzufügen möchten, überprüfen Sie den Code, um Informationen zum Erstellen einer ChoiceBox und eines TextFields zu erhalten, mit denen Ihr Benutzer die Tabelle nach bestimmten Werten filtern kann. Wenn Sie sich dafür entschieden haben, müssen Sie auch eine hBox erstellen, um diese zu enthalten, mit

HBox hBox = neue HBox(choiceBox, textField);

hBox.setAlignment(Pos. CENTER);

Sie müssen auch hBox zur Methode.addAll() unten hinzufügen.

Andernfalls erstellen Sie einfach eine neue vBox, um unsere Daten zu speichern, indem Sie tun

letzte VBox vbox = neue VBox();

vbox.getChildren().addAll(Beschriftung, Tabelle);

((Gruppe) scene.getRoot()).getChildren().addAll(vbox);

stage.setScene (Szene); Bühnenshow();

Kompilieren Sie nun Ihren Code, führen Sie ihn aus und prüfen Sie, ob er funktioniert. Verwenden Sie NetBeans, um Fehler zu finden, die als rote Balken auf der rechten Seite des Bildschirms angezeigt werden. Führen Sie dies so lange aus, bis keine Fehler mehr auftreten und das Projekt ausgeführt wird.

Nachdem Sie Ihre Codierung abgeschlossen haben, empfehle ich Ihnen, ein Javadoc Ihres Codes zu erstellen, damit die Leute sehen können, was Ihr Code macht. Klicken Sie dazu unter der Schaltfläche "Ausführen" oben auf dem Bildschirm einfach auf "Javadoc generieren". Sie können eine Kopie meines Javadoc finden, indem Sie in die Zip-Datei auf der ersten Seite schauen und die Datei index.html auswählen.

Schritt 7: Kompilieren und Verpacken unserer Jar-Datei

Sobald Sie Ihre Software ausreichend debuggt und erfolgreich ausgeführt haben, können Sie diese schließlich in eine JAR-Datei kompilieren, die dann veröffentlicht werden kann, damit andere diese Software ohne NetBeans oder Jsoup ausführen können.

Stellen Sie vor dem Kompilieren Ihrer App sicher, dass alles erledigt ist. Wenn Sie Dokumentation hinzufügen und ein JavaDoc erstellen möchten, können Sie dies tun. Wenn Sie über System.out-Befehle verfügen, die auf Ihrer Konsole ausgegeben werden, entfernen Sie diese. Stellen Sie im Wesentlichen sicher, dass Ihre App keine unerwünschten Befehle oder Funktionen enthält und alles enthält, was zum Verpacken benötigt wird.

Klicken Sie anschließend mit der rechten Maustaste auf den Projektnamen in NetBeans. Es sollte ein Menü erscheinen. Klicken Sie auf Eigenschaften (ganz unten im Menü) und dann auf "Verpackung" auf der linken Seite des neuen Popup-Menüs. Stellen Sie nun sicher, dass alle Kontrollkästchen markiert sind. Ihr Bildschirm sollte wie oben aussehen.

Klicken Sie danach erneut mit der rechten Maustaste auf Ihr Projekt in NetBeans. Klicken Sie an dieser Stelle auf die Schaltfläche "Bereinigen und erstellen", und NetBeans beginnt, Ihre Bibliotheken und Dateien zu übernehmen und sie in eine funktionierende JAR-Datei zu kompilieren. Wenn alles gut geht, sollten Sie nach wenigen Augenblicken in der Konsole eine Meldung sehen, die Ihnen mitteilt, dass Ihr JAR die Kompilierung abgeschlossen hat und die Datei jetzt ausgeführt werden kann. Führen Sie diese App aus und stellen Sie sicher, dass alles funktioniert. Wenn nicht, debuggen und starten Sie den Prozess neu, bis die Fehler behoben wurden.

Schritt 8: Herzlichen Glückwunsch

Herzliche Glückwünsche! Wenn Sie alle Anweisungen richtig befolgt und alles gut codiert haben, sollten Sie Ihre ganz eigene, funktionierende Anwendung haben. Das Coole daran ist, dass Ihre App jetzt immer dann, wenn Sie oder jemand anderes, der Zugriff auf Ihre Tabelle hat, die Daten bearbeitet, die neuen Daten ändern und darauf reagieren kann. Hier ist ein kurzes Video, wie meins ausgegangen ist.

Wenn Sie nach Möglichkeiten suchen, sich weiter zu verbessern und zu entwickeln, empfehle ich Ihnen, einige der fortgeschritteneren Funktionen von JavaFX auszuprobieren, wie FancyText oder FancyButton, die Ihrer Anwendung einige High-End-Grafiken hinzufügen können. Viel Glück und hinterlassen Sie einen Kommentar, wenn Sie Hilfe benötigen oder einen Fehler in meinem Code bemerken!