In Vorheriger Artikel werden die SQL INSERT-Anweisung, die UPDATE-Anweisung, die DELETE-Anweisung und die SELECT-Anweisung nach Methoden getrennt, und die SQL-Anweisung wird von der Hauptmethode ausgeführt. Das ist mir gelungen. Dies war nicht praktikabel, da die Daten, die ich hinzufügen, ändern oder löschen wollte, in der SQL-Anweisung behoben wurden.
Daher dachte ich, wenn ich die Daten, die ich beim Aufrufen jeder Methode der SQL-Anweisung von der Hauptmethode hinzufügen möchte, übergeben könnte, wäre dies ein nützlicherer Quellcode, also habe ich es versucht.
Die Umgebung ist diesmal wie folgt.
Schauen wir uns zunächst die Methode der INSERT-Anweisung im vorherigen Code an.
Methode der vorherigen INSERT-Anweisung
/**
*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);
}
}
}
--Verwenden Sie PreparedStatement anstelle vonStatement
Sie können Platzhalter verwenden, um beliebige Zeichenfolgen an SQL-Anweisungen zu übergeben. Wenn Platzhalter verwendet werden, müssen SQL-Anweisungen im Voraus definiert werden, sodass Daten jetzt wie folgt mit "PreparedStatement" anstelle von "Statement" übergeben werden können.
Code mit Anweisung
// ...
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')");
// ...
Code mit PreparedStatement
// ...
String sql = "INSERT INTO person (name) VALUES(?)";
try {
PreparedStatement ps = null;
ps = connection.prepareStatement(sql);
ps.setString(1, "Satou");
ps.executeUpdate();
connection.commit();
ps.close();
} catch (SQLException e){
// ...
Hinweis) Zu diesem Zeitpunkt wird der ID "PRIMARY KEY AUTO INCREMENT" hinzugefügt, um den Quellcode so einfach wie möglich zu verstehen.
Um die Daten von der Hauptmethode zu übergeben, kann der Datenteil der SQL-Anweisung durch die Operation von der Hauptmethode willkürlich festgelegt werden, indem der Datenteil von ps.setString (1," Satou "); als Argument übergeben wird. Ich konnte es ändern.
Der Quellcode und das Ausführungsergebnis werden unten beschrieben.
Dieses Ziel
import java.sql.*;
/**
* TestDataBaseAccess
*/
public class TestDataBaseAccess {
static Connection connection;
static PreparedStatement ps;
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;
ps = null;
dropTable();
createTable();
insertData("Satou");
insertData("Tanaka");
insertData("Suzuki");
loadData();
System.out.println("---------");
updateData(1, "Takahashi");
loadData();
System.out.println("---------");
deleteData(3);
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(String name) {
String sql = "INSERT INTO person (name) VALUES(?)";
try {
connection = DriverManager.getConnection(URL);
connection.setAutoCommit(false);
ps = connection.prepareStatement(sql);
ps.setString(1, name);
ps.executeUpdate();
connection.commit();
ps.close();
} 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(int id, String name) {
try {
String sql = "UPDATE person SET name = ? WHERE id = ?";
// create a database connection
connection = DriverManager.getConnection(URL);
connection.setAutoCommit(false);
ps = connection.prepareStatement(sql);
ps.setString(1, name);
ps.setInt(2, id);
ps.executeUpdate();
connection.commit();
ps.close();
} 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(int id) {
try {
String sql = "DELETE FROM person WHERE id = ?";
// create a database connection
connection = DriverManager.getConnection(URL);
connection.setAutoCommit(false);
ps = connection.prepareStatement(sql);
ps.setInt(1, id);
ps.executeUpdate();
connection.commit();
ps.close();
} 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 PRIMARY KEY AUTOINCREMENT, 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);
}
}
}
}
javac TestDataBaseAccess.java && java -cp .:sqlite-jdbc-3.30.1.jar TestDataBaseAccess
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 denke, diese Änderung hat uns dem Code näher gebracht, der wiederverwendbarer ist. In Zukunft möchte ich es tatsächlich in Software verwenden und es zu einem besseren Quellcode machen.
[Datenbank] SQLite3 / JDBC-Zusammenfassung
Recommended Posts