JavaWeb (3 : JDBC et MVC)

JDBC est un système de gestion indépendant d'une base de données spécifique et une interface publique pour l'accès et les opérations universels aux bases de données SQL.

Définit un ensemble de normes pour fournir un moyen unifié d'accéder à différentes bases de données.

JDBC est une API d'application pour l'accès aux bases de données, composée d'un ensemble de classes et d'interfaces écrites en langage Java.

Comprend deux niveaux :

① API orientée application que les programmeurs peuvent appeler.

② API orientée base de données permettant aux fabricants de développer des pilotes de base de données.

Pour connecter différentes bases de données avec JDBC, il vous suffit de charger différents packages de pilotes de base de données et vous n'avez pas à vous soucier des différences entre les langages de fonctionnement des bases de données.

2.Écrire le programme JDBC

① Créer une table de base de données


CREATE TABLE users(
    id INT PRIMARY KEY,
    `name` VARCHAR(40),
    `password` VARCHAR(40),
    email VARCHAR(60),
    birthday DATE
);
INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(1,'张三','123456','[email protected]','2000-01-01');
INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(2,'李四','123456','[email protected]','2000-01-01');
INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(3,'王五','123456','[email protected]','2000-01-01');
SELECT * FROM users;

② Importer les dépendances de la base de données


<!--mysql的驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.31</version>
</dependency>

③ Utilisation de JDBC :

Ⅰ. Chargez le pilote de base de données (le pont entre le programme Java et la base de données)

Ⅱ. Obtenir une connexion, une connexion entre le programme Java et la base de données

Ⅲ Créez un objet Statement qui envoie du SQL à la base de données, généré par Connection.

