JDBC-02-授课笔记

JDBC深入浅出-jdbc学习笔记【入门到精通】 本文的学习笔记是根据动力节点杜聚宾杜老师,所讲的JDBC教程做的笔记(附源代码分析): 1.JDBC是什么? Java DataBase Connectivity(Java语言连接数据库) 2.JDBC的本质是什么? JDBC是SUN公司制定的一套接口(interface)。 接口都有调用者和实现者。 面向接口调用、面向接口写实现类,这都属于面向接口编程。 3.为什么要面向接口编程? 解耦合:降低程序的耦合度,提高程序的扩展力。 多态机制就是非常典型的:面向抽象编程。(不要面向具体编程) 阅读详情

JDBC-02-授课笔记

一、数据库连接池

1. 数据库连接池的概念
  • 数据库连接背景
    • 数据库连接是一种关键的、有限的、昂贵的资源,这一点在多用户的网页应用程序中体现得尤为突出
    • 对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性,影响到程序的性能指标
    • 数据库连接池正是针对这个问题提出来的
  • 数据库连接池
    • 数据库连接池负责分配、管理和释放数据库连接
    • 它允许应用程序重复使用一个现有的数据库连接,而不是再重新建立一个
    • 这项技术能明显提高对数据库操作的性能
  • 数据库连接池原理
    在这里插入图片描述
2. 自定义连接池
  • java.sql.DataSource接口:数据源(数据库连接池)。java官方提供的数据库连接池规范(接口)
  • 如果想完成数据库连接池技术,就必须实现 DataSource 接口
  • 核心功能:获取数据库连接对象:Connection getConnection();
  • 自定义连接池:
    1. 定义一个类,实现 DataSource 接口。
    2. 定义一个容器,用于保存多个 Connection 连接对象。
    3. 定义静态代码块,通过 JDBC 工具类获取 10 个连接保存到容器中。
    4. 重写 getConnection 方法,从容器中获取一个连接并返回。
    5. 定义 getSize 方法,用于获取容器的大小并返回。
  • 具体实现:
    • 新建java项目jdbc高级,新建libs目录,添加mysql驱动jar包,并且添加引用库
    • 将上个项目的config.properties复制到src中
    • 将上个项目的JDBCUtils复制到com.itheima.utils中
    • 新建数据库连接池类: com.itheima01.MyDataSource,代码如下:
package com.itheima01;

import com.itheima.utils.JDBCUtils;

import javax.sql.DataSource;
import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.logging.Logger;
/*
	自定义连接池类
*/
public class MyDataSource implements DataSource{
    //定义集合容器,用于保存多个数据库连接对象 (创建的是一个线程安全的ArrayList)
    private static List<Connection> pool = Collections.synchronizedList(new ArrayList<Connection>());

    //静态代码块,生成10个数据库连接保存到集合中
    static {// 工具类中,初始化的操作,就可以放入静态代码块(等到当前类第一次被加载的时候,就会执行)
        for (int i = 0; i < 10; i++) {
            Connection con = JDBCUtils.getConnection();
            pool.add(con);
        }
    }

    //返回连接池的大小
    public int getSize() {
        return pool.size();
    }

    //从池中返回一个数据库连接
    @Override
    public Connection getConnection() {
        if(pool.size() > 0) {
            //从池中获取数据库连接
            return pool.remove(0); //注意:从集合中移除一个,并返回(我们每次都是从集合中拿走一个去用,所以是remove,这个方法正好是能够返回移除的这个对象)
        }else {
            throw new RuntimeException("连接数量已用尽");
        }
    }
    
    //剩下的其他方法,我们先不用具体处理

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return null;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return null;
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return false;
    }

    @Override
    public PrintWriter getLogWriter() throws SQLException {
        return null;
    }

    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {

    }

    @Override
    public void setLoginTimeout(int seconds) throws SQLException {

    }

    @Override
    public int getLoginTimeout() throws SQLException {
        return 0;
    }

    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
        return null;
    }
}
3. 自定义连接池测试
  • 测试:通过自定义数据库连接池完成查询学生表的全部信息
  • 具体代码:新建com.itheima01.MyDataSourceTest
package com.itheima01;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class MyDataSourceTest {
    public static void main(String[] args) throws Exception{
        //创建数据库连接池对象
        MyDataSource dataSource = new MyDataSource();

        System.out.println("使用之前连接池数量:" + dataSource.getSize());//10
        
        //获取数据库连接对象
        Connection con = dataSource.getConnection();
        System.out.println(con.getClass());// JDBC4Connection

        //查询学生表全部信息
        String sql = "SELECT * FROM student";
        PreparedStatement pst = con.prepareStatement(sql);
        ResultSet rs = pst.executeQuery();

        while(rs.next()) {
            System.out.println(rs.getInt("sid") + "\t" + rs.getString("name") + "\t" + rs.getInt("age") + "\t" + rs.getDate("birthday"));
        }
        
        //释放资源
        rs.close();
        pst.close();
		//目前的连接对象close方法,是直接关闭连接,而不是将连接归还池中
        con.close();

        System.out.println("使用之后连接池数量:" + dataSource.getSize());
    }
}
4. 归还连接
  • 归还方式:
    1. 继承方式
    2. 装饰设计模式
    3. 适配器设计模式
    4. 动态代理方式
4.1 继承(无法解决)
  1. 继承方式归还数据库连接的思想
  • 通过打印连接对象,发现 DriverManager 获取的连接实现类是 JDBC4Connection
    • JDBC4Connection继承了ConnectionImpl
    • ConnectionImpl实现了MySQLConnection
    • MySQLConnection继承了Connection
    • 所以可以理解:JDBC4Connection就是Connection的一个实现类
  • 那我们就可以自定义一个类,继承 JDBC4Connection 这个类,重写 close() 方法,完成连接对象的归还
  1. 继承方式归还数据库连接的实现步骤

    1. 定义一个类,继承 JDBC4Connection
    2. 定义 Connection 连接对象和连接池容器对象的成员变量
    3. 通过有参构造方法完成对成员变量的赋值
    4. 重写 close 方法,将连接对象添加到池中
  2. 继承方式归还数据库连接存在的问题

  • 通过查看 JDBC 工具类获取连接的方法发现:我们虽然自定义了一个子类,完成了归还连接的操作。
  • 但是 DriverManager 获取的还是 JDBC4Connection 这个对象,并不是我们的子类对象,
  • 而我们又不能整体去修改驱动包中类的功能,所继承这种方式行不通!
  1. 来,我们测试一下:自定义一个类,继承JDBC4Connection这个类,重写close()方法
/*
    自定义Connection类
 */
public class MyConnection1 extends JDBC4Connection {
    //声明连接对象和连接池集合对象
    private Connection con;
    private List<Connection> pool;

    //通过构造方法给成员变量赋值
    public MyConnection1(String hostToConnectTo, int portToConnectTo, Properties info, String databaseToConnectTo, String url,Connection con,List<Connection> pool) throws SQLException {
        super(hostToConnectTo, portToConnectTo, info, databaseToConnectTo, url);
        this.con = con;
        this.pool = pool;
    }

    //重写close()方法,将连接归还给池中
    @Override
    public void close() throws SQLException {
        pool.add(con);
    }
}
  • 但是这种方式行不通,通过查看JDBC工具类获取连接的方法我们发现:我们虽然自定义了一个子类,完成了归还连接的操作。但是DriverManager获取的还是JDBC4Connection这个对象,并不是我们的子类对象。而我们又不能整体去修改驱动包中类的功能!
//将之前的连接对象换成自定义的子类对象
private static MyConnection1 con;

