JavaWeb (3: JDBC und MVC)

JDBC ist ein von einer bestimmten Datenbank unabhängiges Verwaltungssystem und eine öffentliche Schnittstelle für den universellen Zugriff und Betrieb von SQL-Datenbanken.

Definiert eine Reihe von Standards, um eine einheitliche Möglichkeit für den Zugriff auf verschiedene Datenbanken bereitzustellen.

JDBC ist eine Anwendungs-API für den Datenbankzugriff, die aus einer Reihe von Klassen und Schnittstellen besteht, die in der Java-Sprache geschrieben sind.

Beinhaltet zwei Ebenen:

① Anwendungsorientierte API zum Aufrufen durch Programmierer.

② Datenbankorientierte API für Hersteller zur Entwicklung von Datenbanktreibern.

Um verschiedene Datenbanken mit JDBC zu verbinden, müssen Sie lediglich verschiedene Datenbanktreiberpakete laden und müssen sich keine Gedanken über die Unterschiede in den Datenbankbetriebssprachen machen.

2.Schreiben Sie ein JDBC-Programm

① Datenbanktabelle erstellen


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;

② Datenbankabhängigkeiten importieren


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

③ Verwendung von JDBC:

Ⅰ Laden Sie den Datenbanktreiber (die Brücke zwischen dem Java-Programm und der Datenbank).

Ⅱ. Verbindung herstellen, eine Verbindung zwischen dem Java-Programm und der Datenbank

Ⅲ. Erstellen Sie ein Statement-Objekt, das von Connection generierte SQL-Anweisungen an die Datenbank sendet

Ⅳ Schreiben Sie SQL-Anweisungen (schreiben Sie je nach Unternehmen unterschiedliche SQLs).

Ⅴ Führen Sie SQL aus (wenn Sie den Rückgabewert erhalten möchten, erstellen Sie ein ResultSet-Objekt, um die Abfrageergebnisse zu speichern, nachdem die Anweisung ausgeführt wurde)

Ⅵ Schließen Sie die Verbindung


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. Detaillierte Analyse

(1) Datenbank-URL

jdbc:mysql://localhost:3306/xxx

jdbc	Protokoll
MySQL	Unterprotokoll
lokaler Host: 3306	host:port
xxx	Datenbank

So schreiben Sie häufig verwendete Datenbank-URL-Adressen:

Oracle-Schreiben: jdbc:oracle:thin:@localhost:1521:xxx
SqlServer-Name: jdbc:microsoft:sqlserver://localhost:1433; DatabaseName=xxx
MySQL-Schreibmethode: jdbc:mysql://localhost:3306/xxx

(2) Verbindungsklasse

Die Verbindung wird zur Darstellung von Datenbankverknüpfungen verwendet, und die Sammlung ist das wichtigste Objekt in der Datenbankprogrammierung.

Alle Interaktionen zwischen dem Client und der Datenbank werden über das Verbindungsobjekt abgeschlossen., gängige Methoden dieses Objekts:

Anweisung erstellen()	Erstellen Sie ein Anweisungsobjekt, das SQL an die Datenbank sendet
bereiten SieStatement(sql) vor	Erstellen Sie ein PrepareSatement-Objekt, das vorkompiliertes SQL an die Datenbank sendet
setAutoCommit(boolean autoCommit)	Legen Sie fest, ob Transaktionen automatisch festgeschrieben werden
begehen()	Senden Sie die Transaktion über den Link
Rollback()	Rollback-Transaktion über diesen Link

(3) Anweisungsklasse

Das Statement-Objekt wird zum Senden von SQL-Anweisungen an die Datenbank verwendet. Allgemeine Methoden des Statement-Objekts:

