Explication détaillée de ce qu'est JDBC ? Comment JDBC est-il utilisé ?

Cet article vous apporte une explication détaillée de ce qu'est JDBC ? Comment JDBC est-il utilisé ? . Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

Qu'est-ce que JDBC

JDBC (Java Database Connectivity), c'est-à-dire Java Database Connection, est une API Java utilisée pour exécuter des instructions SQL , qui peut fournir le même accès à plusieurs bases de données relationnelles. Il se compose d'un ensemble de classes et d'interfaces écrites en langage Java. JDBC fournit une base de référence sur laquelle des outils et des interfaces plus avancés peuvent être construits, permettant aux développeurs de bases de données d'écrire des applications de base de données. Au total, JDBC fait trois choses :

1. Établir une connexion avec la base de données

2. Envoyer le relevé pour faire fonctionner la base de données

3. Résultat du traitement

Exemple simple JDBC

Le code ci-dessous montre comment exploiter les requêtes JDBC sur plusieurs éléments de données qui répondent aux exigences de la base de données, et la base de données utilisée est MySql.

1. Créer une base de données et une table. Mon habitude est de créer un fichier .sql sous CLASSPATH pour stocker les instructions SQL

create database school;

use school;

create table student
(
    studentId            int                 primary key    auto_increment    not null,
    studentName        varchar(10)                                                            not null,
    studentAge        int,
    studentPhone    varchar(15)
)

insert into student values(null,'Betty', '20', '00000000');
insert into student values(null,'Jerry', '18', '11111111');
insert into student values(null,'Betty', '21', '22222222');
insert into student values(null,'Steve', '27', '33333333');
insert into student values(null,'James', '22', '44444444');
commit;

2. Créer un fichier .properties Utilisé pour stocker plusieurs. propriétés des connexions MySQL. Pourquoi devrions-nous créer .properties au lieu de le coder en dur dans le code ? Puisqu'il ne s'agit pas d'une classification des modèles de conception Java, nous n'entrerons pas dans les détails : Du point de vue de la conception, écrivez le. contenu dans la configuration Il est toujours préférable d'avoir du contenu dans un fichier plutôt que du contenu codé en dur .

mysqlpackage=com.mysql.jdbc.Driver
mysqlurl=jdbc:mysql://localhost:3306/school?useUnicode=true&characterEncoding=utf-8
mysqlname=root
mysqlpassword=root

3. Établissez des classes d'entités basées sur des champs de table

public class Student
{
    private int        studentId;
    private String    studentName;
    private int        studentAge;
    private String    studentPhone;
    
    public Student(int studentId, String studentName, int studentAge,
            String studentPhone)
    {
        this.studentId = studentId;
        this.studentName = studentName;
        this.studentAge = studentAge;
        this.studentPhone = studentPhone;
    }
    
    public int getStudentId()
    {
        return studentId;
    }

    public String getStudentName()
    {
        return studentName;
    }

    public int getStudentAge()
    {
        return studentAge;
    }

    public String getStudentPhone()
    {
        return studentPhone;
    }

    public String toString()
    {
        return "studentId = " + studentId + ", studentName = " + studentName + ", studentAge = " +
                studentAge + ", studentPhone = " + studentPhone;
    }
}

4. Écrivez une classe DBConnection spécifiquement pour fournir des connexions de base de données externes. J'utilise MySql ici, il n'y a donc qu'un seul mysqlConnection. Si Oracle est également utilisé, bien sûr, un oracleConnection peut être fourni en externe. Certaines personnes peuvent se demander s'il existe des problèmes de sécurité des threads lors de la globalisation de ces connexions. C'est une bonne question. En effet, nous lisons uniquement un PreparedStatement à partir de la connexion et ne l'écrivons pas. La lecture uniquement sans modification ne posera pas de problèmes de sécurité des threads. De plus, définir la connexion sur statique garantit qu'il n'y a qu'une seule copie de la connexion dans la mémoire et n'occupera pas beaucoup de ressources. Ce sera bien si vous n'appelez pas la méthode close() pour la fermer après chaque utilisation.