//4.获取数据库连接的方法
public static Connection getConnection() {
    try {
        //等效于:MyConnection1 con = new JDBC4Connection();  语法错误!
        con = DriverManager.getConnection(url,username,password);
    } catch (SQLException e) {
        e.printStackTrace();
    }

    return con;
}
4.2 装饰设计模式
  1. 装饰设计模式归还数据库连接的思想
  • 我们可以自定义一个类,实现 Connection 接口。这样就具备了和 JDBC4Connection 相同的行为了
  • 重写 close() 方法,完成连接的归还。其余的功能还调用 mysql 驱动包实现类原有的方法即可
  • 然后我们可以使用我们自定义的类对JDBC4Connection对象进行包装
  1. 装饰设计模式归还数据库连接的实现步骤
    1. 定义一个类,实现 Connection 接口
    2. 定义 Connection 连接对象和连接池容器对象的成员变量
    3. 通过有参构造方法完成对成员变量的赋值
    4. 重写 close() 方法,将连接对象添加到池中
    5. 剩余方法,只需要调用 mysql 驱动包的连接对象完成即可
    6. 在自定义连接池中,将获取的连接对象通过自定义连接对象进行包装
  2. 装饰设计模式归还数据库连接存在的问题
    • 实现 Connection 接口后,有大量的方法需要在自定义类中进行重写
  3. 实现:自定义连接类
/*
    自定义Connection类。通过装饰设计模式,实现和mysql驱动包中的Connection实现类相同的功能!
    实现步骤:
        1.定义一个类,实现Connection接口
        2.定义Connection连接对象和连接池容器对象的变量
        3.提供有参构造方法,接收连接对象和连接池对象,对变量赋值
        4.在close()方法中,完成连接的归还
        5.剩余方法,只需要调用mysql驱动包的连接对象完成即可
 */
public class MyConnection2 implements Connection {

    //2.定义Connection连接对象和连接池容器对象的变量
    private Connection con;
    private List<Connection> pool;

    //3.提供有参构造方法,接收连接对象和连接池对象,对变量赋值
    public MyConnection2(Connection con,List<Connection> pool) {
        this.con = con;
        this.pool = pool;
    }

    //4.在close()方法中,完成连接的归还
    @Override
    public void close() throws SQLException {
        pool.add(con);
    }


    @Override
    public Statement createStatement() throws SQLException {
        return con.createStatement();
    }

    @Override
    public PreparedStatement prepareStatement(String sql) throws SQLException {
        return con.prepareStatement(sql);
    }

    @Override
    public CallableStatement prepareCall(String sql) throws SQLException {
        return con.prepareCall(sql);
    }

    @Override
    public String nativeSQL(String sql) throws SQLException {
        return con.nativeSQL(sql);
    }

    @Override
    public void setAutoCommit(boolean autoCommit) throws SQLException {
        con.setAutoCommit(autoCommit);
    }

    @Override
    public boolean getAutoCommit() throws SQLException {
        return con.getAutoCommit();
    }

    @Override
    public void commit() throws SQLException {
        con.commit();
    }

    @Override
    public void rollback() throws SQLException {
        con.rollback();
    }

    @Override
    public boolean isClosed() throws SQLException {
        return con.isClosed();
    }

    @Override
    public DatabaseMetaData getMetaData() throws SQLException {
        return con.getMetaData();
    }

    @Override
    public void setReadOnly(boolean readOnly) throws SQLException {
        con.setReadOnly(readOnly);
    }

    @Override
    public boolean isReadOnly() throws SQLException {
        return con.isReadOnly();
    }

    @Override
    public void setCatalog(String catalog) throws SQLException {
        con.setCatalog(catalog);
    }

    @Override
    public String getCatalog() throws SQLException {
        return con.getCatalog();
    }

    @Override
    public void setTransactionIsolation(int level) throws SQLException {
        con.setTransactionIsolation(level);
    }

    @Override
    public int getTransactionIsolation() throws SQLException {
        return con.getTransactionIsolation();
    }

    @Override
    public SQLWarning getWarnings() throws SQLException {
        return con.getWarnings();
    }

    @Override
    public void clearWarnings() throws SQLException {
        con.clearWarnings();
    }

    @Override
    public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
        return con.createStatement(resultSetType,resultSetConcurrency);
    }

    @Override
    public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
        return con.prepareStatement(sql,resultSetType,resultSetConcurrency);
    }

    @Override
    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
        return con.prepareCall(sql,resultSetType,resultSetConcurrency);
    }

    @Override
    public Map<String, Class<?>> getTypeMap() throws SQLException {
        return con.getTypeMap();
    }

    @Override
    public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
        con.setTypeMap(map);
    }

    @Override
    public void setHoldability(int holdability) throws SQLException {
        con.setHoldability(holdability);
    }

    @Override
    public int getHoldability() throws SQLException {
        return con.getHoldability();
    }

    @Override
    public Savepoint setSavepoint() throws SQLException {
        return con.setSavepoint();
    }

    @Override
    public Savepoint setSavepoint(String name) throws SQLException {
        return con.setSavepoint(name);
    }

    @Override
    public void rollback(Savepoint savepoint) throws SQLException {
        con.rollback(savepoint);
    }

    @Override
    public void releaseSavepoint(Savepoint savepoint) throws SQLException {
        con.releaseSavepoint(savepoint);
    }

    @Override
    public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
        return con.createStatement(resultSetType,resultSetConcurrency,resultSetHoldability);
    }

    @Override
    public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
        return con.prepareStatement(sql,resultSetType,resultSetConcurrency,resultSetHoldability);
    }

    @Override
    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
        return con.prepareCall(sql,resultSetType,resultSetConcurrency,resultSetHoldability);
    }

    @Override
    public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
        return con.prepareStatement(sql,autoGeneratedKeys);
    }

    @Override
    public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
        return con.prepareStatement(sql,columnIndexes);
    }

    @Override
    public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
        return con.prepareStatement(sql,columnNames);
    }

    @Override
    public Clob createClob() throws SQLException {
        return con.createClob();
    }

    @Override
    public Blob createBlob() throws SQLException {
        return con.createBlob();
    }

    @Override
    public NClob createNClob() throws SQLException {
        return con.createNClob();
    }

    @Override
    public SQLXML createSQLXML() throws SQLException {
        return con.createSQLXML();
    }

    @Override
    public boolean isValid(int timeout) throws SQLException {
        return con.isValid(timeout);
    }

    @Override
    public void setClientInfo(String name, String value) throws SQLClientInfoException {
        con.setClientInfo(name,value);
    }

    @Override
    public void setClientInfo(Properties properties) throws SQLClientInfoException {
        con.setClientInfo(properties);
    }

    @Override
    public String getClientInfo(String name) throws SQLException {
        return con.getClientInfo(name);
    }

    @Override
    public Properties getClientInfo() throws SQLException {
        return con.getClientInfo();
    }

    @Override
    public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
        return con.createArrayOf(typeName,elements);
    }

    @Override
    public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
        return con.createStruct(typeName,attributes);
    }

    @Override
    public void setSchema(String schema) throws SQLException {
        con.setSchema(schema);
    }

    @Override
    public String getSchema() throws SQLException {
        return con.getSchema();
    }

    @Override
    public void abort(Executor executor) throws SQLException {
        con.abort(executor);
    }

    @Override
    public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {
        con.setNetworkTimeout(executor,milliseconds);
    }

    @Override
    public int getNetworkTimeout() throws SQLException {
        return con.getNetworkTimeout();
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return con.unwrap(iface);
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return con.isWrapperFor(iface);
    }
}
  • 自定义连接池类