Abfrage ausführen(String sql)	Wird verwendet, um Abfrageanweisungen an Daten zu senden und eine ResultSet-Ergebnismenge zurückzugeben
führeUpdate aus (String sql)	Wird verwendet, um Einfügungs-, Aktualisierungs- oder Löschanweisungen an die Datenbank zu senden und die Anzahl der in der Datenbank aktualisierten Zeilen zurückzugeben
ausführen(String sql)	Wird verwendet, um beliebige SQL-Anweisungen an die Datenbank zu senden
addBatch(String sql)	Fügen Sie mehrere SQL-Anweisungen in einen Stapel ein
führeBatch() aus	Senden Sie einen Stapel SQL-Anweisungen zur Ausführung an die Datenbank

Beachten:

Um die Betriebseffizienz zu verbessern, wird die Ausführungsmethode im Allgemeinen nicht direkt verwendet.

Verwenden Sie sie stattdessen entsprechend: „executeQuery“ für Abfragen; „executeUpdate“ für Hinzufügungen, Löschungen und Änderungen.

(4) ResultSet-Klasse

ResultSet wird verwendet, um die Ausführungsergebnisse von SQL-Anweisungen darzustellen.

Ergebnismenge Verwenden Sie beim Kapseln des Ausführungsergebnissatzesähnlich wie bei TischDer Weg。

Das ResultSet-Objekt verwaltet einen Cursor, der auf die Tabellendatenzeilen zeigt.Der Cursor befindet sich zunächst vor der ersten Zeile。

Durch Aufrufen der Methode ResultSet.next () kann der Cursor auf eine bestimmte Datenzeile zeigen und die Methode getxxx aufrufen, um die Daten dieser Zeile abzurufen.

① Holen Sie sich jede Art von Daten

getObject(int-Index)	Rufen Sie das Objektobjekt entsprechend der angegebenen Anzahl von Spalten ab
getObject(Zeichenfolge Spaltenname)	Rufen Sie das Objektobjekt gemäß dem angegebenen Attributnamen ab

② Rufen Sie Daten des angegebenen Typs ab, z. B. den String-Typ

getString(int index)	Rufen Sie ein String-Objekt basierend auf der angegebenen Anzahl von Spalten ab
getString(String Spaltenname)	Rufen Sie das String-Objekt gemäß dem angegebenen Attributnamen ab

③ So scrollen Sie durch die Ergebnismenge:

nächste()	Zur nächsten Zeile wechseln
Vorherige()	Zur vorherigen Zeile wechseln
absolut (int Zeile)	Zur angegebenen Zeile wechseln
vorErstes()	Verschieben Sie die Vorderseite von resultSet
nachLetztem()	Zum Ende von resultSet wechseln

(5) Ressourcen freigeben

Denken Sie nach Abschluss der Ausführung des JDBC-Programms daran, die vom Programm erstellten Objekte für die Interaktion mit der Datenbank während des laufenden Prozesses freizugeben.

Diese Objekte sind normalerweise ResultSet-, Statement- und Connection-Objekte.

Insbesondere das Connection-Objekt ist eine sehr seltene Ressource und muss sofort nach der Verwendung freigegeben werden.

Wenn die Verbindung nicht zeitnah und korrekt geschlossen werden kann, kann es leicht zu Systemausfällen kommen.

Um sicherzustellen, dass der Ressourcenfreigabecode ausgeführt werden kann, muss der Ressourcenfreigabecode auch in der final-Anweisung platziert werden.

4.SQL-Injection-Problem

Bei der Verwendung von Statement für die Entwicklung gibt es zwei Probleme:

① String-Strings müssen häufig gespleißt werden und die Fehlerrate ist hoch


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

② Es besteht die potenzielle Gefahr einer SQL-Injection

SQL-Injection: Einfügen illegaler SQL-Anweisungen in die vom Benutzer eingegebenen Daten unter Verwendung cleverer Techniken zum Zusammenfügen von Zeichenfolgen, was zu einem SQL-Kurzschluss führt und dadurch Datenbankdaten stiehlt.


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

Operationsergebnis:

Beachten:

Die Priorität von und in der SQL-Anweisung ist größer als oder, daher entspricht die ausgeführte SQL der Auswahl * von Benutzern, wobei '1' = '1';