public class DBConnection
{    
    private static Properties properties = new Properties();
    
    static
    {
        /** 要从CLASSPATH下取.properties文件，因此要加"/" */
        InputStream is = DBConnection.class.getResourceAsStream("/db.properties");
        try
        {
            properties.load(is);
        } 
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
    
    /** 这个mysqlConnection只是为了用来从里面读一个PreparedStatement，不会往里面写数据，因此没有线程安全问题，可以作为一个全局变量 */
    public static Connection mysqlConnection = getConnection();
    
    public static Connection getConnection()
    {
        Connection con = null;
        try
        {
            Class.forName((String)properties.getProperty("mysqlpackage"));
            con = DriverManager.getConnection((String)properties.getProperty("mysqlurl"), 
                    (String)properties.getProperty("mysqlname"), 
                    (String)properties.getProperty("mysqlpassword"));
        } 
        catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        } 
        catch (SQLException e)
        {
            e.printStackTrace();
        }
        return con;
    }
}

5. Créez une classe d'outils pour écrire diverses méthodes spécifiquement pour interagir avec la base de données. Il est préférable de faire de ce type de classe d'outils un singleton, afin de ne pas avoir à en créer de nouveaux à chaque fois (en fait, je ne vois aucun avantage à créer du nouveau), économisant ainsi des ressources

package com.xrq.test11;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

public class StudentManager
{
    private static StudentManager instance = new StudentManager();
    
    private StudentManager()
    {
        
    }
    
    public static StudentManager getInstance()
    {
        return instance;
    }
    
    public List<Student> querySomeStudents(String studentName) throws Exception
    {
        List<Student> studentList = new ArrayList<Student>();
        Connection connection = DBConnection.mysqlConnection;
        PreparedStatement ps = connection.prepareStatement("select * from student where studentName = ?");
        ps.setString(1, studentName);
        ResultSet rs = ps.executeQuery();
        
        Student student = null;
        while (rs.next())
        {
            student = new Student(rs.getInt(1), rs.getString(2), rs.getInt(3), rs.getString(4));
            studentList.add(student);
        }
        
        ps.close();
        rs.close();
        return studentList;
    }
}

6. Écrivez Appelez la fonction principale

List<Student> studentList = StudentManager.getInstance().querySomeStudents("Betty");
for (Student student : studentList) {
    System.out.println(student);
}

7. Jetez un œil aux résultats en cours d'exécution. Ils sont les mêmes que ceux de la base de données Success

studentId = 1, studentName = Betty, studentAge = 20, studentPhone = 00000000
studentId = 3, studentName = Betty, studentAge = 21, studentPhone = 22222222

. Pourquoi utiliser des espaces réservés ? « » Pour fusionner les paramètres, vous devez écrire "+" entre parenthèses. S'il y a trop de paramètres à fusionner, le code n'aura certainement pas une bonne apparence et la lisibilité ne sera pas bonne. Mais en plus de cette raison, il existe une autre raison importante, qui est d'éviter un problème de sécurité . En supposant que nous n'utilisons pas d'espaces réservés pour écrire des instructions SQL, alors la méthode "querySomeStudents(String name) throws Exception" doit être écrite comme ceci :

La fonction principale ci-dessus peut également obtenir deux éléments de données. , mais le problème se pose. Eh bien, et si je l'appelais ainsi :

public List<Student> querySomeStudents(String studentName) throws Exception
{
    List<Student> studentList = new ArrayList<Student>();
    Connection connection = DBConnection.mysqlConnection;
    PreparedStatement ps = connection.prepareStatement("select * from student where studentName = '" + studentName + "'");
    ResultSet rs = ps.executeQuery();
        
    Student student = null;
    while (rs.next())
    {
        student = new Student(rs.getInt(1), rs.getString(2), rs.getInt(3), rs.getString(4));
        studentList.add(student);
    }
        
    ps.close();
    rs.close();
    return studentList;
}

