JavaWeb (3: JDBC e MVC)

JDBC è un sistema di gestione indipendente da un database specifico e un'interfaccia pubblica per l'accesso e le operazioni del database SQL universale.

Definisce una serie di standard per fornire un modo unificato per accedere a diversi database.

JDBC è un'API applicativa per l'accesso ai database, costituita da un insieme di classi e interfacce scritte in linguaggio Java.

Comprende due livelli:

① API orientata alle applicazioni che i programmatori possono chiamare.

② API orientata al database per consentire ai produttori di sviluppare driver di database.

Per connettere diversi database con JDBC, devi solo caricare diversi pacchetti di driver di database e non devi preoccuparti delle differenze nei linguaggi operativi del database.

2.Scrivere il programma JDBC

① Crea la tabella del database


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;

② Importa le dipendenze del database


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

③ Utilizzo di JDBC:

Ⅰ Caricare il driver del database (il ponte tra il programma Java e il database)

Ⅱ Ottieni Connection, una connessione tra il programma Java e il database

Ⅲ Creare un oggetto Statement che invia SQL al database, generato da Connection

Ⅳ. Scrivi istruzioni SQL (scrivi SQL diversi a seconda dell'azienda)

Ⅴ Esegui SQL (se desideri ricevere il valore restituito, crea un oggetto ResultSet per salvare i risultati della query dopo l'esecuzione dell'istruzione)

Ⅵ. Chiudere la connessione


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. Analisi dettagliata

(1) URL del database

jdbc:mysql://localhost:3306/xxx

JDBBC-IT	protocollo
il mio sql	sottoprotocollo
host locale:3306	porta ospite
xxx	Banca dati

Come scrivere gli indirizzi URL del database di uso comune:

Scrittura Oracle: jdbc:oracle:thin:@localhost:1521:xxx
Nome del database SqlServer: jdbc:microsoft:sqlserver://localhost:1433; DatabaseName=xxx
Metodo di scrittura MySql: jdbc:mysql://localhost:3306/xxx

(2) Classe di connessione

La connessione viene utilizzata per rappresentare i collegamenti al database e la raccolta è l'oggetto più importante nella programmazione del database.

Tutte le interazioni tra il client e il database vengono completate tramite l'oggetto connessione., metodi comuni di questo oggetto:

creaIstruzione()	Crea un oggetto istruzione che invia SQL al database
preparareIstruzione(sql)	Crea un oggetto PrepareSatement che invia SQL precompilato al database
setAutoCommit(booleano autoCommit)	Imposta se le transazioni vengono impegnate automaticamente
commettere()	Invia transazione sul collegamento
ripristinare()	Transazione di rollback su questo collegamento

(3) Classe di istruzione

L'oggetto Statement viene utilizzato per inviare istruzioni SQL al database. Metodi comuni dell'oggetto Statement:

eseguiQuery(Stringa sql)	Utilizzato per inviare istruzioni di query ai dati e restituire un set di risultati ResultSet
eseguiUpdate(Stringa sql)	Utilizzato per inviare istruzioni di inserimento, aggiornamento o eliminazione al database e restituire il numero di righe aggiornate nel database
eseguire(Stringa sql)	Utilizzato per inviare istruzioni SQL arbitrarie al database
addBatch(Stringa sql)	Inserisci più istruzioni SQL in un batch
eseguiBatch()	Invia un batch di istruzioni SQL al database per l'esecuzione

Avviso:

Per migliorare l'efficienza operativa, il metodo di esecuzione generalmente non viene utilizzato direttamente.

Usateli invece di conseguenza: eseguireQuery per le query; eseguireUpdate per aggiunte, eliminazioni e modifiche.

(4) Classe ResultSet

ResultSet viene utilizzato per rappresentare i risultati dell'esecuzione delle istruzioni SQL.

Set di risultati Quando si incapsula il set di risultati dell'esecuzione, utilizzaresimile al tavoloIl modo。

L'oggetto ResultSet mantiene un cursore che punta alle righe di dati della tabella.Inizialmente, il cursore si trova prima della prima riga。

La chiamata al metodo ResultSet.next() può far sì che il cursore punti su una riga di dati specifica e chiamare il metodo getxxx per ottenere i dati della riga.

① Ottieni qualsiasi tipo di dato

getObject(int indice)	Ottieni l'oggetto Object in base al numero di colonne specificato
getObject(stringa nomecolonna)	Ottieni l'oggetto Object in base al nome dell'attributo specificato

② Ottieni dati del tipo specificato, come ottenere il tipo String

getString(int indice)	Ottieni un oggetto String in base al numero specificato di colonne
getString(Stringa nomecolonna)	Ottieni l'oggetto String in base al nome dell'attributo specificato

③ Come scorrere il set di risultati:

Prossimo()	passare alla riga successiva
Precedente()	passare alla riga precedente
assoluto(int riga)	Passa alla riga specificata
prima diPrimo()	Sposta la parte anteriore di resultSet
dopoUltimo()	Passa alla fine del resultSet

(5) Rilasciare risorse

Al termine dell'esecuzione del programma Jdbc, ricordarsi di rilasciare gli oggetti creati dal programma per interagire con il database durante il processo in esecuzione.

Questi oggetti sono solitamente oggetti ResultSet, Statement e Connection.

Soprattutto l'oggetto Connection, è una risorsa molto rara e deve essere rilasciata immediatamente dopo l'uso.

Se la connessione non può essere chiusa tempestivamente e correttamente, può facilmente causare tempi di inattività del sistema.

Per garantire che il codice di rilascio della risorsa possa essere eseguito, è necessario inserire anche il codice di rilascio della risorsa nell'istruzione final.

4.Problema di iniezione SQL

Ci sono due problemi quando si utilizza Statement per lo sviluppo:

① Le stringhe devono essere giuntate frequentemente e il tasso di errore è elevato


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

② Esiste il rischio potenziale di SQL injection

SQL injection: inserimento di istruzioni SQL illegali nei dati immessi dall'utente, utilizzando tecniche intelligenti per unire le stringhe, causando un cortocircuito SQL, rubando così i dati del database.


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();
    }
}

