Étapes de développement et introduction du JDBC natif

Package guide : copiez le package jar requis dans le dossier lib nouvellement créé sous le nom du projet,

Étapes de développement natif de jdbc

1. Enregistrez le pilote

2. Obtenez la connexion

3. Obtenez l'objet exécuteur

4. Obtenez l'ensemble de résultats

5. Traitement de l'ensemble de résultats

　 6. Libérer les ressources

JDBC
Java DataBase Connectivity, la connexion à la base de données Java est une API Java utilisée pour exécuter des instructions SQL.
JDBC est la spécification standard permettant à Java d'accéder aux bases de données. Il peut fournir un accès unifié à différentes bases de données relationnelles. Il se compose d'un ensemble d'interfaces et de classes écrites en langage Java.

Pilote
JDBC doit se connecter au pilote. Le pilote permet à deux appareils de communiquer et de respecter un certain format de données de communication. Le format de données est spécifié par le fournisseur d'équipement. et le fournisseur d'équipement le fournit pour l'appareil. Logiciel pilote, via lequel l'appareil peut communiquer.

Spécification JDBC (maîtrise de quatre objets cœurs)
DriverManager : utilisé pour enregistrer le pilote
Connexion : représente la connexion créée avec la base de données
Déclaration : exploite la base de données Instruction SQL Objet
ResultSet : ensemble de résultats ou une table virtuelle

Utilisez la technologie JDBC pour faire fonctionner la base de données via le pilote fourni par mysql Étapes de mise en œuvre :
1. Enregistrez le pilote
pour le dire. la JVM que nous utilisons Quel est le pilote (mysql, oracle....)
DriverManager.registerDriver(new com.mysql.jdbc.Driver()); Il n'est pas recommandé d'utiliser
pour 2 raisons :
> causes Le conducteur a été enregistré deux fois.
>Driver jar qui s'appuie fortement sur la base de données
Solution :
Class.forName("com.mysql.jdbc.Driver");
2. Obtenez la connexion à la base de données
La base de données est un serveur de programme TCP, un serveur de connexion (via une négociation à trois)
équivaut à établir un chemin de connexion du programme Java au serveur de base de données
Connexion statique getConnection (String url, String user, String password)
Essayer d'établir une connexion à l'URL de la base de données donnée.
Description du paramètre : url L'emplacement où la base de données doit être connectée (adresse Web) utilisateur nom d'utilisateur mot de passe Mot de passe
Par exemple : getConnection("jdbc:mysql://localhost:3306/day06", "root", "root");
URL : Un accord entre SUN et le fabricant de la base de données.
jdbc:mysql://localhost:3306/day06
Sous-protocole IP du protocole : base de données du numéro de port
mysql : jdbc:mysql://localhost:3306/day04 ou jdbc:mysql:/// day14 (Connexion locale par défaut)
base de données oracle : jdbc:oracle:thin:@localhost:1521:sid
3. Récupérez l'objet exécuteur
L'objet qui exécute l'instruction SQL, sa fonction est d'exécuter le Interface SQL
L'implémentation se trouve dans le pilote de base de données. Toutes les interactions avec la base de données sont basées sur des objets de connexion.
Statement createStatement(); //Créer un objet pour exécuter les instructions SQL
4. Exécuter l'instruction SQL et obtenir le jeu de résultats
Utiliser l'objet exécuteur pour exécuter l'instruction SQL
Obtenir le jeu de résultats de l'instruction SQL (ajouter, supprimer, modifier) : Entier, le nombre de lignes effectives à exécuter Requête : Ce qui est renvoyé est un ensemble de résultats)
Méthodes courantes :
 ? Exécuter l'instruction insert update delete.
