Hoe gegevens naar PostgreSQL in Java te behouden

  • Noah Scott
  • 0
  • 2943
  • 522
>

Java is tegenwoordig misschien wel de meest gebruikte programmeertaal. Door zijn robuustheid en platformonafhankelijke aard kunnen op Java gebaseerde applicaties op vrijwel alles worden uitgevoerd. Zoals bij elke toepassing het geval is, moeten we onze gegevens op een of andere betrouwbare manier opslaan - deze behoefte heet databases tot leven.

In Java worden databaseverbindingen geïmplementeerd door JDBC (Java Database Connectivity API), waardoor de programmeur verschillende soorten databases op bijna dezelfde manier kan behandelen, wat ons leven veel gemakkelijker maakt wanneer we gegevens uit een database moeten opslaan of lezen.

In deze zelfstudie maken we een voorbeeld van een Java-applicatie die verbinding kan maken met een PostgreSQL-database-instantie en er gegevens in kan schrijven. Om te controleren of onze gegevensinvoer is gelukt, zullen we ook het teruglezen implementeren en de tabel afdrukken waarin we gegevens hebben ingevoegd.

In deze tutorial leer je:
  • Hoe de database voor de applicatie moet worden opgezet
  • Hoe PostgreSQL JDBC-stuurprogramma in uw project te importeren
  • Hoe u gegevens in de database invoegt
  • Hoe u een eenvoudige query uitvoert om de inhoud van een databasetabel te lezen
  • Opgehaalde gegevens afdrukken
Resultaten van het uitvoeren van de applicatie.

Gebruikte softwarevereisten en -conventies

Softwarevereisten en Linux Command Line-conventies
Categorie Vereisten, conventies of gebruikte softwareversie
Systeem Ubuntu 20.04
Software NetBeans IDE 8.2, PostgreSQL 10.12, jdk 1.8
Andere Bevoorrechte toegang tot uw Linux-systeem als root of via het sudo opdracht.
Conventies # - vereist dat gegeven linux-commando's worden uitgevoerd met root-privileges, hetzij direct als rootgebruiker, hetzij door gebruik van sudo opdracht
$ - vereist dat gegeven linux-commando's worden uitgevoerd als een gewone niet-geprivilegieerde gebruiker

De opzet

Voor deze tutorial hebben we slechts één werkstation (desktop of laptop) nodig om alle benodigde componenten te installeren. We behandelen niet de installatie van JDK, de Netbeans IDE of de installatie van PostgreSQL-database op de laboratoriummachine. We gaan ervan uit dat de database voorbeeldb is actief en we kunnen verbinding maken, lezen en schrijven met behulp van wachtwoordverificatie, met de volgende inloggegevens:

Gebruikersnaam:voorbeeldgebruiker
Wachtwoord:VoorbeeldPass

Dit is een voorbeeldconfiguratie, gebruik sterke wachtwoorden in een real-world scenario! De database is ingesteld om te luisteren op localhost, wat nodig is wanneer we de JDBC construeren verbindings-URL.

Het belangrijkste doel van onze applicatie is om te laten zien hoe we naar de database kunnen schrijven en lezen, dus voor de waardevolle informatie die we zo graag willen behouden, kiezen we gewoon een willekeurig getal tussen 1 en 1000, en slaan we die informatie op met een unieke ID van de berekening en het exacte tijdstip waarop de gegevens in de database zijn opgenomen.

De ID en het tijdstip van opname worden verstrekt door de database, waardoor onze applicatie alleen aan het echte probleem kan werken (in dit geval een willekeurig nummer). Dit is met opzet gedaan en aan het einde van deze tutorial bespreken we de mogelijkheden van deze architectuur.

Opzetten van de database voor de applicatie

We hebben een actieve databaseservice en een database met de naam voorbeeldb we hebben rechten om aan te werken met de bovengenoemde inloggegevens. Om een ​​plaats te hebben waar we onze kostbare (willekeurige) gegevens kunnen opslaan, moeten we een tabel maken, en ook een reeks die op een gemakkelijke manier unieke identificatiegegevens biedt. Beschouw het volgende SQL-script:

