Entwicklungsschritte und Einführung von nativem JDBC

Anleitungspaket: Kopieren Sie das erforderliche JAR-Paket in den neu erstellten lib-Ordner unter dem Projektnamen,

Native Entwicklungsschritte von jdbc

1. Treiber registrieren

2. Verbindung abrufen

3. Executor-Objekt abrufen

4. Ergebnissatz abrufen

5. Ergebnissatzverarbeitung

　 6. Ressourcen freigeben

JDBC
Java DataBase Connectivity, Java-Datenbankverbindung ist eine Java-API, die zum Ausführen von SQL-Anweisungen verwendet wird.
JDBC ist die Standardspezifikation für Java für den Zugriff auf Datenbanken. Es kann einen einheitlichen Zugriff auf verschiedene relationale Datenbanken ermöglichen. Es besteht aus einer Reihe von Schnittstellen und Klassen, die in der Java-Sprache geschrieben sind.

Treiber
JDBC muss eine Verbindung zum Treiber herstellen. Der Treiber dient dazu, dass zwei Geräte kommunizieren und ein bestimmtes Kommunikationsdatenformat erfüllen. und der Geräteanbieter stellt für das Gerät eine Treibersoftware bereit, über die das Gerät kommunizieren kann.

JDBC-Spezifikation (Beherrschung von vier Kernobjekten)
DriverManager: wird zum Registrieren des Treibers verwendet
Verbindung: stellt die mit der Datenbank erstellte Verbindung dar
Anweisung: betreibt die Datenbank SQL-Anweisungsobjekt
ResultSet: Ergebnismenge oder eine virtuelle Tabelle