Regardez les résultats en cours :

public static void main(String[] args) throws Exception
    {
        List<Student> studentList = new ArrayList<Student>();
        studentList = StudentManager.getInstance().querySomeStudents("' or '1' = '1");
        for (Student student : studentList)
            System.out.println(student);
    }

Pourquoi ? Regardez simplement l'instruction SQL après l'épissage :

studentId = 1, studentName = Betty, studentAge = 20, studentPhone = 00000000
studentId = 2, studentName = Jerry, studentAge = 18, studentPhone = 11111111
studentId = 3, studentName = Betty, studentAge = 21, studentPhone = 22222222
studentId = 4, studentName = Steve, studentAge = 27, studentPhone = 33333333
studentId = 5, studentName = James, studentAge = 22, studentPhone = 44444444

'1'='1' est toujours vrai, donc la condition de requête précédente est inutile. Ce type de problème a des scénarios d’application et n’est pas simplement écrit avec désinvolture. Java est de plus en plus utilisé sur le Web. Puisqu'il s'agit du Web, une situation lors de l'interrogation est que l'utilisateur saisit une condition, la condition de requête est obtenue en arrière-plan et l'instruction SQL est épissée pour interroger la base de données. pouvez saisir un "'' ou '1' = '1", afin que vous puissiez obtenir toutes les données de la bibliothèque.

select * from student where studentName = '' or '1' = '1'

La relation et la différence entre Statement et PreparedStatement.Relation : héritage PreparedStatement depuis Statement, les deux sont des interfaces La différence : PreparedStatement peut utiliser des espaces réservés, est précompilé et le traitement par lots est plus efficace que Statement

JDBCTransactions

Qu'est-ce qu'une transaction : Une transaction est un ensemble d'opérations un ensemble d'opérations de base de données. Si un ensemble d’étapes de traitement se produisent toutes ou qu’aucune n’est effectuée, nous appelons le processus de réorganisation une transaction.

Caractéristiques de base des transactions : atomicité, cohérence, isolement et durabilité.

Atomicité : L'atomicité signifie qu'une transaction est une unité de travail indivisible et que toutes les opérations de la transaction se produisent ou qu'aucune ne se produit.

Cohérence : La cohérence signifie que les contraintes d'intégrité de la base de données ne sont pas violées avant le début de la transaction et après la fin de la transaction. Cela signifie que les transactions de base de données ne peuvent pas détruire l’intégrité des données relationnelles ni la cohérence de la logique métier.

Si A transfère de l'argent à B, que l'opération de transfert réussisse ou non, le total des dépôts des deux restera inchangé.

Isolement : Lorsque plusieurs transactions accèdent simultanément, les transactions sont isolées et une transaction ne devrait pas affecter les effets en cours des autres transactions.

Dans un environnement concurrent, lorsque différentes transactions manipulent les mêmes données en même temps, chaque transaction possède son propre espace de données complet 🎜>. Les modifications apportées par des transactions simultanées doivent être isolées des modifications apportées par toute autre transaction simultanée. Lorsqu'une transaction consulte les mises à jour des données, l'état des données est soit l'état avant qu'une autre transaction ne les modifie, soit l'état après qu'une autre transaction les modifie La transaction ne verra pas les données dans l'état intermédiaire.

Les problèmes les plus complexes dans les transactions sont causés par l'isolement des transactions. Une isolation complète n'est pas réaliste. L'isolation complète nécessite que la base de données n'exécute qu'une seule transaction à la fois, ce qui affectera sérieusement les performances.

Persistance : signifie qu'une fois la transaction terminée, les modifications apportées à la base de données par la transaction seront conservées dans la base de données et ne seront pas renvoyées. .

Résumé : Ce qui précède représente l’intégralité du contenu de cet article, j’espère qu’il sera utile à l’étude de chacun. Pour plus de didacticiels connexes, veuillez visiter le Tutoriel vidéo Java, le Tutoriel graphique de développement Java, le Tutoriel vidéo bootstrap !

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!