public class MyDataSource implements DataSource{
    //定义集合容器,用于保存多个数据库连接对象
    private static List<Connection> pool = Collections.synchronizedList(new ArrayList<Connection>());

    //静态代码块,生成10个数据库连接保存到集合中
    static {
        for (int i = 0; i < 10; i++) {
            Connection con = JDBCUtils.getConnection();
            pool.add(con);
        }
    }

    //返回连接池的大小
    public int getSize() {
        return pool.size();
    }

    //从池中返回一个数据库连接
    @Override
    public Connection getConnection() {
        if(pool.size() > 0) {
            //从池中获取数据库连接
            Connection con = pool.remove(0);
            //通过自定义连接对象进行包装
            MyConnection2 mycon = new MyConnection2(con,pool);
            //返回包装后的连接对象
            return mycon;
        }else {
            throw new RuntimeException("连接数量已用尽");
        }
    }
}
4.3 适配器设计模式
  1. 适配器设计模式归还数据库连接的思想
  • 我们可以提供一个适配器类,实现 Connection 接口,将所有方法进行实现(除了close方法)
  • 自定义连接类只需要继承这个适配器类,重写需要改进的 close() 方法即可
  1. 适配器设计模式归还数据库连接的实现步骤。

    1. 定义一个适配器类,实现 Connection 接口
    2. 定义 Connection 连接对象的成员变量
    3. 通过有参构造方法完成对成员变量的赋值
    4. 重写所有方法(除了 close ),调用mysql驱动包的连接对象完成即可
    5. 定义一个连接类,继承适配器类
    6. 定义 Connection 连接对象和连接池容器对象的成员变量,并通过有参构造进行赋值。
    7. 重写 close() 方法,完成归还连接
    8. 在自定义连接池中,将获取的连接对象通过自定义连接对象进行包装
  2. 适配器设计模式归还数据库连接存在的问题

    • 自定义连接类虽然很简洁了,但适配器类还是我们自己编写的,也比较的麻烦
  3. 适配器类

/*
    适配器抽象类。实现Connection接口。
    实现所有的方法,调用mysql驱动包中Connection连接对象的方法
 */
public abstract class MyAdapter implements Connection {

    // 定义数据库连接对象的变量
    private Connection con;

    // 通过构造方法赋值
    public MyAdapter(Connection con) {
        this.con = con;
    }

    // 所有的方法,均调用mysql的连接对象实现
    @Override
    public Statement createStatement() throws SQLException {
        return con.createStatement();
    }

    @Override
    public PreparedStatement prepareStatement(String sql) throws SQLException {
        return con.prepareStatement(sql);
    }

    @Override
    public CallableStatement prepareCall(String sql) throws SQLException {
        return con.prepareCall(sql);
    }

    @Override
    public String nativeSQL(String sql) throws SQLException {
        return con.nativeSQL(sql);
    }

    @Override
    public void setAutoCommit(boolean autoCommit) throws SQLException {
        con.setAutoCommit(autoCommit);
    }

    @Override
    public boolean getAutoCommit() throws SQLException {
        return con.getAutoCommit();
    }

    @Override
    public void commit() throws SQLException {
        con.commit();
    }

    @Override
    public void rollback() throws SQLException {
        con.rollback();
    }

    @Override
    public boolean isClosed() throws SQLException {
        return con.isClosed();
    }

    @Override
    public DatabaseMetaData getMetaData() throws SQLException {
        return con.getMetaData();
    }

    @Override
    public void setReadOnly(boolean readOnly) throws SQLException {
        con.setReadOnly(readOnly);
    }

    @Override
    public boolean isReadOnly() throws SQLException {
        return con.isReadOnly();
    }

    @Override
    public void setCatalog(String catalog) throws SQLException {
        con.setCatalog(catalog);
    }

    @Override
    public String getCatalog() throws SQLException {
        return con.getCatalog();
    }

    @Override
    public void setTransactionIsolation(int level) throws SQLException {
        con.setTransactionIsolation(level);
    }

    @Override
    public int getTransactionIsolation() throws SQLException {
        return con.getTransactionIsolation();
    }

    @Override
    public SQLWarning getWarnings() throws SQLException {
        return con.getWarnings();
    }

    @Override
    public void clearWarnings() throws SQLException {
        con.clearWarnings();
    }

    @Override
    public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
        return con.createStatement(resultSetType,resultSetConcurrency);
    }

    @Override
    public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
        return con.prepareStatement(sql,resultSetType,resultSetConcurrency);
    }

    @Override
    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
        return con.prepareCall(sql,resultSetType,resultSetConcurrency);
    }

    @Override
    public Map<String, Class<?>> getTypeMap() throws SQLException {
        return con.getTypeMap();
    }

    @Override
    public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
        con.setTypeMap(map);
    }

    @Override
    public void setHoldability(int holdability) throws SQLException {
        con.setHoldability(holdability);
    }

    @Override
    public int getHoldability() throws SQLException {
        return con.getHoldability();
    }

    @Override
    public Savepoint setSavepoint() throws SQLException {
        return con.setSavepoint();
    }

    @Override
    public Savepoint setSavepoint(String name) throws SQLException {
        return con.setSavepoint(name);
    }

    @Override
    public void rollback(Savepoint savepoint) throws SQLException {
        con.rollback(savepoint);
    }

    @Override
    public void releaseSavepoint(Savepoint savepoint) throws SQLException {
        con.releaseSavepoint(savepoint);
    }

    @Override
    public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
        return con.createStatement(resultSetType,resultSetConcurrency,resultSetHoldability);
    }

    @Override
    public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
        return con.prepareStatement(sql,resultSetType,resultSetConcurrency,resultSetHoldability);
    }

    @Override
    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
        return con.prepareCall(sql,resultSetType,resultSetConcurrency,resultSetHoldability);
    }

    @Override
    public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
        return con.prepareStatement(sql,autoGeneratedKeys);
    }

    @Override
    public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
        return con.prepareStatement(sql,columnIndexes);
    }

    @Override
    public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
        return con.prepareStatement(sql,columnNames);
    }

    @Override
    public Clob createClob() throws SQLException {
        return con.createClob();
    }

    @Override
    public Blob createBlob() throws SQLException {
        return con.createBlob();
    }

    @Override
    public NClob createNClob() throws SQLException {
        return con.createNClob();
    }

    @Override
    public SQLXML createSQLXML() throws SQLException {
        return con.createSQLXML();
    }

    @Override
    public boolean isValid(int timeout) throws SQLException {
        return con.isValid(timeout);
    }

    @Override
    public void setClientInfo(String name, String value) throws SQLClientInfoException {
        con.setClientInfo(name,value);
    }

    @Override
    public void setClientInfo(Properties properties) throws SQLClientInfoException {
        con.setClientInfo(properties);
    }

    @Override
    public String getClientInfo(String name) throws SQLException {
        return con.getClientInfo(name);
    }

    @Override
    public Properties getClientInfo() throws SQLException {
        return con.getClientInfo();
    }

    @Override
    public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
        return con.createArrayOf(typeName,elements);
    }

    @Override
    public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
        return con.createStruct(typeName,attributes);
    }

    @Override
    public void setSchema(String schema) throws SQLException {
        con.setSchema(schema);
    }

    @Override
    public String getSchema() throws SQLException {
        return con.getSchema();
    }

    @Override
    public void abort(Executor executor) throws SQLException {
        con.abort(executor);
    }

    @Override
    public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {
        con.setNetworkTimeout(executor,milliseconds);
    }

    @Override
    public int getNetworkTimeout() throws SQLException {
        return con.getNetworkTimeout();
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return con.unwrap(iface);
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return con.isWrapperFor(iface);
    }
}
  • 自定义连接类