maak reeks resultid_seq start met 0 increment met 1 no maxvalue minvalue 0 cache 1; verander reeks resultid_seq eigenaar in voorbeeldgebruiker; maak een tabel calc_results (residu numerieke primaire sleutel standaard nextval ('resultid_seq' :: regclass), result_of_calculation numeriek niet null, record_date tijdstempel standaard nu ()); verander table calc_results owner in exampleuser; 

Deze instructies zouden voor zich moeten spreken. We maken een reeks, stellen de eigenaar in op voorbeeldgebruiker, maak een tafel met de naam calc_resultaten (staat voor "rekenresultaten"), set resid automatisch worden gevuld met de volgende waarde van onze reeks bij elke invoeging, en definiëren result_of_calculation en record_date kolommen waarin onze gegevens worden opgeslagen. Ten slotte is de eigenaar van de tafel ook ingesteld op voorbeeldgebruiker.

Om deze database-objecten te maken, schakelen we over naar postgres gebruiker:

$ sudo su - postgres

En voer het script uit (opgeslagen in een tekstbestand met de naam table_for_java.sql) tegen de voorbeeldb database:

$ psql -d voorbeeldb < table_for_java.sql CREATE SEQUENCE ALTER SEQUENCE CREATE TABLE ALTER TABLE

Hiermee is onze database klaar.

PostgreSQL JDBC-stuurprogramma in het project importeren



Om de applicatie te bouwen, gebruiken we NetBeans IDE 8.2. De eerste paar stappen zijn handwerk. We kiezen het bestandsmenu, maken een nieuw project. We laten de standaardinstellingen achter op de volgende pagina van de wizard, met Categorie "Java" en Project op "Java-applicatie". We zullen volgende drukken. We geven de applicatie een naam (en definiëren optioneel een niet-standaard locatie). In ons geval wordt het gebeld persistToPostgres. Hierdoor zal de IDE een basis Java-project voor ons maken.

In het Projectenpaneel klikken we met de rechtermuisknop op "Bibliotheken" en selecteren we "Bibliotheek toevoegen…". Er verschijnt een nieuw venster, waar we zoeken en PostgreSQL JDBC-stuurprogramma selecteren en het als een bibliotheek toevoegen.

Het PostgreSQL JDBC-stuurprogramma aan het project toevoegen.

Inzicht in de broncode

We voegen nu de volgende broncode toe aan de hoofdklasse van onze applicatie, PersistToPostgres:

pakket persisttopostgres; importeer java.sql.Connection; importeer java.sql.DriverManager; importeer java.sql.ResultSet; importeer java.sql.SQLException; importeer java.sql.Statement; importeer java.util.concurrent.ThreadLocalRandom; openbare klasse PersistToPostgres openbare statische leegte hoofd (String [] args) int resultaat = ThreadLocalRandom.current (). nextInt (1, 1000 + 1); System.out.println ("Resultaat van de moeilijk op te lossen berekening is:" + resultaat); System.out.println ("----- PostgreSQL JDBC-verbindingstest ------"); probeer Class.forName ("org.postgresql.Driver");  catch (ClassNotFoundException cnfe) System.out.println ("Geen PostgreSQL JDBC-stuurprogramma in bibliotheekpad!"); cnfe.printStackTrace (); terugkeren;  System.out.println ("PostgreSQL JDBC-stuurprogramma geregistreerd!"); Verbinding conn = null; probeer conn = DriverManager.getConnection ("jdbc: postgresql: // localhost: 5432 / exampledb", "exampleuser", "ExamplePass");  catch (SQLException sqle) System.out.println ("Verbinding mislukt! Controleer uitvoerconsole"); sqle.printStackTrace (); terugkeren;  if (conn! = null) System.out.println ("Database verbinding tot stand gebracht"); // bouwvraag proberen Statement st = conn.createStatement (); st.executeUpdate ("Invoegen in calc_results (result_of_calculation) waarden (" + resultaat + ")"); ResultSet rs = st.executeQuery ("selecteer resid, result_van_calculation, record_date from calc_results"); System.out.println ("Resultaten opgenomen in voorbeeldb volgt: \ n ----------------------- \ n"); while (rs.next ()) System.out.println (rs.getString ("resid") + "\ t" + rs.getString ("result_of_calculation") + "\ t" + rs.getString ("record_date" ));  // clean bij exit st.close (); conn.close ();  catch (SQLException sqle2) System.out.println ("Fout bij zoekopdracht"); sqle2.printStackTrace ();  else System.out.println ("Kan geen verbinding maken!");  


  • Op regel 12 berekenen we een willekeurig getal en slaan het op in de resultaat variabele. Dit getal vertegenwoordigt het resultaat van een zware berekening die we in de database moeten opslaan.
  • Bij regel 15 proberen we de PostgreSQL JDBC Driver te registreren. Dit zal resulteren in een foutmelding als de toepassing de driver niet kan vinden tijdens runtime.
  • Op regel 26 bouwen we de JDBC-verbindingsreeks met behulp van de hostnaam waarop de database draait (localhost), de poort waarop de database luistert (5432, de standaardpoort voor PostgreSQL), de databasenaam (voorbeeldb) en de referenties vermeld op de begin.
  • Op regel 37 voeren we de invoegen in SQL-instructie die de waarde van de resultaat variabele in de result_of_calculation kolom van de calc_resultaten tafel. We specificeren alleen de waarde van deze enkele kolom, dus de standaardinstellingen zijn van toepassing: resid wordt opgehaald uit de reeks die we hebben ingesteld, en record_date standaard ingesteld op nu(), dat is de databasetijd op het moment van de transactie.
  • Op regel 38 construeren we een query die alle gegevens in de tabel retourneert, inclusief onze insert in de vorige stap.
  • Vanaf regel 39 presenteren we de gegevens die zijn opgehaald door deze op een tabelachtige manier af te drukken, bronnen vrij te maken en af ​​te sluiten.