Lösung:Verwenden Sie PreparedStatement, eine Unterklasse von Statement, die die Funktion eines SQL-Platzhalters bereitstellt.

Es ist nicht erforderlich, Zeichenfolgen zu verbinden, und die vom Benutzer eingegebenen Daten werden vollständig erkannt, was die Sicherheit erhöht.


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

Operationsergebnis:

5.JDBC-Transaktionen

Eine Transaktion bezieht sich auf eine logische Reihe von Vorgängen, die entweder alle erfolgreich oder alle erfolglos sind (ACID-Prinzip).

Wenn das JDBC-Programm ein Verbindungsobjekt aus der Datenbank erhält, sendet das Verbindungsobjekt standardmäßig automatisch eine Transaktion an die Datenbank.

Wenn Sie diese Standardübermittlungsmethode deaktivieren und die Ausführung mehrerer SQLs in einer Transaktion zulassen möchten, können Sie die folgende JDBC-Steuertransaktionsanweisung verwenden.

Verbindung.setAutoCommit(false);	Transaktion starten
Verbindung.rollback();	Rollback-Transaktion
Verbindung.commit();	Transaktion festschreiben

① Kontotabelle erstellen


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

② Simulieren Sie das Geschäftsszenario, wenn die Übertragung erfolgreich ist


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

Bei unterschiedlichen Anforderungen müssen Sie jedes Mal eine Verbindung zur Datenbank herstellen und Ressourcen freigeben, und es wird viel wiederholter Code geschrieben.

Kapseln Sie die Vorbereitungs- und Freigabevorgänge für die Datenbankverbindung in einer Toolklasse und rufen Sie sie direkt auf, wenn Sie sie verwenden, um das Schreiben wiederholten Codes zu vermeiden.


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

Anruffall, z. B.: Benutzer hinzufügen


 
    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. Datenbankverbindungspool