risultato dell'operazione:

Avviso:

La priorità di e nell'istruzione SQL è maggiore di o, quindi l'SQL eseguito equivale a selezionare * dagli utenti dove '1' = '1';

Soluzione:Utilizzare PreparedStatement, una sottoclasse di Statement, che fornisce la funzione di segnaposto SQL.

Non è necessario unire le stringhe e i dati inseriti dall'utente verranno completamente rilevati, rendendo il tutto più sicuro.


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();
    }
}

risultato dell'operazione:

5.Transazioni JDBC

Una transazione si riferisce a un insieme logico di operazioni, tutte riuscite o tutte fallite (principio ACID).

Quando il programma Jdbc ottiene un oggetto Connection dal database, per impostazione predefinita l'oggetto Connection invierà automaticamente una transazione al database.

Se desideri disattivare questo metodo di invio predefinito e consentire l'esecuzione di più SQL in un'unica transazione, puoi utilizzare la seguente istruzione della transazione di controllo JDBC.

Connessione.setAutoCommit(false);	avviare la transazione
Connessione.rollback();	Transazione di ripristino
Connessione.commit();	impegnare la transazione

① Crea la tabella dei conti


/*创建账户表*/
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);

② Simulare lo scenario aziendale una volta che il trasferimento avrà esito positivo


//失败后让数据库自动回滚事务
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 strumento JDBC

In diverse richieste, è necessario connettersi al database e rilasciare risorse ogni volta e verrà scritto molto codice ripetuto.

Incapsulare le operazioni di preparazione e rilascio della connessione al database in una classe di strumenti e chiamarla direttamente quando la si utilizza per evitare di scrivere codice ripetuto.


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();
        }
    }
}

Chiama il caso, ad esempio: aggiungi utente


 
    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 di connessioni al database