/*
    自定义Connection连接类。通过适配器设计模式。完成close()方法的重写
        1.定义一个类,继承适配器父类
        2.定义Connection连接对象和连接池容器对象的变量
        3.提供有参构造方法,接收连接对象和连接池对象,对变量赋值
        4.在close()方法中,完成连接的归还
 */
public class MyConnection3 extends MyAdapter {
    //2.定义Connection连接对象和连接池容器对象的变量
    private Connection con;
    private List<Connection> pool;

    //3.提供有参构造方法,接收连接对象和连接池对象,对变量赋值
    public MyConnection3(Connection con,List<Connection> pool) {
        super(con);    // 将接收的数据库连接对象给适配器父类传递
        this.con = con;
        this.pool = pool;
    }

    //4.在close()方法中,完成连接的归还
    @Override
    public void close() throws SQLException {
        pool.add(con);
    }
}
  • 自定义连接池类
public class MyDataSource implements DataSource{
    //定义集合容器,用于保存多个数据库连接对象
    private static List<Connection> pool = Collections.synchronizedList(new ArrayList<Connection>());

    //静态代码块,生成10个数据库连接保存到集合中
    static {
        for (int i = 0; i < 10; i++) {
            Connection con = JDBCUtils.getConnection();
            pool.add(con);
        }
    }

    //返回连接池的大小
    public int getSize() {
        return pool.size();
    }

    //从池中返回一个数据库连接
    @Override
    public Connection getConnection() {
        if(pool.size() > 0) {
            //从池中获取数据库连接
            Connection con = pool.remove(0);

            //通过自定义连接对象进行包装
            //MyConnection2 mycon = new MyConnection2(con,pool);
            MyConnection3 mycon = new MyConnection3(con,pool);

            //返回包装后的连接对象
            return mycon;
        }else {
            throw new RuntimeException("连接数量已用尽");
        }
    }
}

4.4 动态代理
  • 经过我们适配器模式的改进,自定义连接类中的方法已经很简洁了。剩余所有的方法已经抽取到了适配器类中。

  • 但是适配器这个类还是我们自己编写的,也比较麻烦!所以可以使用动态代理的方式来改进。

  • 动态代理:在不改变目标对象方法的情况下对方法进行增强

    动态代理:(代理律师): 学生原来所有事情都是自己做,现在请了代理律师,所有事情都是由代理律师出面去处理,但真正处理逻辑的,根据invoke内部代码来决定
    
  • 组成

    • 被代理对象:真实的对象
    • 代理对象:内存中的一个对象
  • 要求

  • 代理对象必须和被代理对象实现相同的接口

  • 实现

    • Proxy.newProxyInstance()
    • Proxy:[ˈprɒksi] 代理人
  • 学生案例:

    --接口
    package com.proxy;
    
    public interface StudentInterface {
        void eat(String name);
        void study();
    }
    --学生类
    package com.proxy;
    
    public class Student implements StudentInterface{
        public void eat(String name) {
            System.out.println("学生吃" + name);
        }
    
        public void study() {
            System.out.println("在家自学");
        }
    }
    
    --代理代码
    package com.proxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class Test {
        public static void main(String[] args) {
            Student stu = new Student();
            /*stu.eat("米饭");
            stu.study();*/
    
            /*
                动态代理:代理律师: 学生原来所有事情都是自己做,现在请了代理律师,所有事情都是由代理律师出面去处理,但真正处理逻辑的,根据invoke内部代码来决定
                要求:在不改动Student类中任何的代码的前提下,通过study方法输出一句话:来黑马学习
                类加载器:和被代理对象使用相同的类加载器
                接口类型Class数组:和被代理对象使用相同接口
                代理规则:完成代理增强的功能
             */
            StudentInterface proxyStu = (StudentInterface) Proxy.newProxyInstance(stu.getClass().getClassLoader(),
                    new Class[]{StudentInterface.class}, new InvocationHandler() {
                /*
                    执行Student类中所有的方法都会经过invoke方法
                    对method方法进行判断
                        如果是study,则对其增强
                        如果不是,还调用学生对象原有的功能即可
                 */
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    if(method.getName().equals("study")) {
                        System.out.println("来黑马学习");
    
                        return null;
                    }else {
                        return method.invoke(stu,args);
                    }
                }
            });
    
            proxyStu.eat("米饭");
            proxyStu.study();
    
        }
    }
    
  • 自定义数据库连接池类

public class MyDataSource implements DataSource{
    //定义集合容器,用于保存多个数据库连接对象
    private static List<Connection> pool = Collections.synchronizedList(new ArrayList<Connection>());

    //静态代码块,生成10个数据库连接保存到集合中
    static {
        for (int i = 0; i < 10; i++) {
            Connection con = JDBCUtils.getConnection();
            pool.add(con);
        }
    }

    //返回连接池的大小
    public int getSize() {
        return pool.size();
    }

    //动态代理方式
    @Override
    public Connection getConnection() {
        if(pool.size() > 0) {
            //从池中获取数据库连接
            Connection con = pool.remove(0);

            Connection proxyCon = (Connection)Proxy.newProxyInstance(con.getClass().getClassLoader(), new Class[]{Connection.class}, new InvocationHandler() {
                /*
                    执行Connection实现类所有方法都会经过invoke
                    如果是close方法,则将连接还回池中
                    如果不是,直接执行实现类的原有方法
                 */
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    if(method.getName().equals("close")) {
                        pool.add(con);
                        return null;
                    }else {
                        return method.invoke(con,args);
                    }
                }
            });

            return proxyCon;
        }else {
            throw new RuntimeException("连接数量已用尽");
        }
    }


    //从池中返回一个数据库连接
    /*@Override
    public Connection getConnection() {
        if(pool.size() > 0) {
            //从池中获取数据库连接
            Connection con = pool.remove(0);

            //通过自定义连接对象进行包装
            //MyConnection2 mycon = new MyConnection2(con,pool);
            MyConnection3 mycon = new MyConnection3(con,pool);

            //返回包装后的连接对象
            return mycon;
        }else {
            throw new RuntimeException("连接数量已用尽");
        }
    }*/
}

5. 开源连接池的使用 ***
5.1 C3P0
  • C3P0 数据库连接池的使用步骤:
    1. 导入 jar 包:“day02_jdbc高级\资料\C3P0连接池\c3p0-0.9.5.2.jar 和mchange-commons-java-0.2.12.jar”
    2. 导入配置文件到 src 目录下: “day02_jdbc高级\资料\C3P0连接池\c3p0-config.xml”
      • 修改配置文件中的数据库url,用户名和密码
    3. 创建 C3P0 连接池对象
    4. 获取数据库连接进行使用
    5. 注意:C3P0 的配置文件会自动加载,但是必须叫 c3p0-config.xml 或 c3p0-config.properties 。
  • 基本使用:新建com.itheima03.C3P0Test1
package com.itheima03;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class C3P0Test1 {
    public static void main(String[] args) throws Exception{
        //1.创建c3p0的数据库连接池对象 (combo:组合,pool水池	)
        DataSource dataSource = new ComboPooledDataSource();

        //2.通过连接池对象获取数据库连接
        Connection con = dataSource.getConnection();

        //3.执行操作
        String sql = "SELECT * FROM student";
        PreparedStatement pst = con.prepareStatement(sql);

        //4.执行sql语句,接收结果集
        ResultSet rs = pst.executeQuery();

        //5.处理结果集
        while(rs.next()) {
            System.out.println(rs.getInt("sid") + "\t" + rs.getString("name") + "\t" + rs.getInt("age") + "\t" + rs.getDate("birthday"));
        }

        //6.释放资源
        rs.close();//归还连接
        pst.close();
        con.close();
    }
}
  • 配置演示:
    • 在上个案例中,con.close()是将连接归还了么?我们来测试一下:
    • 新建C3P0Test2