Ⅳ Écrire des instructions SQL (écrire différents SQL selon l'entreprise)

Ⅴ. Exécutez SQL (si vous souhaitez recevoir la valeur de retour, créez un objet ResultSet pour enregistrer les résultats de la requête après l'exécution de l'instruction)

Ⅵ. Fermez la connexion


public class JDBCTest {
    public static void main(String[] args) throws Exception {
        //配置信息
        //要连接的数据库URL（解决中文乱码问题：useUnicode=true&characterEncoding=utf8&useSSL=true）
        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf8&useSSL=true";
        //连接的数据库时使用的用户名
        String username = "root";
        //连接的数据库时使用的密码
        String password = "123456";
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        
        try {
            //1.加载驱动
            Class.forName("com.mysql.cj.jdbc.Driver");
            //2.获取与数据库的链接
            conn = DriverManager.getConnection(url, username, password);
            //3.获取用于向数据库发送sql语句的statement对象
            st = conn.createStatement();
            String sql = "select id,name,password,email,birthday from users";
            //4.向数据库发sql,并获取代表结果集的resultset对象
            //查：executeQuery    增删改：executeUpdate
            rs = st.executeQuery(sql);
            //5.取出结果集的数据
            while (rs.next()) {
                System.out.println("id=" + rs.getInt("id"));
                System.out.println("name=" + rs.getString("name"));
                System.out.println("password=" + rs.getString("password"));
                System.out.println("email=" + rs.getString("email"));
                System.out.println("birthday=" + rs.getDate("birthday"));
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                //6.关闭链接，释放资源（先开后关）
                rs.close();
                st.close();
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

3. Analyse détaillée

(1) URL de la base de données

jdbc:mysql://localhost:3306/xxx

jdbc	protocole
mysql	sous-protocole
localhost:3306	port hôte
xxx	base de données

Comment écrire les adresses URL de bases de données couramment utilisées :

Écriture Oracle : jdbc:oracle:thin :@localhost:1521:xxx
Nom de la base de données SQL Server : jdbc : microsoft : sqlserver : ://localhost : 1433 ; DatabaseName = xxx
Méthode d'écriture MySql : jdbc:mysql://localhost:3306/xxx

(2) Classe de connexion

La connexion est utilisée pour représenter les liens de base de données et la collection est l'objet le plus important dans la programmation de base de données.

Toutes les interactions entre le client et la base de données sont effectuées via l'objet de connexion., méthodes courantes de cet objet :

createStatement()	Créer un objet d'instruction qui envoie SQL à la base de données
préparerStatement(sql)	Créez un objet PrepareSationment qui envoie du SQL précompilé à la base de données
setAutoCommit(booléen autoCommit)	Définir si les transactions sont automatiquement validées
commettre()	Soumettre la transaction sur le lien
retour en arriere()	Transaction d'annulation sur ce lien

(3) Classe de déclaration

L'objet Statement est utilisé pour envoyer des instructions SQL à la base de données Méthodes courantes de l'objet Statement :

exécuterQuery(Chaîne sql)	Utilisé pour envoyer des instructions de requête aux données et renvoyer un jeu de résultats ResultSet
executeUpdate(Chaîne sql)	Utilisé pour envoyer des instructions d'insertion, de mise à jour ou de suppression à la base de données et renvoyer le nombre de lignes mises à jour dans la base de données
exécuter(Chaîne sql)	Utilisé pour envoyer des instructions SQL arbitraires à la base de données
addBatch(Chaîne sql)	Mettez plusieurs instructions SQL dans un lot
exécuterBatch()	Envoyer un lot d'instructions SQL à la base de données pour exécution

Avis:

Pour améliorer l'efficacité opérationnelle, la méthode d'exécution n'est généralement pas utilisée directement.

Utilisez-les plutôt en conséquence : executeQuery pour les requêtes ;executeUpdate pour les ajouts, les suppressions et les modifications.

(4) Classe ResultSet

ResultSet est utilisé pour représenter les résultats d'exécution des instructions SQL.

Ensemble de résultats Lors de l'encapsulation du jeu de résultats d'exécution, utilisezsemblable au tableauLe chemin。

L'objet ResultSet maintient un curseur pointant vers les lignes de données du tableau.Initialement, le curseur est avant la première ligne。

L'appel de la méthode ResultSet.next() peut faire pointer le curseur sur une ligne de données spécifique et appeler la méthode getxxx pour obtenir les données de la ligne.

① Obtenez tout type de données

getObject(int index)	Récupère l'objet Object en fonction du nombre de colonnes spécifié
getObject(chaîne nom_colonne)	Récupère l'objet Object en fonction du nom d'attribut spécifié

② Obtenir des données du type spécifié, comme obtenir le type String

getString(int index)	Obtenez un objet String en fonction du nombre de colonnes spécifié
getString(Chaîne nom_colonne)	Récupère l'objet String en fonction du nom d'attribut spécifié

③ Comment faire défiler l'ensemble de résultats :

suivant()	passer à la ligne suivante
Précédent()	passer à la ligne précédente
absolu(int ligne)	Déplacer vers la ligne spécifiée
avantPremier()	Déplacer le devant de resultSet
aprèsDernier()	Aller à la fin de resultSet

(5) Libérer des ressources

Une fois l'exécution du programme Jdbc terminée, n'oubliez pas de libérer les objets créés par le programme pour interagir avec la base de données pendant le processus en cours.

Ces objets sont généralement des objets ResultSet, Statement et Connection.

Surtout l'objet Connection, c'est une ressource très rare et doit être libérée immédiatement après utilisation.

Si la connexion ne peut pas être fermée rapidement et correctement, cela peut facilement entraîner un temps d'arrêt du système.

Pour garantir que le code de version de ressource peut s'exécuter, le code de version de ressource doit également être placé dans l'instructionfinal.

4.Problème d'injection SQL

Il y a deux problèmes lors de l'utilisation de Statement pour le développement :

① Les chaînes doivent être épissées fréquemment et le taux d'erreur est élevé


String username = "zhangsan";
String password = "123";
String sql = "select * from users where name='"+username+"' and password='"+password+"'";
ResultSet rs = st.executeQuery(sql);

② Il existe un risque potentiel d'injection SQL

Injection SQL : injection d'instructions SQL illégales dans les données saisies par l'utilisateur, en utilisant des techniques intelligentes pour épisser les chaînes, provoquant un court-circuit SQL, volant ainsi les données de la base de données.


public class SQLTest {
    public static void main(String[] args) throws Exception {
        // 正常登陆sql：select * from users where name='张三' and password ='123456'
        //login("张三","123456");
        // SQL 注入：select * from users where name='' and password ='123456' or '1'='1'
        login("", "123456' or '1'='1");
    }
 
    public static void login(String username, String password) throws Exception {
        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf8&useSSL=true";
        String dbUsername = "root";
        String dbPassword = "123456";
 
        //1.加载驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.获取与数据库的链接
        Connection conn = DriverManager.getConnection(url, dbUsername, dbPassword);
        //3.获取用于向数据库发送sql语句的statement
        Statement st = conn.createStatement();
        String sql = "select * from users where name='" + username + "' and password='" + password + "'";
        System.out.println(sql);
        //4.向数据库发sql,并获取代表结果集的rs
        ResultSet rs = st.executeQuery(sql);
        if (rs.next()) {
            System.out.println("登录成功");
        } else {
            System.out.println("登录失败");
        }
        //6.关闭链接，释放资源
        rs.close();
        st.close();
        conn.close();
    }
}

résultat de l'opération :

Avis:

La priorité de et dans l'instruction SQL est supérieure à ou, donc le SQL exécuté équivaut à sélectionner * parmi les utilisateurs où '1' = '1' ;

Solution:Utilisez PreparedStatement, une sous-classe de Statement, qui fournit la fonction d'espace réservé SQL.

Il n'est pas nécessaire d'épisser les chaînes et les données saisies par l'utilisateur seront entièrement détectées, ce qui les rendra plus sûres.


public class PSTest {
    public static void main(String[] args) throws Exception {
        // 正常登陆sql：select * from users where name='张三' and password ='123456'
        //login("张三","123456");
        // SQL 注入：select * from users where name='' and password ='123456' or '1'='1'
        login("", "123456' or '1'='1");
    }
 
    public static void login(String username, String password) throws Exception {
        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf8&useSSL=true";
        String dbUsername = "root";
        String dbPassword = "123456";
 
        Class.forName("com.mysql.cj.jdbc.Driver");
 
        Connection conn = DriverManager.getConnection(url, dbUsername, dbPassword);
        //获取用于向数据库发送预编译sql语句的prepareStatement
        String sql = "select * from users where name = ? and password = ?";
        System.out.println(sql);
        PreparedStatement ps = conn.prepareStatement(sql);
        //给占位符 ? 填充数据
        ps.setString(1, username);
        ps.setString(2, password);
        ResultSet rs = ps.executeQuery();
        if (rs.next()) {
            System.out.println("登录成功");
        } else {
            System.out.println("登录失败");
        }
        rs.close();
        ps.close();
        conn.close();
    }
}

résultat de l'opération :

5.Transactions JDBC

Une transaction fait référence à un ensemble logique d’opérations, toutes réussies ou toutes infructueuses (principe ACID).

Lorsque le programme Jdbc obtient un objet Connection de la base de données, par défaut, l'objet Connection soumettra automatiquement une transaction à la base de données.

Si vous souhaitez désactiver cette méthode de soumission par défaut et autoriser l'exécution de plusieurs SQL en une seule transaction, vous pouvez utiliser l'instruction de transaction de contrôle JDBC suivante.

Connexion.setAutoCommit(false);	commencer la transaction
Connexion.rollback();	Transaction d'annulation
Connexion.commit();	valider une transaction

① Créer un tableau de comptes


/*创建账户表*/
CREATE TABLE account(
    id INT PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR(40),
    money DECIMAL(9,2)
);
/*插入测试数据*/
insert into account(name,money) values('A',1000);
insert into account(name,money) values('B',1000);
insert into account(name,money) values('C',1000);

② Simulez le scénario commercial lorsque le transfert est réussi


//失败后让数据库自动回滚事务
public class Demo {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf8&useSSL=true";
        String username = "root";
        String password = "123456";
        Connection conn = null;
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(url, username, password);
 
            //通知数据库开启事务，false表示开启
            conn.setAutoCommit(false);
 
            String sql1 = "update account set money=money-100 where name = 'A' ";
            conn.prepareStatement(sql1).executeUpdate();
 
            //模拟执行完SQL1之后程序出现了异常而导致后面的SQL无法正常执行，事务也无法正常提交
            int x = 1/0;
 
            String sql2 = "update account set money=money+100 where name = 'B' ";
            conn.prepareStatement(sql2)executeUpdate();
 
            //sql1 和 sql2都顺利执行，就提交事务
            conn.commit();
            System.out.println("成功！！！");
        } catch (Exception e) {
            //出现异常，通知数据库回滚事务
            conn.rollback();
            e.printStackTrace();
        } finally {
            conn.close();
        }
    }
}

6.Classe d'outils JDBC

Dans différentes requêtes, vous devez vous connecter à la base de données et libérer des ressources à chaque fois, et beaucoup de code répété sera écrit.

Encapsulez les opérations de préparation et de libération de la connexion à la base de données dans une classe d'outils et appelez-la directement lorsque vous l'utilisez pour éviter d'écrire du code répété.


public class JdbcUtil {
    private static Connection connection;
    private static String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf8&useSSL=true";
    private static String username = "root";
    private static String password = "123456";
 
    //驱动（类）只需要加载一次，放静态代码块即可
    static {
        try {
            //加载数据库驱动
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    // 获取数据库连接对象
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }
 
    // 释放资源（利用多态：Statement 和 PreparedStatement 都可以传进来）
    public static void release(Connection conn, Statement st, ResultSet rs) {
        try {
            if (rs != null) {
                rs.close();
            }
            if (st != null) {
                st.close();
            }
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Cas d'appel, tel que : ajouter un utilisateur


 
    public void add(String name, String password) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = JdbcUtil.getConnection();
            String sql = "insert into users(name,password) values(?,?)";
            ps = conn.prepareStatement(sql);
            ps.setString(1, name);
            ps.setString(2, password);
            ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.release(conn, ps, null);
        }
    }

7. Pool de connexions à la base de données

(1. Vue d'ensemble

Processus de développement JDBC :

Ⅰ. Chargez le pilote de base de données (ne doit être chargé qu'une seule fois)

Ⅱ. Établir une connexion à la base de données (Connexion)

Ⅲ Créez un objet Statement qui envoie du SQL à la base de données, généré par Connection.

Ⅳ. Écrire des instructions SQL

Ⅴ. Exécuter SQL (l'objet Query-->ResultSet reçoit le jeu de résultats)

Ⅵ. Fermez la connexion et libérez les ressources.

L'objet de connexion à la base de données est obtenu via DriverManager. Chaque fois qu'il est obtenu, vous devez vous adresser à la base de données pour obtenir une connexion et vérifier le nom d'utilisateur et le mot de passe.

Les utilisateurs doivent obtenir un lien de la base de données pour chaque requête, et la création d'une connexion à la base de données consomme généralement des ressources relativement importantes et prend beaucoup de temps à créer.

Chaque fois que l'instruction SQL est exécutée, la connexion est déconnectée, ce qui entraînera un gaspillage de ressources et les ressources de connexion à la base de données ne seront pas bien réutilisées.

En supposant que le site Web reçoive 100 000 visites par jour, le serveur de base de données doit créer 100 000 connexions, ce qui représente un énorme gaspillage de ressources de base de données et peut facilement provoquer un débordement de mémoire du serveur de base de données et une expansion de la machine.

Solution : Pool de connexions à la base de données

L'idée de base du pool de connexions à la base de données :

Établissez un pool de mémoire tampon pour la base de données et placez à l'avance un certain nombre d'objets de connexion dans le pool de mémoire tampon.

Lorsque vous souhaitez obtenir une connexion à une base de données, il vous suffit de récupérer un objet du pool de mémoire tampon.

Après utilisation, remettez-le dans le pool de mémoire tampon pour la prochaine requête, obtenant ainsi une réutilisation des ressources sans avoir besoin d'une création répétée.

Lorsqu'il n'y a aucun objet de connexion inactif dans le pool de connexions à la base de données, les nouvelles requêtes entreront dans la file d'attente et attendront que d'autres threads libèrent la connexion.

(2) Utilisation

Le pool de connexions à la base de données de JDBC est complété à l'aide de l'interface javax.sql.DataSource est l'interface officiellement fournie par Java.

Lorsqu'ils l'utilisent, les développeurs n'ont pas besoin d'implémenter eux-mêmes l'interface et peuvent utiliser des outils tiers.

C3P0 est une implémentation tierce couramment utilisée. Dans le développement réel, C3P0 peut être utilisé directement pour terminer le fonctionnement du pool de connexions à la base de données.

Étapes d'utilisation :

① Importer les dépendances dans pom.xml


	<dependency>
	    <groupId>com.mchange</groupId>
	    <artifactId>c3p0</artifactId>
	    <version>0.9.5.2</version>
	</dependency>

② Écrire le code


public class DataSourceTest {
    public static void main(String[] args) {
        try {
            //创建C3P0数据库连接池
            ComboPooledDataSource dataSource=new ComboPooledDataSource();
            dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
            dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf8");
            dataSource.setUser("root");
            dataSource.setPassword("123456");
            //设置初始化连接个数
            dataSource.setInitialPoolSize(5);
            //设置最大连接个数（连接池中不够，可以继续申请，申请后最终的上限）
            dataSource.setMaxPoolSize(20);
            //当连接对象不够时，再次申请的连接对象个数
            dataSource.setAcquireIncrement(5);
            //设置最小连接数（当连接池中剩余2个连接对象时，就去申请 --> 提前做准备）
            dataSource.setMinPoolSize(2);
            Connection conn=dataSource.getConnection();
 
            //SQL操作...
 
            //将连接还回到数据库连接池中
            conn.close();
        } catch (PropertyVetoException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Avis:

Connexion obtenue par méthode traditionnelle : com.mysql.cj.jdbc.ConnectionImpl@3c153a1

Connexion obtenue par C3P0 : com.mchange.v2.c3p0.impl.NewProxyConnection@6156496

donc,Bien qu'ils appellent tous la méthode close, les classes d'implémentation sont différentes, donc la réécriture de la méthode est également différente. Il s'agit du polymorphisme d'interface.。

La méthode close dans C3P0 ne détruit pas directement la ressource de connexion, mais renvoie la connexion au pool de connexions de base de données.

La méthode ci-dessus de définition des paramètres du pool de connexions à la base de données est écrite directement dans le programme Java.

Ceci est adoptécoder en durLe chemin,Chaque fois que vous modifiez la configurationIl faut recompiler, génère de nouveaux fichiers de classe, l'efficacité est trop faible。

Dans le développement réel, les informations de configuration de C3P0 sont définies dans un fichier XML et le programme Java n'a besoin que de charger le fichier de configuration pour terminer l'opération d'initialisation du pool de connexions à la base de données.

Par la suite, il vous suffit de modifier la configuration et de modifier la configuration en XML sans recompiler.

Étapes d'utilisation :

① Dans le répertoire des ressources, créez un nouveau fichier nommé c3p0-config.xml

② Remplissez les informations de configuration dans c3p0-config.xml :


<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <!--配置连接池mysql-->
    <named-config name="C3P0Test">
        <!--   指定连接数据源的基本属性     -->
        <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbc?useUnicode=true&amp;characterEncoding=utf8</property>
        <property name="user">root</property>
        <property name="password">123456</property>
 
        <!--   设置初始化连接个数     -->
        <property name="initialPoolSize">5</property>
        <!--   设置最大连接个数（连接池中不够，可以继续申请，申请后最终的上限）     -->
        <property name="maxPoolSize">20</property>
        <!--   当连接对象不够时，再次申请的连接对象个数     -->
        <property name="acquireIncrement">5</property>
        <!--   设置最小连接数（当连接池中剩余2个连接对象时，就去申请 -> 提前做准备） -->
        <property name="minPoolSize">2</property>
    </named-config>
</c3p0-config>

③Écrire un programme Java


public class DataSourceTest {
    public static void main(String[] args) {
        try {
            //创建C3P0数据库连接池
            ComboPooledDataSource dataSource=new ComboPooledDataSource("C3P0Test");
            Connection conn=dataSource.getConnection();
            System.out.println(conn);
            //将连接还回到数据库连接池中
            conn.close();
        }catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Avis:

① Le paramètre dans la méthode de construction ComboPooledDataSource est la valeur de l'attribut name de la balise nommée-config configurée dans c3p0-config.xml.

② À l'heure actuelle, la classe d'outils JDBC peut être modifiée comme suit :


public class JdbcUtil {
    private static DataSource dataSource;
 
    static {
        dataSource = new ComboPooledDataSource("C3P0Test");
    }
 
    // 获取数据库连接对象
    public static Connection getConnection() throws SQLException {
        Connection conn = null;
        try {
            conn = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }
 
    // 释放资源（利用多态：Statement 和 PreparedStatement 都可以传进来）
    public static void release(Connection conn, Statement st, ResultSet rs) {
        try {
            if (rs != null) {
                rs.close();
            }
            if (st != null) {
                st.close();
            }
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

8.DBUtils


    public static Student findById(Integer idx) {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
        Student stu = null;
        try {
            conn = JdbcUtil.getConnection();
 
            String sql = "select * from student where id = ?";
            PreparedStatement ps = conn.prepareStatement(sql);
            //给占位符 ? 填充数据
            ps.setInt(1, idx);
            rs = ps.executeQuery();
            //取出结果集的数据
            while (rs.next()) {
                Integer id = rs.getInt(1);
                String name = rs.getString(2);
                Double score = rs.getDouble(3);
                Date birthday = rs.getDate(4);
                stu = new Student(id, name, score, birthday);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭链接，释放资源
                rs.close();
                st.close();
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return stu;
    }

Dans le code ci-dessus, les opérations de remplissage des espaces réservés avec des données et d'extraction des données de l'ensemble de résultats sont trop lourdes.

S'il y a 100 attributs dans la table Student, nous devrons alors écrire 100 lignes dans la boucle while pour récupérer les données, et cela peut également prendre plusieurs lignes pour remplir les espaces réservés.

Solution:DBUtils peut aider les développeurs à réaliser l'encapsulation des données (mappage des jeux de résultats vers des objets Java).

Étapes d'utilisation :

① Importer les dépendances dans pom.xml


<dependency>
	<groupId>commons-dbutils</groupId>
	<artifactId>commons-dbutils</artifactId>
	<version>1.6</version>
</dependency>

② Écrire le code


    public static Student findById(Integer idx) {
        Connection conn = null;
        Student stu = null;
        try {
            conn = JdbcUtil.getConnection();
 
            String sql = "select * from student where id = ?";
            //使用DBUtils
            QueryRunner qr = new QueryRunner();
            stu = qr.query(conn, sql, new BeanHandler<>(Student.class), idx);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭链接，释放资源
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return stu;
    }

À ce stade, le remplissage des espaces réservés et la suppression du jeu de résultats peuvent être effectués avec deux lignes de code.

détail:

① La méthode de requête doit transmettre 4 paramètres :

Objet de connexion

Instruction SQL

L'objet de classe d'implémentation de l'interface ResultSetHandler (le type de l'objet converti doit être : Student.class)

Paramètres pour remplir les espaces réservés

② L'interface ResultSetHandler est utilisée pour traiter les ensembles de résultats. Elle peut convertir les ensembles de résultats interrogés en objets Java. Les quatre classes d'implémentation suivantes sont fournies.

Gestionnaire de haricots	Mappez le jeu de résultats dans un objet Java (tel qu'un objet Student)
Gestionnaire de liste de haricots	Mappez l'ensemble de résultats dans une collection List (telle que : List<Student > )
Gestionnaire de cartes	Mappez le jeu de résultats dans un objet de collection Map (c'est-à-dire : carte<String,Object> clé : nom de l'attribut ; valeur : valeur de l'attribut)
Gestionnaire de liste de cartes	Mappez l'ensemble de résultats dans une collection MapList (c'est-à-dire : List <Map<<String,Object> >)

③ Le paramètre à remplir dans l'espace réservé est un paramètre variable, donc n'importe quel nombre de paramètres peut être transmis pour répondre aux différents besoins des utilisateurs.

④ La classe d'objet convertie (classe Student) doit avoir un constructeur sans paramètre, sinon le programme signalera une erreur.

raison:La couche inférieure trouve cette classe via Student.class, puis viamécanisme de réflexionRecherchez le constructeur sans paramètre de cette classe et créez son objet.

⑤ Le nom de l'attribut dans la classe doit être exactement le même que le nom du champ dans la table de la base de données.

Parce qu'après la création de l'objet, lors de l'attribution de valeurs aux propriétés de l'objet en fonction du jeu de résultats, la recherche et l'affectation sont effectuées en fonction du nom.

11. Architecture MVC à trois niveaux

Qu’est-ce que MVC ?

Modèle : modèle (service, dao, entité)
Vue : Vue (jsp, html, client d'application)
Contrôleur : Contrôleur (Servlet, Hander, Action)

Une fois la demande entrée dans l'application JavaWeb, le contrôleur reçoit la demande, effectue le traitement de la logique métier et renvoie enfin le résultat à l'utilisateur (Vue + Modèle).

1. Introduction

Dans les premières années, lors de l'exploitation d'applications Web, les utilisateurs accédaient directement à la couche de contrôle, et la couche de contrôle pouvait directement exploiter la base de données :

servlet--CRUD (ajouter, supprimer, modifier)-->base de données

Dans le code du servlet : traitement des requêtes, des réponses, des sauts de vue, traitement JDBC, traitement du code métier et traitement du code logique

Désavantages:Le programme est très volumineux et peu propice à la maintenance

solution: Il n'y a rien que l'ajout d'un autre calque ne puisse résoudre, si c'est le cas, ajoutez un autre calque !

2. Architecture mvc à trois niveaux

Modèle

Traitement métier : logique métier (Service)
Couche de persistance des données : CRUD (objet de persistance des données DAO)

voir

afficher les données
Fournir un lien pour lancer une requête Servlet (a, form, img...)

Contrôleur (Servlet)

Recevoir la demande de l'utilisateur : (requête, paramètres de demande, informations de session)
Remettez-le à la couche métier pour traiter le code correspondant
Contrôler le saut de vue

Prenons l'exemple de la connexion utilisateur et administrateur :

Couche contrôleur :


@WebServlet("/login")
public class LoginServlet extends HttpServlet {
 
    private LoginService loginService = new LoginServiceImpl();
 
    /* 处理登录的业务逻辑*/
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        String type = req.getParameter("type");
        Object object = loginService.login(username,password,type);
        if(object != null){
            HttpSession session = req.getSession();
            switch (type){
                case "reader":
                    Reader reader = (Reader) object;
                    session.setAttribute("reader",reader);
                    //跳转到用户的首页
                    resp.sendRedirect("/book?page=1");
                    break;
                case "admin":
                    Admin admin = (Admin) object;
                    session.setAttribute("admin",admin);
                    //跳转到管理员的首页
                    resp.sendRedirect("/admin?method=findAllBorrow&page=1");
                    break;
            }
        }else{
            resp.sendRedirect("login.jsp");
        }
    }
 
}

Couche de services :


public interface LoginService {
    //利用多态，动态返回不同类型的对象
    public Object login(String username,String password,String type);
}


public class LoginServiceImpl implements LoginService {
 
    private ReaderRepository readerRepository = new ReaderRepositoryImpl();
    private AdminRepository adminRepository = new AdminRepositoryImpl();
 
    @Override
    public Object login(String username, String password,String type) {
        Object object = null;
        //业务逻辑处理：根据type的值，来选择调用不同的登录方法，去查找不同的表
        switch (type){
            case "reader":
                object = readerRepository.login(username,password);
                break;
            case "admin":
                object = adminRepository.login(username, password);
                break;
        }
        return object;
    }
}

Couche Dao/Référentiel :


public interface AdminRepository {
    public Admin login(String username,String password);
}


public interface ReaderRepository {
    public Reader login(String username,String password);
}


public class AdminRepositoryImpl implements AdminRepository {
    //管理员的登录方法（和数据库交互）
    @Override
    public Admin login(String username, String password) {
        Connection connection = JDBCTools.getConnection();
        String sql = "select * from bookadmin where username = ? and password = ?";
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        Admin admin = null;
        try {
            statement = connection.prepareStatement(sql);
            statement.setString(1,username);
            statement.setString(2,password);
            resultSet = statement.executeQuery();
            if(resultSet.next()){
                admin = new Admin(resultSet.getInt(1),resultSet.getString(2),resultSet.getString(3));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCTools.release(connection,statement,resultSet);
        }
        return admin;
    }
}


public class ReaderRepositoryImpl implements ReaderRepository {
    //用户的登录方法（和数据库交互）
    @Override
    public Reader login(String username, String password) {
        Connection connection = JDBCTools.getConnection();
        String sql = "select * from reader where username = ? and password = ?";
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        Reader reader = null;
        try {
            statement = connection.prepareStatement(sql);
            statement.setString(1,username);
            statement.setString(2,password);
            resultSet = statement.executeQuery();
            if(resultSet.next()){
                reader = new Reader(resultSet.getInt(1),resultSet.getString(2),resultSet.getString(3),resultSet.getString(4),resultSet.getString(5),resultSet.getString(6),resultSet.getString(7));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCTools.release(connection,statement,resultSet);
        }
        return reader;
    }
}

Partage de technologie