(1. Panoramica

Processo di sviluppo JDBC:

Ⅰ Caricare il driver del database (deve essere caricato solo una volta)

Ⅱ Stabilire la connessione al database (Connessione)

Ⅲ Creare un oggetto Statement che invia SQL al database, generato da Connection

Ⅳ Scrivere istruzioni SQL

Ⅴ Esegui SQL (Query-->L'oggettoResultSet riceve il set di risultati)

Ⅵ Chiudi la connessione e rilascia le risorse

L'oggetto di connessione al database viene ottenuto tramite DriverManager Ogni volta che viene ottenuto, è necessario rivolgersi al database per ottenere una connessione e verificare il nome utente e la password.

Gli utenti devono ottenere un collegamento dal database per ogni richiesta e la creazione di una connessione al database solitamente consuma risorse relativamente grandi e richiede molto tempo.

Ogni volta che viene eseguita l'istruzione SQL, la connessione viene interrotta, il che causerà uno spreco di risorse e le risorse di connessione al database non verranno riutilizzate correttamente.

Supponendo che il sito Web riceva 100.000 visite al giorno, il server del database deve creare 100.000 connessioni, il che rappresenta un enorme spreco di risorse del database e può facilmente causare un overflow della memoria del server del database e l'espansione della macchina.

Soluzione: pool di connessioni al database

L'idea di base del pool di connessioni al database:

Stabilire un pool buffer per il database e inserire in anticipo un certo numero di oggetti di connessione nel pool buffer.

Quando si desidera ottenere una connessione al database, è sufficiente prendere un oggetto dal pool di buffer.

Dopo l'uso, reinserirlo nel buffer pool per la richiesta successiva, ottenendo il riutilizzo delle risorse senza la necessità di ripetute creazioni.

Quando non sono presenti oggetti di connessione inattivi nel pool di connessioni del database, le nuove richieste entreranno nella coda di attesa e attenderanno che altri thread rilascino la connessione.

(2) Utilizzo

Il pool di connessioni al database di JDBC viene completato utilizzando l'interfaccia javax.sql.DataSource è l'interfaccia fornita ufficialmente da Java.

Quando lo utilizzano, gli sviluppatori non hanno bisogno di implementare l'interfaccia da soli e possono utilizzare strumenti di terze parti.

C3P0 è un'implementazione di terze parti comunemente utilizzata Nello sviluppo effettivo, C3P0 può essere utilizzato direttamente per completare l'operazione del pool di connessioni al database.

Passaggi per l'utilizzo:

① Importa le dipendenze in pom.xml


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

② Scrivi il codice


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();
        }
    }
}

Avviso:

Connessione ottenuta tramite metodo tradizionale: com.mysql.cj.jdbc.ConnectionImpl@3c153a1

Connessione ottenuta da C3P0: com.mchange.v2.c3p0.impl.NewProxyConnection@6156496

COSÌ,Sebbene tutti chiamino il metodo close, le classi di implementazione sono diverse, quindi anche la riscrittura del metodo è diversa. Si tratta di polimorfismo dell'interfaccia.。

Il metodo di chiusura in C3P0 non distrugge direttamente la risorsa di connessione, ma restituisce la connessione al pool di connessioni del database.

Il metodo sopra descritto per impostare i parametri per il pool di connessioni al database viene scritto direttamente nel programma Java.

Questo è adottatohardcodeIl modo,Ogni volta che cambi la configurazioneÈ necessario ricompilare, genera nuovi file di classe, l'efficienza è troppo bassa。

Nello sviluppo effettivo, le informazioni di configurazione di C3P0 sono definite in un file xml e il programma Java deve solo caricare il file di configurazione per completare l'operazione di inizializzazione del pool di connessioni al database.

Successivamente basterà modificare la configurazione e modificare la configurazione in xml senza ricompilare.

Passaggi per l'utilizzo:

① Nella directory delle risorse, crea un nuovo file denominato c3p0-config.xml

② Compila le informazioni di configurazione in 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>

③Scrivere un programma 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();
        }
    }
}

Avviso:

① Il parametro nel metodo di costruzione ComboPooledDataSource è il valore dell'attributo name del tag Named-config configurato in c3p0-config.xml.

② A questo punto, la classe dello strumento JDBC può essere modificata come:


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;
    }

Nel codice precedente, le operazioni di riempimento dei segnaposto con i dati e di estrazione dei dati dal set di risultati sono troppo macchinose.

