Exemple simple de partage sur JDBC

Avant-propos : Après avoir installé la base de données, le programme Java que nous écrivons ne peut pas utiliser directement la base de données, et JDBC (Java Database Connectivity, connexion à la base de données Java) est une API utilisée dans le langage Java pour standardiser l'accès des programmes clients à la base de données. Avec lui, nous pouvons envoyer des instructions SQL à diverses bases de données relationnelles pour réaliser des opérations telles que l'ajout, la suppression, la modification et l'interrogation de la base de données.

Travail de préparation :

1. Base de données : ici, en prenant MySQL comme exemple, créez une table Personne avec quatre champs : identifiant de clé primaire auto-incrémenté, nom, sexe et âge

 1 DROP TABLE IF EXISTS `person`; 2 CREATE TABLE `person` ( 3   `id` int(11) NOT NULL AUTO_INCREMENT, 4   `name` varchar(11) DEFAULT NULL, 5   `gender` varchar(11) DEFAULT NULL, 6   `age` int(11) DEFAULT NULL, 7   PRIMARY KEY (`id`) 8 ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8; 9 10 INSERT INTO `person` VALUES ('1', '小明', '男', '18');11 INSERT INTO `person` VALUES ('2', '小芳', '女', '19');12 INSERT INTO `person` VALUES ('3', '小刚', '男', '20');13 INSERT INTO `person` VALUES ('4', '小丽', '女', '21');

2. Package jar du pilote de base de données : Mysql-connector-java-5.1.42-bin.jar

3. Importez le package de pilotes dans Eclipse : cliquez avec le bouton droit sur le projet et cliquez sur Chemin du générateur ---- Configurer le chemin du générateur ---- Ajouter des JAR externes ---- Recherchez l'emplacement du package jar et sélectionnez Ouvrir ---- Ok, et vous pouvez commencer à faire des choses !

Le schéma est le suivant :

Tout d'abord, une démonstration complète d'un processus de fonctionnement JDBC simple.

 1 package com.jdbc.demo; 2  3 import java.sql.Connection; 4 import java.sql.DriverManager; 5 import java.sql.ResultSet; 6 import java.sql.SQLException; 7 import java.sql.Statement; 8  9 //一段完整的jdbc操作过程,后面会详细介绍，为了代码视图简洁，异常均抛出。10 public class Demo {11     12     public static void main(String[] args) throws ClassNotFoundException, SQLException {13         //第1步，注册加载驱动类14         Class.forName("com.mysql.jdbc.Driver");15         //第2步，获取数据库连接,方法中3个参数依次为：16         //url:就是你要连接的数据库的地址，不同的数据库格式会有差异17         //user:就是数据库的用户名，例如MySQL的root18         //password:数据库连接密码19         String url = "jdbc:mysql://127.0.0.1/hb?characterEncoding=utf-8";20         String user = "root";21         String password = "123123";22         Connection conn = DriverManager.getConnection(url, user, password);23         //第3步，构造语句集对象，为了简要直观，这里使用Statement,不过实际开发建议用PreparedStatement24         String sql = "select * from person";25         Statement stmt = conn.createStatement();26         //第4步，提交SQL语句，这是是查询，所以调用executeQuery方法，会返回一个集合，我们可以遍历输出其中信息；27         //如果是增删改，不同于数据库中的3种SQL语句，这里都是调用executeUpdate方法，返回的是int值28         ResultSet rs = stmt.executeQuery(sql);29         //第5步(可选)，处理结果，在这里我们输出Person表中所有人名30         while(rs.next()) {31             String name = rs.getString("name");32             System.out.println(name);33         }34         //第6步，关闭相关对象，这里为ResultSet,Statement,Connection35         //注意！关闭顺序和声明顺序相反!依次如下36         rs.close();37         stmt.close();38         conn.close();39         40     }41 42 }

Les résultats d'exécution du programme sont les suivants :

Introduction de l'API associée

java.sql.Connection :

Pour la connexion avec la base de données, veillez à ne pas importer le mauvais package, car après avoir importé le driver MySQL, il y a aussi une Connexion sous com.mysql.jdbc. Si vous importez ceci, une erreur se produira ;

La connexion est obtenue en appelant la méthode getConnection de la classe DriverManager de la couche de gestion JDBC. Les deux derniers paramètres de la méthode sont relativement simples, un nom d'utilisateur et. un mot de passe. Le premier paramètre format url est lié à chaque base de données

　

　MySQL: jdbc:mysql://<:port>/, port par défaut. 3306, si le serveur utilise le port par défaut, le port peut être omis et des connexions supplémentaires peuvent être ajoutées à l'attribut URL jdbc:mysql://:/?property1=value1&property2 =value2;

　

ORACLE:jdbc:oracle:thin:@< ;host><:port>:

java,sql.Statement et java.sql.PreparedStatement

Objets Statement, utilisés pour soumettre des instructions SQL ;

Statement est généralement utilisé pour exécuter des instructions SQL statiques, et Statement.excute(sql) peut être soumis

;

PreparedStatement peut exécuter des instructions SQL dynamiques, permettant des requêtes paramétrées, avec de meilleures performances, et peut efficacement éviter les attaques par injection SQL, les exemples suivants utilisent tous PreparedStatement

　

java.sql.ResultSet :

Spécifiez l'instruction SQL (généralement une requête) à exécuter et à renvoyer L'ensemble de résultats d'origine Dans le développement réel, nous réencapsulons généralement les résultats pour faciliter l'appel du

classe d'entité Personne

 1 package com.jdbc.entity; 2 //实体类Person，属性与数据库中字段对应 3 public class Person { 4     private Integer id; 5     private String name; 6     private String gender; 7     private Integer age; 8     public Integer getId() { 9         return id;10     }11     public void setId(Integer id) {12         this.id = id;13     }14     public String getName() {15         return name;16     }17     public void setName(String name) {18         this.name = name;19     }20     public String getGender() {21         return gender;22     }23     public void setGender(String gender) {24         this.gender = gender;25     }26     public Integer getAge() {27         return age;28     }29     public void setAge(Integer age) {30         this.age = age;31     }32     @Override33     public String toString() {34         return "Person [id=" + id + ", name=" + name + ", gender=" + gender35                 + ", age=" + age + "]";36     }37     38 }

La classe d'outils JdbcUtil est utilisée pour charger des classes de pilotes, obtenir des connexions et fermer des objets

package com.jdbc.demo;import java.sql.Connection;import java.sql.DriverManager;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;public class JdbcUtil {private static String driver = "com.mysql.jdbc.Driver";private static String url = "jdbc:mysql://127.0.0.1/hb?characterEncoding=utf-8";private static String username = "root";private static String password = "hjh123";//静态代码块中注册加载驱动类static {try {
            Class.forName(driver);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }//封装获取连接方法public static Connection getConnection() {try {return DriverManager.getConnection(url, username, password);
        } catch (SQLException e) {
            e.printStackTrace();
        }return null;
    }//封装关闭对象方法public static void close(ResultSet rs, Statement statement, Connection conn) {if (rs != null) {try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }if (statement != null) {try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }if (conn != null) {try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    
}