De applicatie uitvoeren

We kunnen nu het persistToPostgres applicatie, vanaf de IDE zelf, of vanaf de opdrachtregel. Om vanuit de IDE te draaien, kunnen we de "Run Project" knop bovenaan gebruiken. Om het vanaf de opdrachtregel uit te voeren, moeten we naar het dist directory van het project en roep de JVM op met de POT pakket als argument:

$ java -jar persistToPostgres.jar Het resultaat van de moeilijk op te lossen berekening is: 173 ----- PostgreSQL JDBC-verbindingstest ------ Databaseverbinding tot stand gebracht Resultaten opgenomen in voorbeeldb volgen: ------- ---------------- 0145 31-05-2020 17:40: 30.974246

Opdrachtregeluitvoeringen leveren dezelfde uitvoer op als de IDE-console, maar wat hier belangrijker is, is dat bij elke uitvoering (of het nu vanaf de IDE of de opdrachtregel is) een nieuwe rij in onze databasetabel wordt ingevoegd met het gegeven willekeurige getal dat bij elke rennen.

Dit is de reden waarom we ook een groeiend aantal records in de uitvoer van de applicatie zullen zien: elke run groeit de tabel met één rij. Na een paar runs zien we een lange lijst met resultaatrijen in de tabel.

Database-output toont de resultaten van elke uitvoering van de applicatie.

Gevolgtrekking

Hoewel deze eenvoudige applicatie nauwelijks in de echte wereld wordt gebruikt, is het perfect om enkele echt belangrijke aspecten te demonstreren. In deze tutorial zeiden we dat we een belangrijke berekening uitvoeren met de applicatie, en elke keer een willekeurig getal invoegen, omdat het doel van deze tutorial is om te laten zien hoe de gegevens kunnen worden bewaard. Dit doel hebben we bereikt: bij elke run wordt de applicatie afgesloten en gaan de resultaten van de interne berekeningen verloren, maar de database bewaart de gegevens.

We hebben de applicatie vanaf een enkel werkstation uitgevoerd, maar als we echt een ingewikkelde berekening zouden moeten oplossen, zouden we alleen de URL van de databaseverbinding hoeven te wijzigen om te verwijzen naar een externe machine waarop de database draait, en zouden we de berekening op meerdere computers kunnen starten tegelijkertijd honderden of duizenden exemplaren van deze toepassing maken, misschien kleine stukjes van een grotere puzzel oplossen en de resultaten op een persistente manier opslaan, waardoor we onze rekenkracht kunnen opschalen met een paar regels code en een beetje planning.

.




Niemand heeft nog op dit artikel gereageerd.

Een verzameling nuttige informatie over het Linux-besturingssysteem en nieuwe technologieën
Nieuwe artikelen, praktische tips, gedetailleerde recensies en handleidingen. Voel je thuis in de wereld van het Linux-besturingssysteem