? ResultSet executeQuery(String sql ); --Exécuter l'instruction select.
? , et false est renvoyé lors de l'exécution d'autres instructions.
5. Traitez l'ensemble de résultats
ResultSet est en fait une table bidimensionnelle Nous pouvons appeler sa méthode booléenne next() pour pointer vers une certaine ligne d'enregistrements. la méthode next() est appelée pour la première fois, elle pointe vers l'emplacement de la première ligne d'enregistrements. À ce stade, ResultSet peut être utilisé. Méthode getXXX(int col) fournie (différente de l'index commençant à 0, de la colonne commençant à partir de 0). 1) pour obtenir les données de la colonne spécifiée :
rs.next(); // Pointez sur la première ligne
rs.getInt (1);//Obtenez les données de la première ligne et de la première colonne
Méthodes courantes :
 ? Object getObject(int index) / Object getObject(String name) Obtenir un objet
 ? String getString(int index)/ String getString(String name) Obtenir une chaîne
 ? int index)/int getInt(String name) Obtenir un entier
? double getDouble(int index)/ double getDouble(String name) Obtenir une double précision Type à virgule flottante
6. Libérer des ressources
Comme les flux IO, tout doit être fermé après utilisation ! L'ordre de fermeture est de l'obtenir d'abord, puis de le fermer, et de l'obtenir plus tard et de le fermer en premier.
Démonstration de code d'utilisation de JDBC pour ajouter, supprimer, modifier et interroger la base de données :

  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 }

Problème d'injection SQL
Injection SQL : le contenu saisi par l'utilisateur est utilisé dans le cadre de la syntaxe de l'instruction SQL, modifiant ainsi la véritable signification du SQL d'origine.
Supposons qu'il y ait un cas de connexion et que l'instruction SQL soit la suivante :
SELECT * FROM user table WHERE NAME = nom d'utilisateur saisi par l'utilisateur AND PASSWORD = mot de passe saisi par l'utilisateur ;
À ce moment, lorsque l'utilisateur saisit le numéro de compte et le mot de passe corrects, et l'utilisateur est autorisé à se connecter une fois les informations interrogées. Mais lorsque l'utilisateur saisit le numéro de compte XXX et le mot de passe : OR 'a'='a';
À ce stade, l'instruction de requête ci-dessus peut toujours produire des résultats. Ensuite, l'utilisateur se connecte directement avec succès. Nous ne voulons évidemment pas voir un tel résultat. Il s'agit d'un problème d'injection SQL.
À cette fin, nous utilisons PreparedStatement pour résoudre le problème correspondant.

preparedStatement : objet précompilé, qui est une sous-classe de l'objet Statement.

Caractéristiques :
Hautes performances
Compilera d'abord l'instruction SQL
Peut filtrer les mots-clés saisis par l'utilisateur.

Objet de prétraitement PreparedStatement, tous les paramètres réels de chaque instruction SQL traitée doivent être remplacés par des espaces réservés ?

String sql = "select * from user which username = ? and password = ?";
Pour utiliser PreparedStatement, vous devez suivre les 3 étapes suivantes :
1. Code objet de prétraitement PreparedStatement :
. Obtenir le pré-traitement Pour traiter l'objet, vous devez fournir l'instruction SQL qui a été traitée à l'aide d'espaces réservés
PreparedStatement psmt = conn.prepareStatement(sql)
2. Définissez les paramètres réels
void setXxx(int ​​index, Xxx xx) spécifiera les paramètres Définir la valeur du type spécifié
Paramètre 1 : index Numéro de séquence du paramètre réel, à partir de 1.
Paramètre 2 : valeur réelle du paramètre xxx, xxx représente le type spécifique.
Par exemple :
setString(2, "1234") Remplacez l'espace réservé ? à la deuxième position dans l'instruction SQL par le paramètre réel "1234"
3 Exécutez l'instruction SQL :
int. executeUpdate (); --Exécuter l'instruction de suppression de mise à jour.
ResultSet executeQuery(); --Exécuter l'instruction select.
boolean perform(); --Exécuter select et renvoyer true. 🎜>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!