Verwenden Sie die JDBC-Technologie, um die Datenbank über den von MySQL bereitgestellten Treiber zu betreiben:
1. Registrieren Sie den Treiber
, um ihn mitzuteilen die JVM, die wir verwenden. Was ist der Treiber (MySQL, Oracle...)
DriverManager.registerDriver(new com.mysql.jdbc.Driver()); Es wird aus zwei Gründen nicht empfohlen,
zu verwenden:
> Ursachen Der Fahrer wurde zweimal registriert.
>Treiber-JAR, das stark auf die Datenbank angewiesen ist
Lösung:
Class.forName("com.mysql.jdbc.Driver");
2. Stellen Sie die Verbindung zur Datenbank her
Die Datenbank ist TCP-Programmserver, Verbindungsserver (über 3-Wege-Handshake)
entspricht dem Herstellen eines Verbindungspfads vom Java-Programm zum Datenbankserver
statische Verbindung getConnection(String URL, String Benutzer, String Passwort)
Es wird versucht, eine Verbindung zur angegebenen Datenbank-URL herzustellen.
Parameterbeschreibung: URL Der Ort, an dem die Datenbank verbunden werden muss (Webadresse) Benutzer Benutzername Passwort Passwort
Zum Beispiel: getConnection("jdbc:mysql://localhost:3306/day06", "root", "root");
URL: Eine Vereinbarung zwischen SUN und dem Datenbankhersteller.
jdbc:mysql://localhost:3306/day06
Protokoll-Unterprotokoll IP: Portnummerndatenbank
mysql: jdbc:mysql://localhost:3306/day04 oder jdbc:mysql:/// Tag 14 (Standardmäßige lokale Verbindung)
Oracle-Datenbank: jdbc:oracle:thin:@localhost:1521:sid
3. Holen Sie sich das Executor-Objekt
Das Objekt, das die SQL-Anweisung ausführt. Seine Funktion besteht darin, das auszuführen SQL
-Schnittstelle Die Implementierung erfolgt im Datenbanktreiber. Alle Interaktionen mit der Datenbank basieren auf Verbindungsobjekten.
Anweisung createStatement(); //Erstellen Sie ein Objekt zum Ausführen von SQL-Anweisungen
4. Führen Sie die SQL-Anweisung aus und erhalten Sie die Ergebnismenge
Verwenden Sie das Executor-Objekt, um die SQL-Anweisung auszuführen
Rufen Sie die Ergebnismenge ab der SQL-Anweisung (Hinzufügen, Löschen, Ändern): Ganzzahl, die Anzahl der effektiv auszuführenden Zeilen. Abfrage: Was zurückgegeben wird, ist eine Ergebnismenge.
Allgemeine Methoden:
? Führe die Anweisung „Insert Update“ aus.
? ResultSetexecuteQuery(Stringsql); --Führe die SELECT-Anweisung aus.
? , und false wird zurückgegeben, wenn andere Anweisungen ausgeführt werden.
5. Verarbeiten Sie die Ergebnismenge
ResultSet ist eigentlich eine zweidimensionale Tabelle. Wir können ihre boolesche next()-Methode aufrufen, um auf eine bestimmte Zeile von Datensätzen zu verweisen Wenn die Methode next() zum ersten Mal aufgerufen wird, zeigt sie auf die Position der ersten Datensatzzeile. Zu diesem Zeitpunkt kann ResultSet verwendet werden. Vorausgesetzt, die Methode getXXX(int col) beginnt bei 0 und beginnt bei der Spalte 1) um die Daten der angegebenen Spalte abzurufen:
rs.next(); // Zeigen Sie auf die erste Zeile
rs.getInt (1);//Erhalten Sie die Daten in der ersten Zeile und Spalte
Gängige Methoden:
? Object getObject(int index) / Object getObject(String name) Holen Sie sich ein beliebiges Objekt
? int index)/int getInt(String name) Ganzzahl
abrufen? double getDouble(int index)/ double getDouble(String name) Gleitkommatyp mit doppelter Genauigkeit abrufen
6. Ressourcen freigeben
Wie IO-Streams alles Muss nach Gebrauch verschlossen werden! Die Reihenfolge beim Schließen besteht darin, es zuerst abzurufen und dann zu schließen, und es später abzurufen und zuerst zu schließen.
Codedemonstration der Verwendung von JDBC zum Hinzufügen, Löschen, Ändern und Abfragen der Datenbank:

  1 public static void main(String[] args) throws Exception {  2         //1.注册驱动  3         Class.forName("com.mysql.jdbc.Driver");  4         //2.获取数据库连接  5         String url = "jdbc:mysql://localhost:3306/mybase4";  6         String user = "root";  7         String password = "root"; 
  8         Connection conn = DriverManager.getConnection(url, user, password);  9         //3.获取执行者对象 10         Statement stat = conn.createStatement(); 11         //调用更新数据的方法 12         //update(stat); 13         //调用删除数据的方法 14         //delete(stat); 15         //调用增加数据的方法 16         //insert(stat); 17         //调用查询数据的方法 18         select(stat); 19         //6.释放资源 20         stat.close(); 21         conn.close(); 22     } 23  24     /* 25      * 使用JDBC技术,查询数据库中表的数据 26      */ 27     private static void select(Statement stat) throws Exception { 28         //拼接sql语句 29         String sql = "SELECT * FROM category"; 30         /* 31          * 4.执行sql语句 32          * 使用Statement中的方法 33          * ResultSet executeQuery(String sql) 执行给定的 SQL 语句，该语句返回单个 ResultSet 对象。 
 34          * 返回值ResultSet标准接口的实现类对象,实现类对象由mysql驱动提供,可以使用ResultSet接口接收 35          */ 36         ResultSet rs = stat.executeQuery(sql); 37         System.out.println(rs);//com.mysql.jdbc.JDBC4ResultSet@1acb189 38         /* 39          * 5.处理结果 40          * ResultSet中有一个方法 41          * boolean next() 将光标从当前位置向前移一行。 42          * 如果新的当前行有效，则返回 true；如果不存在下一行，则返回 false 
 43          * 如果有结果集返回true,若果没有结果集返回false 44          * 相当于迭代器中的hasNext方法 45          */ 46         while(rs.next()){ 47             /* 48              * next返回true,有结果集 49              * 取出结果集 50              * 使用ResultSet中的方法getXXX(参数); 51              * 参数: 52              *     int columnIndex:列所在的索引,从1开始 53              *     String columnLabel:列名 54              * 注意: 55              *     如果使用getInt,getDouble指定数据类型的方法,返回值就是对应的数据类型 56              *     如果使用getObject方法返回值是object类型(只是打印可用) 57              * 如果使用getString方法返回值是String类型 58              */ 59             /*int i1 = rs.getInt(1); 60             String s2 = rs.getString(2); 61             System.out.println(i1+"\t"+s2);*/ 62              63             //System.out.println(rs.getObject(1)+"\t"+rs.getObject(2)); 64             System.out.println(rs.getObject("cid")+"\t"+rs.getObject("cname")); 65             //5.释放资源 66             rs.close(); 67         } 68     } 69  70     /* 71      * 使用JDBC技术,对数据库中的表数据进行增加 72      */ 73     private static void insert(Statement stat) throws SQLException { 74         //拼接sql语句 75         String sql = "INSERT INTO category(cname) VALUES('玩具')"; 76         //4.执行sql语句 77         int row = stat.executeUpdate(sql); 78         //5.处理结果 79         if(row>0){ 80             System.out.println("增加数据成功!"); 81         }else{ 82             System.out.println("增加数据失败!"); 83         } 84          85     } 86  87     /* 88      * 使用JDBC技术,对数据库中的表数据进行删除 89      */ 90     private static void delete(Statement stat) throws Exception { 91         //拼接sql语句 92         String sql = "DELETE FROM category WHERE cid=5"; 93         //4.执行sql语句 94         int row = stat.executeUpdate(sql); 95         //5.处理结果 96         if(row>0){ 97             System.out.println("删除数据成功!"); 98         }else{ 99             System.out.println("删除数据失败!");100         }101     }102 103     /*104      * 使用JDBC技术,对数据库中的表数据进行更新105      */106     private static void update(Statement stat) throws Exception {107         //拼接sql语句108         String sql = "UPDATE category SET cname='鞋帽' WHERE cid=6";109         //4.执行sql语句110         int row = stat.executeUpdate(sql);111         //5.处理结果112         if(row>0){113             System.out.println("更新数据成功!");114         }else{115             System.out.println("更新数据失败!");116         }117     }

 1 JDBC工具类 2 “获得数据库连接”操作，将在以后的增删改查所有功能中都存在，可以封装工具类JDBCUtils。提供获取连接对象的方法，从而达到代码的重复利用。 3 代码演示: 4 public class JDBCUtils { 5      6     //私有构造方法,防止外界创建对象调用方法 7     private JDBCUtils() { 8     } 9     10     //定义Connectionn变量11     private static Connection conn;12     13     //保证代码只执行一次,可以放入静态代码块中14     static{15         try {16             //注册驱动17             Class.forName("com.mysql.jdbc.Driver");18             //获取连接19             String url="jdbc:mysql://127.0.0.1:3306/mybase4";20             String user="root";21             String password = "root";22             conn = DriverManager.getConnection(url, user, password);23         } catch (Exception e) {24             //注意,如果连接数据库失败,停止程序25             throw new RuntimeException(e+"连接数据库失败");26         }27     }28     29     //创建一个静态方法,获取数据库连接对象,并返回30     public static Connection getConnection(){31         return conn;32     }33     34     /*35      * 创建一个静态方法,对资源进行释放36      * ResultSet rs37      * Statement stat38      * Connection conn39      */40     public static void close(ResultSet rs,Statement stat,Connection conn){41         try {42             if(rs!=null){43                 rs.close();44             }45         } catch (SQLException e) {46             e.printStackTrace();47         }48         try {49             if(stat!=null){50                 stat.close();51             }52         } catch (SQLException e) {53             e.printStackTrace();54         }55         try {56             if(conn!=null){57                 conn.close();58             }59         } catch (SQLException e) {60             e.printStackTrace();61         }62     }63 }

SQL-Injection-Problem
SQL-Injection: Der vom Benutzer eingegebene Inhalt wird als Teil der SQL-Anweisungssyntax verwendet und verändert die wahre Bedeutung des ursprünglichen SQL.
Angenommen, es liegt ein Anmeldefall vor und die SQL-Anweisung lautet wie folgt:
SELECT * FROM user table WHERE NAME = vom Benutzer eingegebener Benutzername AND PASSWORD = vom Benutzer eingegebenes Passwort;
Zu diesem Zeitpunkt, wann Der Benutzer gibt die richtige Kontonummer und das richtige Passwort ein und kann sich anmelden, nachdem die Informationen abgefragt wurden. Wenn der Benutzer jedoch die Kontonummer XXX und das Passwort eingibt: ODER 'a'='a';
Zu diesem Zeitpunkt kann die obige Abfrageanweisung immer Ergebnisse liefern. Dann meldet sich der Benutzer direkt erfolgreich an. Dies ist ein SQL-Injection-Problem.
Zu diesem Zweck verwenden wir PreparedStatement, um das entsprechende Problem zu lösen.

preparedStatement: Vorkompiliertes Objekt, das eine Unterklasse des Statement-Objekts ist.

Eigenschaften:
Hohe Leistung
Kompiliert zuerst die SQL-Anweisung
Kann die vom Benutzer eingegebenen Schlüsselwörter herausfiltern.

PreparedStatement-Vorverarbeitungsobjekt, müssen alle tatsächlichen Parameter in jeder verarbeiteten SQL-Anweisung durch Platzhalter ersetzt werden?

String sql = "select * from user where username = ? and password = ?";
Um PreparedStatement zu verwenden, müssen Sie die folgenden 3 Schritte ausführen:
1. PreparedStatement-Vorverarbeitungsobjektcode:
Vorverarbeitung abrufen Um das Objekt zu verarbeiten, müssen Sie die SQL-Anweisung bereitstellen, die mithilfe von Platzhaltern verarbeitet wurde
PreparedStatement psmt = conn.prepareStatement(sql)
2. Stellen Sie die tatsächlichen Parameter ein
void setXxx(int ​​index,
Parameter 2: xxx tatsächlicher Parameterwert, xxx repräsentiert den spezifischen Typ.
Zum Beispiel:
setString(2, „1234“) Ersetzen Sie den Platzhalter ? an der zweiten Position in der SQL-Anweisung durch den tatsächlichen Parameter „1234“
3. Führen Sie die SQL-Anweisung aus:
int executeUpdate(); --Führen Sie die Anweisung zum Einfügen von Updates aus.
ResultSetexecute(); 🎜>

Das obige ist der detaillierte Inhalt vonEntwicklungsschritte und Einführung von nativem JDBC. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!