package com.itheima03;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;
import java.sql.Connection;

public class C3P0Test2 {
    public static void main(String[] args) throws Exception{
        //1.创建c3p0的数据库连接池对象
        DataSource dataSource = new ComboPooledDataSource();

        //2.测试
        for(int i = 1; i <= 11; i++) {
            Connection con = dataSource.getConnection();
            System.out.println(i + ":" + con);

            if(i == 5) {//如果没有这段代码,我们循环获取11个连接是会报错的,因为我们配置的最大连接数量是10
                con.close();
            }
        }
    }
}

  • 测试:
    在这里插入图片描述

    • 添加过if判断之后,就不会报错,然后观察到打印的对象,发现第五个和第六个是一个对象
    • 这说明,close之后,连接是还给连接池了,这样第六个才能继续获取40e0这个对象
5.2 Druid
  • druid:['dru:ɪd] ,棉帆布

  • Druid 数据库连接池的使用步骤:

    1. 导入 jar 包:“ day02_jdbc高级\资料\druid-1.0.9\druid-1.0.9.jar”
    2. 编写配置文件,放在 src 目录下 : “day02_jdbc高级\资料\druid-1.0.9\druid.properties”
      • 修改url,用户名和密码
    3. 通过 Properties 集合加载配置文件
    4. 通过 Druid 连接池工厂类获取数据库连接池对象
    5. 获取数据库连接进行使用
    6. 注意:Druid 不会自动加载配置文件,需要我们手动加载,但是文件的名称可以自定义。
  • 基本使用

    • 新建com.itheima04.DruidTest1
package com.itheima04;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;

/*
    1.通过Properties集合,加载配置文件
    2.通过Druid连接池工厂类获取数据库连接池对象
    3.通过连接池对象获取数据库连接进行使用
 */
public class DruidTest1 {
    public static void main(String[] args) throws Exception{
        //获取配置文件的流对象
        InputStream is = DruidTest1.class.getClassLoader().getResourceAsStream("druid.properties");

        //1.通过Properties集合,加载配置文件
        Properties prop = new Properties();
        prop.load(is);

        //2.通过Druid连接池工厂类获取数据库连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

        //3.通过连接池对象获取数据库连接进行使用
        Connection con = dataSource.getConnection();


        String sql = "SELECT * FROM student";
        PreparedStatement pst = con.prepareStatement(sql);

        //4.执行sql语句,接收结果集
        ResultSet rs = pst.executeQuery();

        //5.处理结果集
        while(rs.next()) {
            System.out.println(rs.getInt("sid") + "\t" + rs.getString("name") + "\t" + rs.getInt("age") + "\t" + rs.getDate("birthday"));
        }

        //6.释放资源
        rs.close();
        pst.close();
        con.close();//也是将连接归还
    }
}
  • 抽取工具类com.itheima.utils.DataSourceUtils
package com.itheima.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/*
    数据库连接池的工具类
 */
public class DataSourceUtils {
    //1.私有构造方法
    private DataSourceUtils(){}

    //2.声明数据源变量
    private static DataSource dataSource;

    //3.提供静态代码块,完成配置文件的加载和获取数据库连接池对象
    static{
        try{
            //完成配置文件的加载
            InputStream is = DataSourceUtils.class.getClassLoader().getResourceAsStream("druid.properties");

            Properties prop = new Properties();
            prop.load(is);

            //获取数据库连接池对象
            dataSource = DruidDataSourceFactory.createDataSource(prop);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //4.提供一个获取数据库连接的方法
    public static Connection getConnection() {
        Connection con = null;
        try {
            con = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return con;
    }

    //5.提供一个获取数据库连接池对象的方法
    public static DataSource getDataSource() {
        return dataSource;
    }

    //6.释放资源
    public static void close(Connection con, Statement stat, ResultSet rs) {
        if(con != null) {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(stat != null) {
            try {
                stat.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static void close(Connection con, Statement stat) {
        if(con != null) {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(stat != null) {
            try {
                stat.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

  • 使用工具类

    package com.itheima04;
    
    import com.itheima.utils.DataSourceUtils;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    
    public class DruidTest2 {
        public static void main(String[] args) throws Exception{
            //1.通过连接池工具类获取一个数据库连接
            Connection con = DataSourceUtils.getConnection();
    
            String sql = "SELECT * FROM student";
            PreparedStatement pst = con.prepareStatement(sql);
    
            //2.执行sql语句,接收结果集
            ResultSet rs = pst.executeQuery();
    
            //3.处理结果集
            while(rs.next()) {
                System.out.println(rs.getInt("sid") + "\t" + rs.getString("name") + "\t" + rs.getInt("age") + "\t" + rs.getDate("birthday"));
            }
    
            //4.释放资源
            DataSourceUtils.close(con,pst,rs);
        }
    }
    
5.3 C3P0 与Druid的区别
  • c3p0是一个开放源代码的JDBC连接池,Hibernate的发行包中默认使用此连接池,性能很好

  • Druid是阿里出品,淘宝和支付宝专用数据库连接池,但它不仅仅是一个数据库连接池,它还包含一个
    ProxyDriver,一系列内置的JDBC组件库,一个 SQL Parser。

    • 支持所有JDBC兼容的数据库,包括Oracle、MySql、Derby、Postgresql、SQL Server、H2等等
    • Druid针对Oracle和MySql做了特别优化,比如Oracle的PS Cache内存占用优化,MySql的ping检

    测优化

二、JDBC框架(JDBCTemplate)

1.分析前一天案例中的重复代码
  • dao层的重复代码
    • 定义必要的信息、获取数据库的连接、释放资源都是重复的代码!
    • 而我们最终的核心功能仅仅只是执行一条sql语句而已啊!
    • 所以我们可以抽取出一个JDBC模板类,来封装一些方法(update、query),专门帮我们执行增删改查的sql语句!
    • 将之前那些重复的操作,都抽取到模板类中的方法里。就能大大简化我们的使用步骤!
2.自定义JDBC框架
2.1数据库的源信息
  • DataBaseMetaData(了解):数据库的源信息
    • java.sql.DataBaseMetaData:封装了整个数据库的综合信息
    • 例如:
      • String getDatabaseProductName():获取数据库产品的名称
      • int getDatabaseProductVersion():获取数据库产品的版本号
  • ParameterMetaData:参数的源信息
    • java.sql.ParameterMetaData:封装的是预编译执行者对象中每个参数的类型和属性
    • 这个对象可以通过预编译执行者对象中的getParameterMetaData()方法来获取
    • 核心功能:
      • int getParameterCount():获取sql语句中参数的个数
  • ResultSetMetaData:结果集的源信息
    • java.sql.ResultSetMetaData:封装的是结果集对象中列的类型和属性
    • 这个对象可以通过结果集对象中的getMetaData()方法来获取
    • 核心功能:
      • int getColumnCount():获取列的总数
      • String getColumnName(int i):获取列名
2.2JDBCTemplate类增删改功能的编写
public class JDBCTemplate {
    private DataSource dataSource;
    private Connection con;
    private PreparedStatement pst;
    private ResultSet rs;

    public JDBCTemplate(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    //专用于执行增删改sql语句的方法
    public int update(String sql,Object...objs) {
        int result = 0;

        try{
            con = dataSource.getConnection();
            pst = con.prepareStatement(sql);

            //获取sql语句中的参数源信息
            ParameterMetaData pData = pst.getParameterMetaData();
            //获取sql语句中参数的个数
            int parameterCount = pData.getParameterCount();

            //判断参数个数是否一致
            if(parameterCount != objs.length) {
                throw new RuntimeException("参数个数不匹配");
            }

            //为sql语句中的?占位符赋值
            for (int i = 0; i < objs.length; i++) {
                pst.setObject(i+1,objs[i]);
            }

            //执行sql语句
            result = pst.executeUpdate();

        } catch(Exception e) {
            e.printStackTrace();
        } finally {
            //释放资源
            DataSourceUtils.close(con,pst);
        }

        //返回结果
        return result;
    }
}

2.3JDBCTemplate类查询功能的编写
  • 实体类
/*
    学生实体类
 */
public class Student {
    private Integer sid;
    private String name;
    private Integer age;
    private Date birthday;

    public Student() {
    }

    public Student(Integer sid, String name, Integer age, Date birthday) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public Integer getSid() {
        return sid;
    }

    public void setSid(Integer sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", birthday=" + birthday +
                '}';
    }
}

  • ResultSetHandler接口
/*
    用于处理结果集的接口
 */
public interface ResultSetHandler<T> {
    //处理结果集的抽象方法。
    <T> T handler(ResultSet rs);
}

  • BeanHandler实现类
/*
    实现类1:用于完成将查询出来的一条记录,封装到Student对象中
 */
public class BeanHandler<T> implements ResultSetHandler<T> {
    //1.声明对象类型变量
    private Class<T> beanClass;

    //2.有参构造对变量赋值
    public BeanHandler(Class<T> beanClass) {
        this.beanClass = beanClass;
    }

    /*
        将ResultSet结果集中的数据封装到beanClass类型对象中
     */
    @Override
    public T handler(ResultSet rs) {
        //3.声明对象
        T bean = null;
        try{
            //4.创建传递参数的对象
            bean = beanClass.newInstance();

            //5.判断是否有结果集
            if(rs.next()) {
                //6.得到所有的列名
                //6.1先得到结果集的源信息
                ResultSetMetaData rsmd = rs.getMetaData();
                //6.2还要得到有多少列
                int columnCount = rsmd.getColumnCount();
                //6.3遍历列数
                for(int i = 1; i <= columnCount; i++) {
                    //6.4得到每列的列名
                    String columnName = rsmd.getColumnName(i);
                    //6.5通过列名获取数据
                    Object columnValue = rs.getObject(columnName);

                    //6.6列名其实就是对象中成员变量的名称。于是就可以使用列名得到对象中属性的描述器(get和set方法)
                    PropertyDescriptor pd = new PropertyDescriptor(columnName.toLowerCase(),beanClass);
                    //6.7获取set方法
                    Method writeMethod = pd.getWriteMethod();
                    //6.8执行set方法,给成员变量赋值
                    writeMethod.invoke(bean,columnValue);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

        //7.将对象返回
        return bean;
    }
}

  • BeanListHandler实现类
/*
    实现类2:用于将结果集封装到集合中
 */
public class BeanListHandler<T> implements ResultSetHandler<T> {

    //1.声明对象变量
    private Class<T> beanClass;

    //2.有参构造为变量赋值
    public BeanListHandler(Class<T> beanClass) {
        this.beanClass = beanClass;
    }

    @Override
    public List<T> handler(ResultSet rs) {
        //3.创建集合对象
        List<T> list = new ArrayList<>();

        try{
            //4.遍历结果集对象
            while(rs.next()) {
                //5.创建传递参数的对象
                T bean = beanClass.newInstance();
                //6.得到所有的列名
                //6.1先得到结果集的源信息
                ResultSetMetaData rsmd = rs.getMetaData();
                //6.2还要得到有多少列
                int columnCount = rsmd.getColumnCount();
                //6.3遍历列数
                for(int i = 1; i <= columnCount; i++) {
                    //6.4得到每列的列名
                    String columnName = rsmd.getColumnName(i);
                    //6.5通过列名获取数据
                    Object columnValue = rs.getObject(columnName);

                    //6.6列名其实就是对象中成员变量的名称。于是就可以使用列名得到对象中属性的描述器(get和set方法)
                    PropertyDescriptor pd = new PropertyDescriptor(columnName.toLowerCase(),beanClass);
                    //6.7获取set方法
                    Method writeMethod = pd.getWriteMethod();
                    //6.8执行set方法,给成员变量赋值
                    writeMethod.invoke(bean,columnValue);
                }
                //7.将对象保存到集合中
                list.add(bean);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        //8.返回结果
        return list;
    }
}

  • ScalarHandler实现类
/*
    实现类3:用于返回一个聚合函数的查询结果
 */
public class ScalarHandler<T> implements ResultSetHandler<T> {
    @Override
    public Long handler(ResultSet rs) {
        //1.声明一个变量
        Long value = null;
        try{
            //2.判断是否有结果
            if(rs.next()) {
                //3.获取结果集的源信息
                ResultSetMetaData rsmd = rs.getMetaData();
                //4.获取第一列的列名
                String columnName = rsmd.getColumnName(1);
                //5.根据列名获取值
                value = rs.getLong(columnName);
            }
        } catch(Exception e) {
            e.printStackTrace();
        }
        //6.将结果返回
        return value;
    }
}

  • JDBCTemplate类
public class JDBCTemplate {
    private DataSource dataSource;
    private Connection con;
    private PreparedStatement pst;
    private ResultSet rs;

    public JDBCTemplate(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    
    /*
    	专用于执行聚合函数sql语句的方法
    */
    public Long queryForScalar(String sql, ResultSetHandler<Long> rsh, Object...objs) {
        Long result = null;
        try{
            con = dataSource.getConnection();
            pst = con.prepareStatement(sql);

            //获取sql语句中的参数源信息
            ParameterMetaData pData = pst.getParameterMetaData();
            int parameterCount = pData.getParameterCount();

            //判断参数个数是否一致
            if(parameterCount != objs.length) {
                throw new RuntimeException("参数个数不匹配");
            }

            //为sql语句中的?占位符赋值
            for (int i = 0; i < objs.length; i++) {
                pst.setObject(i+1,objs[i]);
            }

            //执行sql语句
            rs = pst.executeQuery();

            //通过ScalarHandler方式对结果进行处理
            result = rsh.handler(rs);

        } catch(Exception e) {
            e.printStackTrace();
        } finally {
            //释放资源
            DataSourceUtils.close(con,pst,rs);
        }

        //将结果返回
        return result;
    }

    /*
    	专用于查询所有记录sql语句的方法
    */
    public <T> List<T> queryForList(String sql, ResultSetHandler<T> rsh, Object...objs) {
        List<T> list = new ArrayList<>();
        try{
            con = dataSource.getConnection();
            pst = con.prepareStatement(sql);

            //获取sql语句中的参数源信息
            ParameterMetaData pData = pst.getParameterMetaData();
            int parameterCount = pData.getParameterCount();

            //判断参数个数是否一致
            if(parameterCount != objs.length) {
                throw new RuntimeException("参数个数不匹配");
            }

            //为sql语句中的?占位符赋值
            for (int i = 0; i < objs.length; i++) {
                pst.setObject(i+1,objs[i]);
            }

            //执行sql语句
            rs = pst.executeQuery();

            //通过BeanListHandler方式对结果进行处理
            list = rsh.handler(rs);

        } catch(Exception e) {
            e.printStackTrace();
        } finally {
            //释放资源
            DataSourceUtils.close(con,pst,rs);
        }

        //将结果返回
        return list;
    }


    /*
    	专用于执行查询一条记录sql语句的方法
    */
    public <T> T queryForObject(String sql, ResultSetHandler<T> rsh, Object...objs) {
        T obj = null;
        try{
            con = dataSource.getConnection();
            pst = con.prepareStatement(sql);

            //获取sql语句中的参数源信息
            ParameterMetaData pData = pst.getParameterMetaData();
            int parameterCount = pData.getParameterCount();

            //判断参数个数是否一致
            if(parameterCount != objs.length) {
                throw new RuntimeException("参数个数不匹配");
            }

            //为sql语句中的?占位符赋值
            for (int i = 0; i < objs.length; i++) {
                pst.setObject(i+1,objs[i]);
            }

            //执行sql语句
            rs = pst.executeQuery();

            //通过BeanHandler方式对结果进行处理
            obj = rsh.handler(rs);

        } catch(Exception e) {
            e.printStackTrace();
        } finally {
            //释放资源
            DataSourceUtils.close(con,pst,rs);
        }

        //将结果返回
        return obj;
    }
}

2.4测试自定义JDBC框架的使用
public class JDBCTemplateTest {
    //创建JDBCTemplate对象
    JDBCTemplate template = new JDBCTemplate(DataSourceUtils.getDataSource());

    @Test
    public void selectScalar() {
        //查询student表的记录条数
        String sql = "SELECT COUNT(*) FROM student";
        Long count = template.queryForScalar(sql, new ScalarHandler<Long>());
        System.out.println(count);
    }

    @Test
    public void selectAll() {
        //查询所有学生信息
        String sql = "SELECT * FROM student";
        List<Student> list = template.queryForList(sql, new BeanListHandler<Student>(Student.class));
        for(Student stu : list) {
            System.out.println(stu);
        }
    }

    @Test
    public void selectOne() {
        //查询张三这条记录
        String sql = "SELECT * FROM student WHERE sid=?";
        //通过BeanHandler将结果封装成一个Student对象
        Student stu = template.queryForObject(sql, new BeanHandler<Student>(Student.class), 1);
        System.out.println(stu);
    }

    @Test
    public void insert() {
        //新增周七记录
        String sql = "INSERT INTO student VALUES (?,?,?,?)";
        Object[] params = {5,"周七",27,"2007-07-07"};
        int result = template.update(sql, params);
        System.out.println(result);
    }

    @Test
    public void delete() {
        //删除周七这条记录
        String sql = "DELETE FROM student WHERE sid=?";
        int result = template.update(sql, 5);
        System.out.println(result);
    }

    @Test
    public void update() {
        //修改张三的年龄为33
        String sql = "UPDATE student SET age=? WHERE name=?";
        Object[] params = {33,"张三"};
        int result = template.update(sql,params);
        System.out.println(result);
    }
}

Zipformer实战:5分钟快速搭建语音识别模型(附LibriSpeech测试结果) 本文提供了一份详细的Zipformer语音识别模型实战指南。通过清晰的步骤,指导读者在5分钟内完成从环境配置、LibriSpeech数据集准备到模型训练与测试的全过程。文章重点解析了关键配置参数,并分享了在LibriSpeech测试集上的性能结果,帮助开发者快速评估和应用这一高效的语音识别架构。 阅读详情

相关推荐

Android TV远程调试全攻略:从开发者模式开启到ADB连接(附常见问题排查)

本文提供了一份详尽的Android TV远程调试实战指南,涵盖从开启开发者模式、配置网络ADB连接到高效调试与深度排错的完整流程。文章重点解析了通过Wi-Fi进行远程调试的核心步骤,并针对常见的连接失败、授权问题等提供了系统性的解决方案,旨在帮助开发者为Android TV应用开发构建稳定高效的调试环境。

1349

JDBC笔记

JDBC核心技术 第1章:JDBC概述 1.1 数据的持久化 持久化(persistence):把数据保存到可掉电式存储设备中以供之后使用。大多数情况下,特别是企业级应用,数据持久化意味着将内存中的数据保存到硬盘上加以”固化”,而持久化的实现过程大多通过各种关系数据库来完成。 持久化的主要应用是将内存中的数据存储在关系型数据库中,当然也可以存储在磁盘文件、XML数据文件中。 1.2 Java中的数据存储技术 在Java中,数据库存取技术可分为如下几类: JDBC直接访问数据库 J

weixin_45775746的博客 1万+

【Unity】入门教程第一期-下载安装Unity编辑器(下)

讲解如何在Unity Hub中下载Unity编辑器以及IED环境

Xiaoxin的博客 2042

JDBC-01-授课笔记

其实就是java官方提供的一套规范(接口)。用于帮助开发人员快速实现不同关系型数据库的连接!图示: 上图解释:导入jar包 注册驱动 获取连接 获取执行者对象 执行sql语句,并接收返回结果 处理结果 释放资源 创建一个java项目:JDBC基础将jar包导入,并添加到引用类库新建com.itheima01.JDBCDemo01 二、JDBC各个功能类详解 *** 1.DriverManager DriverManager:驱动管理对象注册驱动(告诉程序该使用哪一个数据库驱动

InLoadwetrust的博客 252

ASF-YOLO:一种基于注意尺度序列融合的细胞实例分割YOLO模型

随着样本制备技术和显微成像技术的快速发展,细胞图像的定量处理和分析在医学、细胞生物学等领域发挥着重要作用。基于卷积神经网络(CNN),可以通过神经网络训练学习不同细胞图像的特征信息,具有很强的泛化性能。两阶段的R-CNN系列[1,2,3]及其一阶段变体[4,5]是实例分割任务的经典CNN基础框架。在最近的研究中,You Only Look Once(YOLO)系列[6,7,8,9]已经成为实时实例分割中速度最快、最准确的模型之一。

m0_47867638的博客 9813

Cadence Allegro 17.4学习记录开始01-原理图Capture CIS 17.4

Orcad的学习记录

qq_31444421的博客 1万+

尚硅谷JDBC学习笔记

尚硅谷JDBC学习笔记 文章目录尚硅谷JDBC学习笔记写在前面1. 通过Driver接口获取数据库连接2. 通过DriverManager获取数据库连接3. 通过Statement执行更新操作4. 通过ResultSet执行查询操作5. PreparedStatement6. 利用反射及JDBC元数据编写通用的查询7. DAO设计模式8. JDBC的元数据9. JDBC获取插入记录的主键值10. ...

李英俊小朋友 2690

spyglass之功耗分析

用于功耗分析的软件除了ptpx外,spyglass也可以。ptpx的功耗分析是基于netlist(网表)进行的,一般用于分析综合后的pre功耗和P&R后的post功耗,但这已经是项目进行到比较后期了,如果后期发现功耗数据与我们目标功耗相差较大,则意味着需要功耗优化,这时有可能会将项目计划节点延迟。如果在前期designer可以获得设计模块的功耗数据,可提早优化功耗,spyglass则为designer提供了一个很好的手段去评估功耗,从而提前优化功耗。

u011974971的博客 9208

JDBC学习笔记

JDBC学习

2301_80073794的博客 973

基于STM32L4XX、HAL库的MAX13487EESA RS485总线收发器驱动程序设计

MAX13487EESA是一款3.3V供电的RS-485/RS-422收发器,由Maxim Integrated生产。PA4 (控制引脚) ---> /RE, DE (连接在一起)具有±15kV ESD保护的驱动器输出和接收器输入。半双工RS-485/RS-422通信。工业温度范围:-40°C至+85°C。工作电压范围:3.0V至3.6V。数据速率高达250kbps。

zhusl6688的博客 690

上位机介绍:C# 开发者的必知基础

上位机是指在工业控制系统中,位于上层、负责人机交互和数据管理的计算机/软件,与“下位机”(PLC、传感器、变频器、单片机等硬件设备)相对应,核心是“向下通信控制设备,向上展示交互数据”。下位机:一线干活的“工人”(执行采集、控制指令);上位机:指挥管理的“办公室人员”(发指令、看数据、做报表)。C#开发者掌握上位机开发的核心是“通信+UI+稳定性基础层:搞懂WinForms/WPF基础、串口/Modbus通信,能实现核心功能;进阶层:掌握分层设计、异步编程、工业级容错(断线重连、数据校验);

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 1561

day02JDBC连接池&JDBCTemplate课堂笔记

该笔记是黑马JDBC课程笔记,仅为了方便学习上传,请勿商用。 文章目录1.今日内容2. 数据库连接池1. 概念:其实就是一个容器(集合),存放数据库连接的容器。2. 好处:3. 实现:4. C3P0:数据库连接池技术5. Druid:数据库连接池实现技术,由阿里巴巴提供的(目前性能最好)1. 步骤:2. 定义工具类3.Spring JDBC 数据库连接池 1.今日内容 1. 数据库连接池 2....

H.千面的博客 363

【Unity】【WebRTC】如何用Unity而不是浏览器接收远程画面

之前几篇我们讨论了如何设置信令服务器,如何发送画面给远端以及如何用浏览器查看同步画面,今天来讨论如何实现Unity内部接收画面。看本篇之前请先看过之前将web服务器设置和基本远程画面功能的几篇博文。在Unity编辑器中打开一个示例项目,点击BroadCast按钮。4. 再点击Receiver按钮,Start。Build一个示例项目,并运行这个项目。启动Web.app。

每日出拳老爷子的博客 1722

JDBC学习笔记02

JDBC学习笔记02

少年有事问春风 405

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

JDBC自用笔记

JDBC(Java DataBase Connectivity):Java语言连接数据库的一套API,可以实现用Java语言操作数据库。API(Application Programming Interface):应用程序编程接口,是一套类库。API包括:API字节码(String.class),API源码(String.java),API帮助文档。注意:API版本要一致。//封装员工信息,被称为bean或者pojo类,也就是普通的java类return id;

2202_75362371的博客 1065

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

JavaWeb笔记:JDBC总结

JavaWeb笔记:JDBC总结 目录 JavaWeb笔记:JDBC总结 一、JDBC概述 二、开发一个JDBC程序(重要) 三、JDBC常用的类和接口详解 1、java.sql.Drivermanager类 : 创建连接 2、java.sql.Connection接口:一个连接 3、java.sql.Statement接口: 操作sql语句,并返回相应结果的对象(小货车) 4、...

岁月求索 1071

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

day01JDBC课堂笔记

该笔记是黑马JDBC课程笔记,仅为了方便学习上传,请勿商用。 文章目录1. 今日内容2. JDBC:1. 概念:2. 快速入门:3. 详解各个对象:1. DriverManager:驱动管理对象2. Connection:数据库连接对象3. Statement:执行sql的对象4. ResultSet:结果集对象,封装查询结果5. PreparedStatement:执行sql的对象3.抽取JDB...

H.千面的博客 639

Web 02 - JDBC

JDBC(Java Database Connectivity,Java 数据库连接)是使用 Java 语言操作关系型数据库一套 API 规范。JDK 仅提供这些规范接口,具体实现需要依赖不同数据库厂商的数据库驱动,称为 JDBC 驱动或者 Jar 包。不同数据库厂商使用相同的接口,Java 代码不需要针对不同数据库分别开发。使用同一套 Java 代码,操作不同的关系型数据库。

m0_65735686的博客 2050

[JDBC学习笔记] JDBC

摘要:JDBC是Java操作关系型数据库的标准API,通过定义统一的接口实现不同数据库的兼容操作。主要流程包括注册驱动、获取连接、执行SQL等步骤。核心API包括DriverManager(驱动管理)、Connection(连接对象)、Statement(SQL执行)和ResultSet(结果集)。PreparedStatement可预防SQL注入,提高安全性。数据库连接池(如Druid)通过复用连接提高性能,需配置DataSource获取连接。JDBC简化了Java与数据库的交互,实现了代码与数据库的解耦

qq_58547683的博客 960

02 JDBC

JDBC概念(1)JDBC 就是使用Java语言操作关系型数据库的一套API(2)全称:( Java DataBase Connectivity ) Java 数据库连接JDBC本质官方(sun公司)定义的一套操作所有关系型数据库的规则,即接口各个数据库厂商去实现这套接口,提供数据库驱动jar包我们可以使用这套接口(JDBC)编程,真正执行的代码是驱动jar包中的实现类JDBC好处各数据库厂商使用相同的接口,Java代码不需要针对不同数据库分别开发。

weixin_62504976的博客 728

我的JDBC学习笔记-02

JDBC学习笔记-02 若使用 Statement st = conn.createStatement(); #则会有sql注入的问题 由图可见,即使输入的密码不对,程序仍然识别为正确 此时就是 恶意地对sql语句注入使其跳过验证,直接登录 为了避免出现这种情况,我们使用 String sql ="insert into users values (?,?,?)"; ...

qq_42002553的博客 300

02JDBC

Statement对象的作用就是用来执行SQL语句。而针对不同类型的SQL语句使用的方法也不一样。执行DDL、DML语句执行DQL语句封装了SQL查询语句的结果。ResultSet executeQuery(sql) :执行DQL 语句,返回 ResultSet 对象那么我们就需要从ResultSet对象中获取我们想要的数据。ResultSet对象提供了操作查询结果数据的方法,如下:将光标从当前位置向前移动一行判断当前行是否为有效行true : 有效航,当前行有数据。

路小飞 1839

JDBC超详细笔记

本文从基础到高级再到实战,由浅入深,把MySQL讲的清清楚楚,明明白白,这应该是我目前为止看到过最好的有关MySQL的学习笔记了,我相信如果你把这份笔记认真看完后,无论是工作中碰到的问题还是被面试官问到的问题都能迎刃而解!MySQL50道高频面试题整理:《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门,即可获取!11.3 测试类// 当前系统时间//自定义一个时间//日期转换将字符串转为 java.util.Date。

2401_84091544的博客 976

Java开发 - 尚硅谷JDBC学习笔记

JDBC是Java连接数据库技术的统称JDBC是由两部分组成的:Java提供的jdbc规范(接口)各个数据库厂商实现的驱动jar包JDBC技术是一种典型的面向接口编程JDBC是的缩写,直译为Java数据库连接JDBC是Java程序连接数据库的技术统称JDBC由Java语言的规范(接口)和各个数据库厂商的实现驱动(jar包)组成性能提升级。官方表示MySQL 8.0 的速度要比 MySQL 5.7 快 2 倍。

codeLearnerEternally的博客 2468

Sharding-JDBC笔记02-Sharding-JDBC执行原理

本章着重介绍Sharding-JDBC执行原理

weixin_46425661的博客 992
上一篇: JDBC-01-授课笔记
下一篇: mybatis-第1天讲义
InLoadwetrust
博客等级 码龄6年 11粉丝 84原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

InLoadwetrust

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值