Se ci sono 100 attributi nella tabella Studente, allora dovremo scrivere 100 righe nel ciclo while per recuperare i dati e potrebbero essere necessarie anche molte righe per riempire i segnaposto.

Soluzione:DBUtils può aiutare gli sviluppatori a completare l'incapsulamento dei dati (mappatura dei set di risultati su oggetti Java).

Passaggi per l'utilizzo:

① Importa le dipendenze in pom.xml


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

② Scrivi il codice


    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;
    }

A questo punto, riempire i segnaposto ed estrarre il set di risultati può essere eseguito con due righe di codice.

dettaglio:

① Il metodo di query deve passare 4 parametri:

Oggetto di connessione

Istruzione SQL

L'oggetto della classe di implementazione dell'interfaccia ResultSetHandler (il tipo dell'oggetto convertito deve essere: Student.class)

Parametri per popolare i segnaposto

② L'interfaccia ResultSetHandler viene utilizzata per elaborare i set di risultati. Può convertire i set di risultati interrogati in oggetti Java. Vengono fornite le seguenti quattro classi di implementazione.

Gestore di fagioli	Mappare il set di risultati in un oggetto Java (come l'oggetto Student)
GestoreElencoBean	Mappare il set di risultati in una raccolta List (come: List<Student > )
Gestore di mappe	Mappare il set di risultati in un oggetto di raccolta Map (es: mappa<String,Object> chiave: nome attributo; valore: valore attributo)
GestoreMapList	Mappare il set di risultati in una raccolta MapList (ad esempio: List <Map<<String,Object> >)

③ Il parametro per compilare il segnaposto è un parametro variabile, quindi è possibile passare qualsiasi numero di parametri per soddisfare le diverse esigenze degli utenti.

④ La classe oggetto convertita (classe Studente) deve avere un costruttore senza parametri, altrimenti il programma segnalerà un errore.

motivo:Il livello inferiore trova questa classe tramite Student.class e poi tramitemeccanismo di riflessioneTrova il costruttore senza parametri di questa classe e crea il suo oggetto.

⑤ Il nome dell'attributo nella classe deve essere esattamente uguale al nome del campo nella tabella del database.

Perché dopo la creazione dell'oggetto, quando si assegnano valori alle proprietà dell'oggetto in base al set di risultati, la ricerca e l'assegnazione vengono eseguite in base al nome.

11. Architettura a tre livelli MVC

Cos'è MVC?

Modello: modello (servizio, dao, entità)
Visualizza: Visualizza (jsp, html, client dell'app)
Controller: controller (servlet, hander, azione)

Dopo che la richiesta è entrata nell'applicazione JavaWeb, il Controller riceve la richiesta, esegue l'elaborazione della logica aziendale e infine restituisce il risultato all'utente (Visualizzazione + Modello).

1. Introduzione

Nei primi anni, quando si utilizzavano le applicazioni web, gli utenti accedevano direttamente al livello di controllo e il livello di controllo poteva gestire direttamente il database:

servlet--CRUD (aggiungi, elimina, modifica)-->database

Nel codice servlet: elaborazione di richieste, risposte, salti di visualizzazione, elaborazione JDBC, elaborazione del codice aziendale ed elaborazione del codice logico

Svantaggi:Il programma è molto gonfio e non favorisce la manutenzione

soluzione: Non c'è niente che l'aggiunta di un altro livello non possa risolvere, se c'è, aggiungi un altro livello!

2. architettura a tre livelli mvc

Modello

Elaborazione aziendale: logica aziendale (Servizio)
Livello di persistenza dei dati: CRUD (oggetto di persistenza dei dati DAO)

visualizzazione

mostra dati
Fornire un collegamento per avviare una richiesta Servlet (a, form, img...)

Controllore (servlet)

Ricevi la richiesta dell'utente: (req, parametri di richiesta, informazioni sulla sessione)
Passarlo al livello aziendale per elaborare il codice corrispondente
Controlla il salto della vista

Prendiamo come esempio l'accesso dell'utente e dell'amministratore:

Livello di controllo:


@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");
        }
    }
 
}

Livello di servizio:


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;
    }
}

Livello Dao/Repository:


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;
    }
}

Condivisione della tecnologia