(1. Übersicht

JDBC-Entwicklungsprozess:

Ⅰ Laden Sie den Datenbanktreiber (muss nur einmal geladen werden)

Ⅱ Datenbankverbindung herstellen (Verbindung)

Ⅲ. Erstellen Sie ein Statement-Objekt, das von Connection generierte SQL-Anweisungen an die Datenbank sendet

Ⅳ. SQL-Anweisungen schreiben

Ⅴ. SQL ausführen (Query-->ResultSet-Objekt empfängt Ergebnismenge)

Ⅵ. Schließen Sie die Verbindung und geben Sie Ressourcen frei

Das Datenbankverbindungsobjekt wird über DriverManager abgerufen. Bei jedem Abruf müssen Sie eine Verbindung zur Datenbank herstellen und den Benutzernamen und das Kennwort überprüfen.

Benutzer müssen für jede Anfrage einen Link von der Datenbank erhalten, und das Erstellen einer Verbindung zur Datenbank verbraucht normalerweise relativ große Ressourcen und dauert lange.

Jedes Mal, wenn die SQL-Anweisung ausgeführt wird, wird die Verbindung getrennt, was zu einer Verschwendung von Ressourcen führt und die Datenbankverbindungsressourcen nicht ordnungsgemäß wiederverwendet werden.

Unter der Annahme, dass die Website 100.000 Besuche pro Tag erhält, muss der Datenbankserver 100.000 Verbindungen herstellen, was eine enorme Verschwendung von Datenbankressourcen darstellt und leicht zu einem Speicherüberlauf des Datenbankservers und einer Maschinenerweiterung führen kann.

Lösung: Datenbankverbindungspool

Die Grundidee des Datenbankverbindungspools:

Richten Sie einen Pufferpool für die Datenbank ein und stellen Sie im Voraus eine bestimmte Anzahl von Verbindungsobjekten in den Pufferpool.

Wenn Sie eine Datenbankverbindung herstellen möchten, müssen Sie nur ein Objekt aus dem Pufferpool entnehmen.

Legen Sie es nach der Verwendung für die nächste Anforderung wieder in den Pufferpool zurück, um eine Wiederverwendung der Ressourcen zu erreichen, ohne dass eine wiederholte Erstellung erforderlich ist.

Wenn im Datenbankverbindungspool keine inaktiven Verbindungsobjekte vorhanden sind, werden neue Anforderungen in die Warteschlange gestellt und warten darauf, dass andere Threads die Verbindung freigeben.

(2) Verwendung

Der Datenbankverbindungspool von JDBC wird über die Schnittstelle javax.sql.DataSource vervollständigt. DataSource ist die offiziell von Java bereitgestellte Schnittstelle.

Bei der Nutzung müssen Entwickler die Schnittstelle nicht selbst implementieren und können Tools von Drittanbietern nutzen.

C3P0 ist eine häufig verwendete Implementierung von Drittanbietern. In der tatsächlichen Entwicklung kann C3P0 direkt verwendet werden, um den Betrieb des Datenbankverbindungspools abzuschließen.

Schritte zur Nutzung:

① Abhängigkeiten in pom.xml importieren


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

② Code schreiben


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

Beachten:

Verbindung wird über die herkömmliche Methode erhalten: com.mysql.cj.jdbc.ConnectionImpl@3c153a1

Von C3P0 erhaltene Verbindung: com.mchange.v2.c3p0.impl.NewProxyConnection@6156496

Also,Obwohl sie alle die Close-Methode aufrufen, sind die Implementierungsklassen unterschiedlich, sodass auch das Umschreiben der Methode unterschiedlich ist. Dies ist Schnittstellenpolymorphismus.。

Die Methode close in C3P0 zerstört die Verbindungsressource nicht direkt, sondern gibt die Verbindung an den Datenbankverbindungspool zurück.

Die obige Methode zum Festlegen von Parametern für den Datenbankverbindungspool wird direkt in das Java-Programm geschrieben.

Dies wird übernommenHardcodeDer Weg,Jedes Mal, wenn Sie die Konfiguration ändernMuss neu kompiliert werden, neue Klassendateien generieren, die Effizienz ist zu gering。

In der tatsächlichen Entwicklung werden die Konfigurationsinformationen von C3P0 in einer XML-Datei definiert, und das Java-Programm muss nur die Konfigurationsdatei laden, um den Initialisierungsvorgang des Datenbankverbindungspools abzuschließen.

Anschließend müssen Sie nur noch die Konfiguration ändern und die Konfiguration in XML ändern, ohne sie neu zu kompilieren.

Schritte zur Nutzung:

① Erstellen Sie im Ressourcenverzeichnis eine neue Datei mit dem Namen c3p0-config.xml

② Geben Sie die Konfigurationsinformationen in c3p0-config.xml ein:


<?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>

③Schreiben Sie ein Java-Programm


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

Beachten:

① Der Parameter in der Konstruktionsmethode ComboPooledDataSource ist der Namensattributwert des in c3p0-config.xml konfigurierten Tags „named-config“.

② Zu diesem Zeitpunkt kann die JDBC-Toolklasse wie folgt geändert werden:


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

Im obigen Code sind die Vorgänge zum Füllen der Platzhalter mit Daten und zum Extrahieren der Daten aus der Ergebnismenge zu umständlich.

Wenn die Student-Tabelle 100 Attribute enthält, müssen wir 100 Zeilen in die while-Schleife schreiben, um die Daten abzurufen, und möglicherweise sind auch viele Zeilen erforderlich, um die Platzhalter auszufüllen.

Lösung:DBUtils können Entwicklern dabei helfen, die Datenkapselung abzuschließen (Zuordnung von Ergebnismengen zu Java-Objekten).

Schritte zur Nutzung:

① Abhängigkeiten in pom.xml importieren


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

② Code schreiben


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

An diesem Punkt kann das Füllen der Platzhalter und das Herausnehmen der Ergebnismenge mit zwei Codezeilen erfolgen.

Detail:

① Die Abfragemethode muss 4 Parameter übergeben:

Verbindungsobjekt

SQL-Anweisung

Das Implementierungsklassenobjekt der ResultSetHandler-Schnittstelle (der Typ des konvertierten Objekts muss sein: Student.class)

Parameter zum Füllen von Platzhaltern

② Die ResultSetHandler-Schnittstelle wird zur Verarbeitung von Ergebnismengen verwendet. Sie kann die abgefragten Ergebnismengen in Java-Objekte konvertieren.

BeanHandler	Ordnen Sie die Ergebnismenge einem Java-Objekt zu (z. B. einem Student-Objekt).
BeanListHandler	Ordnen Sie die Ergebnismenge einer Listensammlung zu (z. B. List<Student > )
Kartenhandler	Ordnen Sie die Ergebnismenge einem Map-Sammlungsobjekt zu (dh: Karte<String,Object> Schlüssel: Attributname; Wert: Attributwert)
MapListHandler	Ordnen Sie die Ergebnismenge einer MapList-Sammlung zu (z. B. List <Map<<String,Object> >)

③ Der Parameter zum Ausfüllen des Platzhalters ist ein variabler Parameter, sodass eine beliebige Anzahl von Parametern übergeben werden kann, um den unterschiedlichen Anforderungen der Benutzer gerecht zu werden.

④ Die konvertierte Objektklasse (Student-Klasse) muss über einen Konstruktor ohne Parameter verfügen, andernfalls meldet das Programm einen Fehler.

Grund:Die unterste Ebene findet diese Klasse über Student.class und dann überReflexionsmechanismusSuchen Sie den parameterlosen Konstruktor dieser Klasse und erstellen Sie sein Objekt.

⑤ Der Name des Attributs in der Klasse muss genau mit dem Namen des Felds in der Datenbanktabelle übereinstimmen.

Denn nachdem das Objekt erstellt wurde, werden beim Zuweisen von Werten zu den Objekteigenschaften basierend auf der Ergebnismenge die Suche und Zuweisung basierend auf dem Namen durchgeführt.

11. Dreistufige MVC-Architektur

Was ist MVC?

Modell: Modell (Dienst, Dao, Entität)
Ansicht: Ansicht (JSP, HTML, App-Client)
Controller: Controller (Servlet, Hander, Aktion)

Nachdem die Anforderung in die JavaWeb-Anwendung gelangt ist, empfängt der Controller die Anforderung, führt eine Geschäftslogikverarbeitung durch und gibt schließlich das Ergebnis an den Benutzer zurück (Ansicht + Modell).

1. Einleitung

In den Anfangsjahren griffen Benutzer beim Betrieb von Webanwendungen direkt auf die Steuerungsschicht zu, und die Steuerungsschicht konnte die Datenbank direkt betreiben:

Servlet--CRUD (Hinzufügen, Löschen, Ändern)-->Datenbank

Im Servlet-Code: Verarbeitung von Anforderungen, Antworten, Ansichtssprüngen, JDBC-Verarbeitung, Geschäftscodeverarbeitung und Logikcodeverarbeitung

Nachteile:Das Programm ist sehr aufgebläht und nicht wartungsfreundlich

Lösung: Es gibt nichts, was das Hinzufügen einer weiteren Ebene nicht lösen kann. Wenn ja, fügen Sie eine weitere Ebene hinzu!

2. Dreistufige MVC-Architektur

Modell

Geschäftsverarbeitung: Geschäftslogik (Service)
Datenpersistenzschicht: CRUD (DAO-Datenpersistenzobjekt)

Sicht

Anzeigedaten
Geben Sie einen Link zum Initiieren einer Servlet-Anfrage an (a, form, img...)

Controller (Servlet)

Benutzeranforderung empfangen: (Anforderung, Anforderungsparameter, Sitzungsinformationen)
Übergeben Sie es an die Business-Schicht, um den entsprechenden Code zu verarbeiten
Ansichtssprung steuern

Nehmen Sie als Beispiel die Benutzer- und Administratoranmeldung:

Controller-Ebene:


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

Serviceschicht:


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

Dao/Repository-Ebene:


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

Technologieaustausch