Encapsulation facile d'une classe DAO à ajouter à la table Person Contrôle de suppression et de modification

  1 package com.jdbc.demo;  2   3 import java.sql.Connection;  4 import java.sql.PreparedStatement;  5 import java.sql.ResultSet;  6 import java.sql.SQLException;  7 import java.util.ArrayList;  8 import java.util.List;  9  10 import com.jdbc.entity.Person; 11  12  13 //封装Person表的增删改查方法 14 public class PersonDaoImpl { 15     //这里的问号?是占位符,用于给将要传递的参数占位置，实现了动态SQL语句的执行 16     //添加一条记录的SQL语句，第一个参数由于数据表中是主键自增，这里可以用null 17     private static final String SQL_ADD = "insert into person values(null,?,?,?)"; 18     //删除，指定id的记录 19     private static final String SQL_DEL = "delete from person where id = ?"; 20     //修改，指定id的记录 21     private static final String SQL_UPD = "update person set name = ?,gender = ?,age = ? where id = ?"; 22     //查询，指定id记录 23     private static final String SQL_ID = "select * from person where id = ?"; 24     //查询，所有记录 25     private static final String SQL_ALL = "select * from person"; 26      27     //添加一条记录 28     public boolean add(Person p) { 29         Connection conn = JdbcUtil.getConnection(); 30         PreparedStatement ps = null; 31         try { 32             ps = conn.prepareStatement(SQL_ADD); 33             //把我们传入的person对象的属性值分作为占位符的值传入,数组各值顺序对应占位符字段顺序 34             Object[] params = {p.getName(),p.getGender(),p.getAge()}; 35             int len = params.length; 36             for(int i = 0;i < len;i++) { 37                 //！！！这里比较特殊，很多下标都是从0开始，例如数组， 38                 //！！！但是这个setObject方法第一个索引参数是从1开始 39                 ps.setObject(i+1, params[i]); 40             } 41             //这里的整型返回值line意指更新的记录数，或者说是数据库中受影响的记录行数 42             //之前的Statement.excute方法要传入SQL语句字符串参数， 43             //但是用了PreparedStatement就不用传参数了，因为在前面我们已经预定义处理了 44             int line = ps.executeUpdate(); 45             if (line > 0) { 46                 System.out.println("添加成功,受影响记录数为"+line); 47                 return true;//结束，但是后面finally区代码会执行 48             } 49         } catch (SQLException e) { 50             e.printStackTrace(); 51         } finally { 52             //关闭相关对象 53             JdbcUtil.close(null, ps, conn); 54         } 55         System.out.println("添加失败"); 56         return false; 57     } 58     //删除一条记录 59     public boolean delete(int id) { 60         Connection conn = JdbcUtil.getConnection(); 61         PreparedStatement ps = null; 62         try { 63             ps = conn.prepareStatement(SQL_DEL); 64             ps.setInt(1, id); 65             //这里的整型返回值line意指更新的记录数，或者说是数据库中受影响的记录行数 66             int line = ps.executeUpdate(); 67             if (line > 0) { 68                 System.out.println("删除成功,受影响记录数为"+line); 69                 return true;//结束，但是后面finally区代码会执行 70             } 71         } catch (SQLException e) { 72             e.printStackTrace(); 73         } finally { 74             //关闭相关对象 75             JdbcUtil.close(null, ps, conn); 76         } 77         System.out.println("删除失败"); 78         return false; 79     } 80     //修改一条记录 81     public boolean update(Person p) { 82         Connection conn = JdbcUtil.getConnection(); 83         PreparedStatement ps = null; 84         try { 85             ps = conn.prepareStatement(SQL_UPD); 86             //把我们传入的person对象的属性值分作为占位符的值传入 87             Object[] params = {p.getName(),p.getGender(),p.getAge(),p.getId()}; 88             int len = params.length; 89             for(int i = 0;i < len;i++) { 90                 //！！！这里比较特殊，很多下标都是从0开始，例如数组， 91                 //！！！但是这个setObject方法第一个索引参数是从1开始 92                 ps.setObject(i+1, params[i]); 93             } 94             //这里的整型返回值line意指更新的记录数，或者说是数据库中受影响的记录行数 95             int line = ps.executeUpdate(); 96             if (line > 0) { 97                 System.out.println("修改成功,受影响记录数为"+line); 98                 return true;//结束，但是后面finally区代码会执行 99             }100         } catch (SQLException e) {101             e.printStackTrace();102         } finally {103             //关闭相关对象104             JdbcUtil.close(null, ps, conn);105         }106         System.out.println("修改失败");107         return false;108     }109     //获取一条记录,这里返回的不再是布尔值，而是一个对应数据表中一条记录的Person对象110     public Person findById(int id) {111         Connection conn = JdbcUtil.getConnection();112         PreparedStatement ps = null;113         ResultSet rs = null;114         try {115             ps = conn.prepareStatement(SQL_ID);116             ps.setInt(1, id);117             //返回结果集，这里是查询指定id，所以结果集中应该最多只有一条记录118             rs = ps.executeQuery();119             if(rs.next()) {120                 Person p = new Person();121                 p.setId(id);122                 //这里的Result的getObject方法，参数为数据表中字段名，可以获取对应字段值123                 p.setName(rs.getString("name"));124                 p.setGender(rs.getString("gender"));125                 p.setAge(rs.getInt("age"));126                 return p;//返回p对象，结束127             }128         } catch (SQLException e) {129             e.printStackTrace();130         } finally {131             //关闭相关对象132             JdbcUtil.close(rs, ps, conn);133         }134         return null;135     }136     //获取所有记录，返回结果集不便操作，故封装到一个List中作为方法返回值137         public List<Person> findAll() {138             Connection conn = JdbcUtil.getConnection();139             PreparedStatement ps = null;140             ResultSet rs = null;141             List<Person> list = new ArrayList<>();142             try {143                 ps = conn.prepareStatement(SQL_ALL);144                 //返回结果集145                 rs = ps.executeQuery();146                 while(rs.next()) {147                     //创建一个Person对象148                     Person p = new Person();149                     //这里的Result的getObject方法，参数为数据表中字段名，可以获取对应字段值150                     p.setId(rs.getInt("id"));151                     p.setName(rs.getString("name"));152                     p.setGender(rs.getString("gender"));153                     p.setAge(rs.getInt("age"));154                     list.add(p);//添加至集合155                 }156                 return list;157             } catch (SQLException e) {158                 e.printStackTrace();159             } finally {160                 //关闭相关对象161                 JdbcUtil.close(rs, ps, conn);162             }163             return null;164         }165 }

Résumé

Les étapes de la base de données de fonctionnement JDBC sont résumées comme suit :

1 Enregistrez et chargez la classe du pilote

2.

3. Créer un objet d'instruction

4. Exécuter l'instruction SQL (exécuter)

5 (facultatif). (notez l'ordre : ResultSet, Statement/PreparedStatement, Connction)

Extension

Le processus ci-dessus peut essentiellement compléter le fonctionnement d'une table de données, mais il ne peut être utilisé que pour une seule donnée fixe table, utilisant des technologies telles que les génériques et la réflexion, pour extraire et encapsuler le code de la couche dao, et ajouter des instructions SQL pour implémenter des requêtes de table conjointes, rendant le programme plus polyvalent et flexible, et peut être utilisé pour n'importe quelle table de données. Dans le processus de développement actuel, certains frameworks ont encapsulé JDBC, comme hibernate et mybatis, et vous pouvez en apprendre davantage grâce aux opérations JDBC sous-jacentes.

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!