In Vorheriger Artikel konnte ich mit JDBC von Java aus auf die SQLite-Datenbank zugreifen. Da ich im Voraus eine Datenbank vorbereiten und eine SELECT-Anweisung in ein Java-Programm schreiben musste, um Daten aus der Datenbank abzurufen, ging ich noch einen Schritt weiter und integrierte zusätzlich zur SELECT-Anweisung eine INSERT-Anweisung, eine UPDATE-Anweisung, eine DELETE-Anweisung usw. Ich habe versucht herauszufordern.
Die Entwicklungsumgebung ist diesmal wie folgt.
Da ich dieses Mal mehrere SQL-Anweisungen verwenden wollte, werde ich daraus eine Methode machen, die auf dem Beispielcode in der README-Datei des JDBC-Repositorys basiert.
Beispielcode für Referenzquelle
import java.sql.*;
public class Sample
{
public static void main(String[] args) throws ClassNotFoundException
{
// load the sqlite-JDBC driver using the current class loader
Class.forName("org.sqlite.JDBC");
Connection connection = null;
try
{
// create a database connection
connection = DriverManager.getConnection("jdbc:sqlite:sample.db");
Statement statement = connection.createStatement();
statement.setQueryTimeout(30); // set timeout to 30 sec.
statement.executeUpdate("drop table if exists person");
statement.executeUpdate("create table person (id integer, name string)");
statement.executeUpdate("insert into person values(1, 'leo')");
statement.executeUpdate("insert into person values(2, 'yui')");
ResultSet rs = statement.executeQuery("select * from person");
while(rs.next())
{
// read the result set
System.out.println("name = " + rs.getString("name"));
System.out.println("id = " + rs.getInt("id"));
}
}
catch(SQLException e)
{
// if the error message is "out of memory",
// it probably means no database file is found
System.err.println(e.getMessage());
}
finally
{
try
{
if(connection != null)
connection.close();
}
catch(SQLException e)
{
// connection close failed.
System.err.println(e);
}
}
}
}
Der obige Beispielcode greift auf die Datenbank zu → löscht die Tabelle → erstellt die Tabelle → gibt die Daten ein → liest alle Daten in der Hauptmethode. In einem tatsächlichen Programm wird jede Operation separat ausgeführt, daher halte ich es für realistischer, sie zu Methoden zu machen und sie bei Bedarf zur Hauptmethode aufzurufen.
Der Code, den ich zu einer Methode gemacht habe, lautet wie folgt. Die Namen in der Datenbank wurden entsprechend geändert, um das Verständnis zu erleichtern.
Methodisierter Code
import java.sql.*;
/**
* TestDataBaseAccess
*/
public class TestDataBaseAccess {
static Connection connection;
static String URL = "jdbc:sqlite:sample.db";
public static void main(String[] args) throws ClassNotFoundException {
// load the sqlite-JDBC driver using the current class loader
Class.forName("org.sqlite.JDBC");
connection = null;
dropTable();
createTable();
insertData();
loadData();
updateData();
loadData();
deleteData();
loadData();
}
/**
*SELECT-Anweisung
*/
public static void loadData() {
try {
// create a database connection
connection = DriverManager.getConnection(URL);
Statement statement = connection.createStatement();
statement.setQueryTimeout(30); // set timeout to 30 sec.
ResultSet rs = statement.executeQuery("SELECT * FROM person");
while(rs.next()){
// read the result set
System.out.println("id = " + rs.getInt("id") + " | name = " + rs.getString("name"));
}
} catch(SQLException e) {
// if the error message is "out of memory",
// it probably means no database file is found
System.err.println(e.getMessage());
} finally {
try {
if(connection != null)
connection.close();
} catch(SQLException e) {
// connection close failed.
System.err.println(e);
}
}
}
/**
*INSERT-Anweisung
*/
public static void insertData() {
try {
// create a database connection
connection = DriverManager.getConnection(URL);
Statement statement = connection.createStatement();
statement.setQueryTimeout(30); // set timeout to 30 sec.
statement.executeUpdate("INSERT INTO person VALUES(1, 'Satou')");
statement.executeUpdate("INSERT INTO person VALUES(2, 'Tanaka')");
statement.executeUpdate("INSERT INTO person VALUES(3, 'Suzuki')");
} catch(SQLException e) {
// if the error message is "out of memory",
// it probably means no database file is found
System.err.println(e.getMessage());
} finally {
try {
if(connection != null)
connection.close();
} catch(SQLException e) {
// connection close failed.
System.err.println(e);
}
}
}
/**
*UPDATE-Anweisung
*/
public static void updateData() {
try {
// create a database connection
connection = DriverManager.getConnection(URL);
Statement statement = connection.createStatement();
statement.setQueryTimeout(30); // set timeout to 30 sec.
statement.executeUpdate("UPDATE person SET name = 'Takahashi' WHERE id = 1");
} catch(SQLException e) {
// if the error message is "out of memory",
// it probably means no database file is found
System.err.println(e.getMessage());
} finally {
try {
if(connection != null)
connection.close();
} catch(SQLException e) {
// connection close failed.
System.err.println(e);
}
}
}
/**
*DELETE-Anweisung
*/
public static void deleteData() {
try {
// create a database connection
connection = DriverManager.getConnection(URL);
Statement statement = connection.createStatement();
statement.setQueryTimeout(30); // set timeout to 30 sec.
statement.executeUpdate("DELETE FROM person WHERE id = 3");
} catch(SQLException e) {
// if the error message is "out of memory",
// it probably means no database file is found
System.err.println(e.getMessage());
} finally {
try {
if(connection != null)
connection.close();
} catch(SQLException e) {
// connection close failed.
System.err.println(e);
}
}
}
/**
*Tabelle erstellen
*/
public static void createTable() {
try {
// create a database connection
connection = DriverManager.getConnection(URL);
Statement statement = connection.createStatement();
statement.setQueryTimeout(30); // set timeout to 30 sec.
statement.executeUpdate("CREATE TABLE person (id INTEGER, name STRING)");
} catch(SQLException e) {
// if the error message is "out of memory",
// it probably means no database file is found
System.err.println(e.getMessage());
} finally {
try {
if(connection != null)
connection.close();
} catch(SQLException e) {
// connection close failed.
System.err.println(e);
}
}
}
/**
*Tabelle löschen
*/
public static void dropTable() {
try {
// create a database connection
connection = DriverManager.getConnection(URL);
Statement statement = connection.createStatement();
statement.setQueryTimeout(30); // set timeout to 30 sec.
statement.executeUpdate("DROP TABLE IF EXISTS person");
} catch(SQLException e) {
// if the error message is "out of memory",
// it probably means no database file is found
System.err.println(e.getMessage());
} finally {
try {
if(connection != null)
connection.close();
} catch(SQLException e) {
// connection close failed.
System.err.println(e);
}
}
}
}
Nachdem ich es zu einer Methode gemacht hatte, rief ich den Prozessablauf zur Hauptmethode auf.
Ausführungsergebnis
id = 1 | name = Satou
id = 2 | name = Tanaka
id = 3 | name = Suzuki
id = 1 | name = Takahashi
id = 2 | name = Tanaka
id = 3 | name = Suzuki
id = 1 | name = Takahashi
id = 2 | name = Tanaka
Ich habe es geschafft, jede SQL-Anweisung in eine Methode umzuwandeln und sie nach Bedarf als Hauptmethode aufzurufen. Beim Umgang mit SQL schien ein Fehler aufzutreten, wenn Sie nicht jede Methode abfangen wollten. Da jedoch die Dateneingabeinhalte und -änderungen in der Methode definiert sind, ist die Wiederverwendbarkeit derzeit gering und immer noch unvollständig. Basierend auf diesem Code werde ich daraus einen wiederverwendbaren Code machen.
Recommended Posts