【Java】连接池与DBUtils的使用

已于 2022-04-18 18:34:13 修改
阅读量875 收藏
点赞数
分类专栏： Java日记 Java ee 文章标签： java java-ee
于 2022-04-18 18:20:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48131807/article/details/124249138
版权

目录

1.为什么要使用连接池

2.自定义连接池-初级版本

3.自定义连接池-进阶版本

4.装饰者模式

5.自定义连接池-终极版本

6.C3P0连接池

1.通过硬编码来编写【了解】

2.通过配置文件来编写

3.使用c3p0改写工具类

7.DRUID连接池

1.通过硬编码方式【了解】

2.通过配置文件方式

3.Druid工具类的制作

8.DBUtils完成增删改

9.DBUtils完成查询

查询一条记录(使用ArrayHandler,使用BeanHandler,使用MapHandler)

查询多条数据封装到List集合中(使用ArrayListHandler,使用BeanListHandler,使用MapListHandler)

查询单个数据(使用ScalarHandler())

查询单列多个值(使用ColumnListHandler)

10.元数据

参数元数据

结果集元素数据

11.自定义DBUtils增删改

1.为什么要使用连接池

Connection对象在JDBC使用的时候就会去创建一个对象,使用结束以后就会将这个对象给销毁了(close).每次创建和销毁对象都是耗时操作.需要使用连接池对其进行优化.

程序初始化的时候，初始化多个连接,将多个连接放入到池(集合)中.每次获取的时候,都可以直接从连接池中进行获取.使用结束以后,将连接归还到池中.

  1. 程序一开始就创建一定数量的连接，放在一个容器(集合)中，这个容器称为连接池。

  2. 使用的时候直接从连接池中取一个已经创建好的连接对象, 使用完成之后 归还到池子

  3. 如果池子里面的连接使用完了, 还有程序需要使用连接, 先等待一段时间(eg: 3s), 如果在这段时间之内有连接归还, 就拿去使用; 如果还没有连接归还, 新创建一个, 但是新创建的这一个不会归还了(销毁)

  4. 集合选择LinkedList

    • 增删比较快

    • LinkedList里面的removeFirst()和addLast()方法和连接池的原理吻合

2.自定义连接池-初级版本

  • 创建连接池类

  • 在连接池类中,定义一个LinkedList集合(表示连接池)

  • 在连接池类的静态代码块中,创建固定数量的连接,并存储到LinkedList集合中

  • 提供一个公共的非静态方法来获取连接对象(getAbc)

  • 提供一个公共的非静态方法来归还连接对象(addBack)

  • 提供一个公共的静态方法来获取连接池中连接的数量

package com.jcli.demo02_自定义连接池初级版;

import com.jcli.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.LinkedList;

/**
 * - 创建连接池类
 */
public class MyDataSource01 {
    //- 在连接池类中,定义一个LinkedList集合(表示连接池)
    private static LinkedList<Connection> pools = new LinkedList<>();

    //- 在连接池类的静态代码块中,创建固定数量的连接,并存储到LinkedList集合中
    static {
        for (int i = 0; i < 6; i++) {
            try {
                //获得连接
                Connection connection = JDBCUtils.getConnection();
                //把连接添加到连接池
                pools.add(connection);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    //- 提供一个公共的非静态方法来获取连接对象(getAbc)
    public Connection getAbc() {
        Connection connection = pools.removeFirst();
        return connection;
    }

    //- 提供一个公共的非静态方法来归还连接对象(addBack)
    public void addBack(Connection connection) {
        pools.addLast(connection);
    }

    //- 提供一个公共的静态方法来获取连接池中连接的数量
    public static int size() {
        return pools.size();
    }
}

测试：

// 1.创建连接池对象
// 2.获得连接
// 3.预编译sql语句,得到预编译对象
// 4.设置参数
// 5.执行sql语句,处理结果
// 取数据
// 6.归还连接
// 7.释放资源

package com.jcli.demo02_自定义连接池初级版;

import com.jcli.utils.JDBCUtils;

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

public class Test {
    public static void main(String[] args) throws SQLException {
        // 1.创建连接池对象
        MyDataSource01 dataSource01 = new MyDataSource01();
        System.out.println("获得连接之前:"+MyDataSource01.size());
        // 2.获得连接
        Connection connection = dataSource01.getAbc();
        System.out.println("获得连接之后:"+MyDataSource01.size());
        // 3.预编译sql语句,得到预编译对象
        String sql = "select * from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);
        // 4.设置参数
        ps.setInt(1,1);
        // 5.执行sql语句,处理结果
        ResultSet resultSet = ps.executeQuery();
        // 取数据
        while (resultSet.next()){
            int id = resultSet.getInt("id");
            String username = resultSet.getString("username");
            String password = resultSet.getString("password");
            String nickname = resultSet.getString("name");
        }
        System.out.println("归还连接之前:"+MyDataSource01.size());
        // 6.归还连接
        dataSource01.addBack(connection);
        System.out.println("归还连接之后:"+MyDataSource01.size());
        // 7.释放资源
        JDBCUtils.release(resultSet,ps,null);
    }
}

3.自定义连接池-进阶版本

实现接口DataSource，重写获取方法getConnection

  • 创建连接池类, 实现DataSource接口,重写方法

  • 在连接池类中,定义一个LinkedList集合(表示连接池)

  • 在连接池类的静态代码块中,创建固定数量的连接,并存储到LinkedList集合中

  • 使用重写的方法getConnection,来获取连接对象

  • 提供一个公共的非静态方法来归还连接对象(addBack)

  • 提供一个公共的静态方法来获取连接池中连接的数量

package com.jcli.demo03_自定义连接池进阶版;

import com.jcli.utils.JDBCUtils;

import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.LinkedList;
import java.util.logging.Logger;

/**
 * - 创建连接池类
 */
public class MyDataSource02 implements DataSource {
    //- 在连接池类中,定义一个LinkedList集合(表示连接池)
    private static LinkedList<Connection> pools = new LinkedList<>();

    //- 在连接池类的静态代码块中,创建固定数量的连接,并存储到LinkedList集合中
    static {
        for (int i = 0; i < 6; i++) {
            try {
                //获得连接
                Connection connection = JDBCUtils.getConnection();
                //把连接添加到连接池
                pools.add(connection);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    //- 提供一个公共的非静态方法来获取连接对象(getAbc)
    /*public Connection getAbc() {
        Connection connection = pools.removeFirst();
        return connection;
    }*/

    //- 提供一个公共的非静态方法来归还连接对象(addBack)
    public void addBack(Connection connection) {
        pools.addLast(connection);
    }

    //- 提供一个公共的静态方法来获取连接池中连接的数量
    public static int size() {
        return pools.size();
    }

    //- 重写getConnection方法，获得链接
    @Override
    public Connection getConnection() throws SQLException {
        Connection connection = pools.removeFirst();
        return connection;
    }

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

测试：

package com.jcli.demo02_自定义连接池初级版;

import com.jcli.utils.JDBCUtils;

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

public class Test {
    public static void main(String[] args) throws SQLException {
        // 1.创建连接池对象
        MyDataSource01 dataSource01 = new MyDataSource01();
        System.out.println("获得连接之前:"+MyDataSource01.size());
        // 2.获得连接
        Connection connection = dataSource01.getAbc();
        System.out.println("获得连接之后:"+MyDataSource01.size());
        // 3.预编译sql语句,得到预编译对象
        String sql = "select * from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);
        // 4.设置参数
        ps.setInt(1,1);
        // 5.执行sql语句,处理结果
        ResultSet resultSet = ps.executeQuery();
        // 取数据
        while (resultSet.next()){
            int id = resultSet.getInt("id");
            String username = resultSet.getString("username");
            String password = resultSet.getString("password");
            String nickname = resultSet.getString("name");
        }
        System.out.println("归还连接之前:"+MyDataSource01.size());
        // 6.归还连接
        dataSource01.addBack(connection);
        System.out.println("归还连接之后:"+MyDataSource01.size());
        // 7.释放资源
        JDBCUtils.release(resultSet,ps,null);
    }
}

4.装饰者模式

  • 作用：改写已存在的类的某个方法或某些方法

  • 条件:

    • 装饰类和被装饰类要实现同一个接口

    • 装饰类里面要拿到被装饰类的引用

    • 对需要增强的方法进行增强

    • 对不需要增强的方法就调用被装饰类中原有的方法

package com.jcli.demo04_装饰者模式;

public interface Star {
    void sing();
    void dance();
}

package com.jcli.demo04_装饰者模式;

// 被装饰类
public class CiVi implements Star {
    @Override
    public void sing() {
        System.out.println("CiVi在唱小星星~~~");
    }

    @Override
    public void dance() {
        System.out.println("CiVi在跳绳~~~");
    }
}


package com.jcli.demo04_装饰者模式;
// 装饰类
public class CiViWrapper implements Star {
    Star star;

    public CiViWrapper(Star star) {
        this.star = star;
    }

    @Override
    public void sing() {
        System.out.println("CiVi在唱小星星~~~");
        System.out.println("CiVi在唱十年~~~");
        System.out.println("CiVi在唱绿光~~~");
    }

    @Override
    public void dance() {
        star.dance();
    }
}

package com.jcli.demo04_装饰者模式;

public class Test {
    public static void main(String[] args) {
        CiVi ciVi = new CiVi();
        CiViWrapper cvw = new CiViWrapper(ciVi);
        cvw.sing();
        cvw.dance();
    }
}

5.自定义连接池-终极版本

  • 创建增强的连接类,对close方法进行增强,其余方法依然调用原有的连接对象的方法

  • 创建连接池类, 实现DataSource接口,重写方法

  • 在连接池类中,定义一个LinkedList集合(表示连接池)

  • 在连接池类的静态代码块中,创建固定数量的连接,并存储到LinkedList集合中

  • 使用重写的方法getConnection,来获取连接对象----->增强的连接对象

  • 提供一个公共的静态方法来获取连接池中连接的数量

  • 与进阶版的区别:

    • 连接池类中不需要提供归还连接的方法

    • getConnection获得连接的方法不再返回被增强的连接对象,而是返回增强的连接对象

实现

//装饰类
//获取被装饰的引用
//创建linkedList集合
//对需要增强的方法增强~~~归还连接
//不需要增强的直接调用~~~被装饰类
//创建连接池类
//- 重写getConnection方法，获得链接
// 返回增强的连接对象
//- 取消归还连接对象(addBack)方法
package com.jcli.demo05_自定义连接池终极版;

import java.sql.*;
import java.util.LinkedList;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.Executor;

// 装饰类
public class MyConnection implements Connection {
    //获取被装饰的引用
    Connection connection;
    //创建linkedList集合
    LinkedList<Connection> pools;

    public MyConnection(Connection connection, LinkedList<Connection> pools) {
        this.connection = connection;
        this.pools = pools;
    }

    @Override
    public void close() throws SQLException {
        // 对需要增强的方法进行增强----归还连接
        pools.addLast(connection);
    }

    @Override
    public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
        // 对不需要增强的方法就调用被装饰类中原有的方法
        return connection.createStatement();
    }

    @Override
    public PreparedStatement prepareStatement(String sql) throws SQLException {
        // 对不需要增强的方法就调用被装饰类中原有的方法
        return connection.prepareStatement(sql);
    }


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


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

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

    @Override
    public void setAutoCommit(boolean autoCommit) throws SQLException {

    }

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

    @Override
    public void commit() throws SQLException {

    }

    @Override
    public void rollback() throws SQLException {

    }


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

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

    @Override
    public void setReadOnly(boolean readOnly) throws SQLException {

    }

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

    @Override
    public void setCatalog(String catalog) throws SQLException {

    }

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

    @Override
    public void setTransactionIsolation(int level) throws SQLException {

    }

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

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

    @Override
    public void clearWarnings() throws SQLException {

    }


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

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

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

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

    }

    @Override
    public void setHoldability(int holdability) throws SQLException {

    }

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

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

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

    @Override
    public void rollback(Savepoint savepoint) throws SQLException {

    }

    @Override
    public void releaseSavepoint(Savepoint savepoint) throws SQLException {

    }

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

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

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

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

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

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

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

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

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

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

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

    @Override
    public void setClientInfo(String name, String value) throws SQLClientInfoException {

    }

    @Override
    public void setClientInfo(Properties properties) throws SQLClientInfoException {

    }

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

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

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

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

    @Override
    public void setSchema(String schema) throws SQLException {

    }

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

    @Override
    public void abort(Executor executor) throws SQLException {

    }

    @Override
    public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {

    }

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

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

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

6.C3P0连接池

1.通过硬编码来编写【了解】

  • 拷贝c3p0的jar包到模块下

  • 创建c3p0连接池对象

  • 设置连接参数

  • 获得连接对象

  • 预编译sql语句,得到预编译对象

  • 设置sql语句参数

  • 执行sql语句,处理结果

  • 释放资源

package com.jcli.demo06_C3P0连接池;

import com.jcli.utils.JDBCUtils;
import com.mchange.v2.c3p0.ComboPooledDataSource;

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

public class Test01 {
    public static void main(String[] args) throws Exception {
        //- 拷贝c3p0的jar包到模块下
        //        - 创建c3p0连接池对象
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        //        - 设置连接参数
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/jcli_ee");
        dataSource.setUser("root");
        dataSource.setPassword("root");
        dataSource.setInitialPoolSize(5);
        //        - 获得连接对象
        Connection connection = dataSource.getConnection();
        //        - 预编译sql语句,得到预编译对象
        String sql = "select * from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);
        //        - 设置sql语句参数
        ps.setInt(1, 1);
        //        - 执行sql语句,处理结果
        ResultSet resultSet = ps.executeQuery();
        while (resultSet.next()) {
            System.out.println(resultSet.getInt("id"));
            System.out.println(resultSet.getString("username"));
            System.out.println(resultSet.getString("password"));
            System.out.println(resultSet.getString("name"));
        }
        //        - 释放资源
        JDBCUtils.release(resultSet, ps, connection);
    }
}

2.通过配置文件来编写

- 拷贝c3p0的jar包到模块下
- 拷贝c3p0-config.xml配置文件拷贝到模块的src路径下
  - **c3p0-config.xml配置文件的文件名不能修改,必须为c3p0-config.xml**
  - **c3p0-config.xml配置文件的路径必须在src路径下**
  - **c3p0-config.xml配置文件中property标签的name属性值不能修改**
- 创建c3p0连接池对象
- 获得连接对象
- 预编译sql语句,得到预编译对象
- 设置sql语句参数
- 执行sql语句,处理结果
- 释放资源

package com.jcli.demo06_C3P0连接池;

import com.jcli.utils.JDBCUtils;
import com.mchange.v2.c3p0.ComboPooledDataSource;

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

public class Test02 {
    public static void main(String[] args) throws SQLException {
        //- 拷贝c3p0的jar包到模块下
        //        - 拷贝c3p0-config.xml配置文件拷贝到模块的src路径下
        //        - **c3p0-config.xml配置文件的文件名不能修改,必须为c3p0-config.xml**
        //- **c3p0-config.xml配置文件的路径必须在src路径下**
        //- **c3p0-config.xml配置文件中property标签的name属性值不能修改**
        //- 创建c3p0连接池对象
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        //        - 获得连接对象
        Connection connection = dataSource.getConnection();
        //        - 预编译sql语句,得到预编译对象
        String sql = "select * from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);
        //        - 设置sql语句参数
        ps.setInt(1, 1);
        //        - 执行sql语句,处理结果
        ResultSet resultSet = ps.executeQuery();
        while (resultSet.next()) {
            System.out.println(resultSet.getInt("id"));
            System.out.println(resultSet.getString("username"));
            System.out.println(resultSet.getString("password"));
            System.out.println(resultSet.getString("name"));
        }
        //        - 释放资源
        JDBCUtils.release(resultSet, ps, connection);
    }
}

3.使用c3p0改写工具类

整个程序只需要创建一个连接池对象,其余地方直接使用这个唯一的连接池对象获得连接即可

- 创建唯一的连接池对象---->private static final修饰
- 提供一个获取连接池对象的静态方法
- 提供一个获取连接的静态方法
- 提供一个释放资源的静态方法
package com.jcli.utils;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class C3P0Utils {
    //    - 创建唯一的连接池对象---->private static final修饰
    private static final ComboPooledDataSource DATA_SOURCE = new ComboPooledDataSource();

    //- 提供一个获取连接池对象的静态方法
    public static DataSource getDataSource() {
        return DATA_SOURCE;
    }

    //- 提供一个获取连接的静态方法
    public static Connection getConnection() throws SQLException {
        return DATA_SOURCE.getConnection();
    }

    //- 提供一个释放资源的静态方法
    public static void release(ResultSet resultSet, Statement statement, Connection connection) {
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

package com.jcli.demo06_C3P0连接池;

import com.jcli.utils.C3P0Utils;
import com.mchange.v2.c3p0.ComboPooledDataSource;

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

public class Test3 {
    public static void main(String[] args) throws Exception{
        //- 创建c3p0连接池对象
        DataSource dataSource = C3P0Utils.getDataSource();

        //- 获得连接对象
        Connection connection = dataSource.getConnection();

        //- 预编译sql语句,得到预编译对象
        String sql = "select * from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);

        //- 设置sql语句参数
        ps.setInt(1,1);

        //- 执行sql语句,处理结果
        ResultSet resultSet = ps.executeQuery();
        while (resultSet.next()) {
            System.out.println(resultSet.getInt("id"));
            System.out.println(resultSet.getString("username"));
            System.out.println(resultSet.getString("password"));
            System.out.println(resultSet.getString("name"));
        }
        //- 释放资源
        C3P0Utils.release(resultSet,ps,connection);
    }
}

7.DRUID连接池

1.通过硬编码方式【了解】

- 导入druid的jar包到模块中
- 创建druid的连接池对象
- 设置连接参数
- 获得连接对象
- 预编译sql语句,得到预编译对象
- 设置sql语句参数
- 执行sql语句,处理结果
- 释放资源
package com.jcli.demo07_DRUID连接池;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidPooledConnection;
import com.jcli.utils.JDBCUtils;
import com.mchange.v2.c3p0.ComboPooledDataSource;

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

public class Test01 {
    public static void main(String[] args) throws Exception {
        //- 导入druid的jar包到模块中
        //- 创建druid的连接池对象
        DruidDataSource dataSource = new DruidDataSource();
        //        - 设置连接参数
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/jcli_ee");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        //        - 获得连接对象
        DruidPooledConnection connection = dataSource.getConnection();
        //        - 预编译sql语句,得到预编译对象
        String sql = "select * from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);
        //        - 设置sql语句参数
        ps.setInt(1, 1);
        //        - 执行sql语句,处理结果
        ResultSet resultSet = ps.executeQuery();
        while (resultSet.next()) {
            System.out.println(resultSet.getInt("id"));
            System.out.println(resultSet.getString("username"));
            System.out.println(resultSet.getString("password"));
            System.out.println(resultSet.getString("name"));
        }
        //        - 释放资源
        JDBCUtils.release(resultSet, ps, connection);
    }
}

2.通过配置文件方式

- 拷贝druid的jar包到模块下
- 拷贝druid.properties配置文件拷贝到模块的src路径下
  - druid.properties配置文件的文件名可以修改
  - druid.properties配置文件的路径建议在src路径下
  - druid.properties配置文件中的键名不能修改
- 创建druid连接池对象,传入Properties对象
- 获得连接对象
- 预编译sql语句,得到预编译对象
- 设置sql语句参数
- 执行sql语句,处理结果
- 释放资源
package com.jcli.demo07_DRUID连接池;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import com.alibaba.druid.pool.DruidPooledConnection;
import com.jcli.utils.JDBCUtils;

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

public class Test02 {
    public static void main(String[] args) throws Exception {
        //- 拷贝druid的jar包到模块下
        //- 拷贝druid.properties配置文件拷贝到模块的src路径下
        //  - druid.properties配置文件的文件名可以修改
        //  - druid.properties配置文件的路径建议在src路径下
        //  - druid.properties配置文件中的键名不能修改

        // 创建properties对象,加载druid.properties配置文件
        Properties pro = new Properties();
        InputStream is = Test02.class.getClassLoader().getResourceAsStream("druid.properties");
        pro.load(is);
        //- 创建druid连接池对象,传入Properties对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(pro);
        //        - 设置连接参数
        //dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        //dataSource.setUrl("jdbc:mysql://localhost:3306/jcli_ee");
        //dataSource.setUsername("root");
        //dataSource.setPassword("root");
        //        - 获得连接对象
        Connection connection = dataSource.getConnection();
        //        - 预编译sql语句,得到预编译对象
        String sql = "select * from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);
        //        - 设置sql语句参数
        ps.setInt(1, 1);
        //        - 执行sql语句,处理结果
        ResultSet resultSet = ps.executeQuery();
        while (resultSet.next()) {
            System.out.println(resultSet.getInt("id"));
            System.out.println(resultSet.getString("username"));
            System.out.println(resultSet.getString("password"));
            System.out.println(resultSet.getString("name"));
        }
        //        - 释放资源
        JDBCUtils.release(resultSet, ps, connection);
    }
}

3.Druid工具类的制作

- 创建连接池成员变量
- 在静态代码块中加载配置文件,创建druid连接池对象
- 提供一个获取连接池对象的静态方法
- 提供一个获取连接的静态方法
- 提供一个释放资源的静态方法
package com.jcli.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import com.jcli.demo07_DRUID连接池.Test02;

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 DruidUtils {
    //    - 创建连接池成员变量
    private static DataSource dataSource;

    //- 在静态代码块中加载配置文件,创建druid连接池对象
    static {
        try {

            Properties pro = new Properties();
            InputStream is = Test02.class.getClassLoader().getResourceAsStream("druid.properties");
            pro.load(is);

            //- 创建druid连接池对象,传入Properties对象
            dataSource = DruidDataSourceFactory.createDataSource(pro);

        } catch (Exception e) {

        }
    }

    //- 提供一个获取连接池对象的静态方法
    public static DataSource getDataSource() {
        return dataSource;
    }

    //- 提供一个获取连接的静态方法
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }

    //- 提供一个释放资源的静态方法
    public static void release(ResultSet resultSet, Statement statement, Connection connection) {

        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }


}

package com.jcli.demo07_DRUID连接池;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import com.jcli.utils.DruidUtils;
import com.jcli.utils.JDBCUtils;

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

public class Test03 {
    public static void main(String[] args) throws Exception {
        //获得连接池对象
        DataSource dataSource = DruidUtils.getDataSource();
        /*// 创建properties对象,加载druid.properties配置文件
        Properties pro = new Properties();
        InputStream is = Test03.class.getClassLoader().getResourceAsStream("druid.properties");
        //pro.load(is);
        //- 创建druid连接池对象,传入Properties对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(pro);*/
        //        - 获得连接对象
        Connection connection = dataSource.getConnection();
        //        - 预编译sql语句,得到预编译对象
        String sql = "select * from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);
        //        - 设置sql语句参数
        ps.setInt(1, 1);
        //        - 执行sql语句,处理结果
        ResultSet resultSet = ps.executeQuery();
        while (resultSet.next()) {
            System.out.println(resultSet.getInt("id"));
            System.out.println(resultSet.getString("username"));
            System.out.println(resultSet.getString("password"));
            System.out.println(resultSet.getString("name"));
        }
        //        - 释放资源
        JDBCUtils.release(resultSet, ps, connection);
    }
}

8.DBUtils完成增删改

- 导入DButils的jar包---->mysql驱动包,第三方数据库连接池的jar包,配置文件,工具类
- 创建QueryRunner对象,传入连接池对象
- 调用update方法执行sql语句
package com.jcli.demo08_DBUtils完成增删改;

import com.jcli.utils.C3P0Utils;
import org.apache.commons.dbutils.QueryRunner;
import org.junit.Test;

import java.sql.SQLException;

public class TestDemo {
//- 导入DButils的jar包---->mysql驱动包,第三方数据库连接池的jar包,配置文件,工具类
//- 创建QueryRunner对象,传入连接池对象
//- 调用update方法执行sql语句
    QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());
    @Test
    public void add() throws SQLException {
        String sql = "insert into user values(null,?,?,?)";
        int rows = queryRunner.update(sql, "tq", "123", "田七");
        System.out.println("insert受影响的行数:" + rows);
    }
    @Test
    public void update() throws SQLException {
        String sql = "update user set password=? where name=?";
        int rows = queryRunner.update(sql,  "11123", "田七");
        System.out.println("update受影响的行数:" + rows);
    }
    @Test
    public void delete() throws SQLException {
        String sql = "delete from user where id = ?";
        int rows = queryRunner.update(sql,  10);
        System.out.println("delete受影响的行数:" + rows);
    }

}

9.DBUtils完成查询

查询一条记录(使用ArrayHandler,使用BeanHandler,使用MapHandler)

package com.jcli.demo09_DBUtils完成查询;

import com.jcli.bean.User;
import com.jcli.utils.C3P0Utils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.junit.Test;

import java.sql.SQLException;
import java.util.Arrays;
import java.util.Map;

//查询一条记录
public class Test01 {
    //- 创建QueryRunner对象,传入连接池对象
    QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());

    // 查询结果为一条记录的封装成数组
    @Test
    public void selectById1() throws SQLException {
        String sql = "select * from user where id = ?";
        Object[] arr = queryRunner.query(sql, new ArrayHandler(), 1);
        System.out.println(Arrays.toString(arr));
    }

    //    查询结果记录为一条记录的封装成javabean对象
    @Test
    public void selectById2() throws SQLException {
        String sql = "select * from user where id = ?";
        User arr = queryRunner.query(sql, new BeanHandler<User>(User.class), 1);
        System.out.println(arr);
    }

    //    查询结果为一条记录的封装成map集合
    @Test
    public void selectById3() throws SQLException {
        String sql = "select * from user where id = ?";
        Map<String, Object> map = queryRunner.query(sql, new MapHandler(), 1);
        System.out.println(map);
    }
}

查询多条数据封装到List集合中(使用ArrayListHandler,使用BeanListHandler,使用MapListHandler)

package com.jcli.demo09_DBUtils完成查询;

import com.jcli.bean.User;
import com.jcli.utils.C3P0Utils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.*;
import org.junit.Test;

import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

//查询多条记录
public class Test02 {
    //- 创建QueryRunner对象,传入连接池对象
    QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());

    // 查询结果为多条记录的封装成list集合，类型Object数组
    @Test
    public void selectByAll1() throws SQLException {
        String sql = "select * from user ";
        List<Object[]> list = queryRunner.query(sql, new ArrayListHandler());
        for (Object[] arr : list) {
            System.out.println(Arrays.toString(arr));
        }
    }

    //    查询结果记录为多条记录的封装成list集合，类型javabean对象
    @Test
    public void selectByAll2() throws SQLException {
        String sql = "select * from user ";
        List<User> list = queryRunner.query(sql, new BeanListHandler<User>(User.class) );
        for (User user : list) {
            System.out.println(user);
        }
    }

    //    查询结果为多条记录的封装成list集合，类型+map集合
    @Test
    public void selectByAll3() throws SQLException {
        String sql = "select * from user ";
        List<Map<String, Object>> list = queryRunner.query(sql, new MapListHandler());
        for (Map<String, Object> map : list) {
            System.out.println(map);
        }
    }
}

查询单个数据(使用ScalarHandler())

package com.jcli.demo09_DBUtils完成查询;

import com.jcli.bean.User;
import com.jcli.utils.C3P0Utils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.junit.Test;

import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

//查询单个数据(使用ScalarHandler())
public class Test03 {
    //- 创建QueryRunner对象,传入连接池对象
    QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());
    @Test
    public void selectByAll1() throws SQLException {
        String sql = "select count(*) from user ";
        Long count = (Long) queryRunner.query(sql, new ScalarHandler());
        System.out.println(count);
    }
}

查询单列多个值(使用ColumnListHandler)

package com.jcli.demo09_DBUtils完成查询;

import com.jcli.utils.C3P0Utils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ColumnListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.junit.Test;

import java.sql.SQLException;
import java.util.List;

//查询单列多个值(使用ColumnListHandler)
public class Test04 {
    //- 创建QueryRunner对象,传入连接池对象
    QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());
    @Test
    public void selectByAll1() throws SQLException {
        String sql = "select name from user ";
        List<Object> list = queryRunner.query(sql,new ColumnListHandler());
        System.out.println(list);
    }
}

10.元数据

参数元数据

package com.jcli.demo10_自定义DBUtils;

import com.jcli.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.SQLException;

//参数元数据
public class Test01 {
    public static void main(String[] args) throws SQLException {
        Connection connection = JDBCUtils.getConnection();
        String sql = "select * from user where username = ? and password = ?";
        PreparedStatement ps = connection.prepareStatement(sql);
        //- 获取参数的元数据对象

        ParameterMetaData pmd = ps.getParameterMetaData();
        //- 根据参数的元数据对象 获取 参数的元数据
        System.out.println("获取参数计数:"+pmd.getParameterCount());
        //Parameter metadata not available for the given statement
        System.out.println("获取参数类名称"+pmd.getParameterClassName(1));
    }
}

结果集元素数据

package com.jcli.demo10_自定义DBUtils;

import com.jcli.utils.JDBCUtils;

import java.sql.*;

// 结果集元素数据
public class Test02 {
    public static void main(String[] args) throws SQLException {
        Connection connection = JDBCUtils.getConnection();
        String sql = "select * from user";
        PreparedStatement ps = connection.prepareStatement(sql);
        ResultSet resultSet = ps.executeQuery();
        // 获得结果集元数据对象
        ResultSetMetaData rmd = resultSet.getMetaData();

        // 使用结果集元数据对象 获得 结果集的元数据(列的个数,列的名称,类型...)
        int columnCount = rmd.getColumnCount();
        System.out.println("结果集中列的个数:"+columnCount);
        // 循环遍历获取列名,列的类型
        for (int i = 1; i <= columnCount; i++) {
            System.out.println("结果集中列的名称:"+rmd.getColumnName(i));
            System.out.println("结果集中列的sql类型:"+rmd.getColumnTypeName(i));
            System.out.println("结果集中列的java类型:"+rmd.getColumnClassName(i));
            System.out.println("----------------");
        }
    }
}

11.自定义DBUtils增删改

- 创建MyQueryRunner类
- 定义一个DataSource成员变量
- 定义一个有参构造方法,空参构造方法
- 定义一个update(String sql,Object... args)完成增删改操作
package com.jcli.demo11_自定义DBUtils增删改;

import com.jcli.utils.JDBCUtils;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * - 创建MyQueryRunner类
 */
public class MyQueryRunner {
    //    * - 定义一个DataSource成员变量
    private DataSource dataSource;

    //    * - 定义一个有参构造方法,空参构造方法
    public MyQueryRunner() {
    }

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

    //    * - 定义一个update(String sql,Object... args)完成增删改操作
    public int update(String sql, Object... args) throws SQLException {
        //- 1.注册驱动,获得连接
        Connection connection = dataSource.getConnection();
        //        - 2.预编译sql语句,得到预编译对象
        PreparedStatement ps = connection.prepareStatement(sql);
        //        - 3.设置参数
        // 3.1 获得参数的元数据对象
        ParameterMetaData pmd = ps.getParameterMetaData();
        // 3.2 通过参数元数据对象获取参数的个数
        int parameterCount = pmd.getParameterCount();
        // 3.3 循环遍历赋值
        for (int i = 0; i < parameterCount; i++) {
            ps.setObject(i + 1, args[i]);
        }
        //        - 4.执行sql语句,处理结果
        int rows = ps.executeUpdate();
        //        - 5.释放资源
        JDBCUtils.release(null, ps, connection);
        return rows;
    }

}

package com.jcli.demo11_自定义DBUtils增删改;

import com.jcli.utils.C3P0Utils;
import org.junit.Test;

import java.sql.SQLException;

public class TestDemo {
    //- 导入DButils的jar包---->mysql驱动包,第三方数据库连接池的jar包,配置文件,工具类
//- 创建QueryRunner对象,传入连接池对象
    MyQueryRunner queryRunner = new MyQueryRunner(C3P0Utils.getDataSource());

    //- 调用update方法执行sql语句
    @Test
    public void add() throws SQLException {
        String sql = "insert into user values(null,?,?,?)";
        int rows = queryRunner.update(sql, "tq", "123", "田七");
        System.out.println("insert受影响的行数:" + rows);
    }

    @Test
    public void update() throws SQLException {
        String sql = "update user set password=? where name=?";
        int rows = queryRunner.update(sql, "11123", "田七");
        System.out.println("update受影响的行数:" + rows);
    }

    @Test
    public void delete() throws SQLException {
        String sql = "delete from user where id = ?";
        int rows = queryRunner.update(sql, 10);
        System.out.println("delete受影响的行数:" + rows);
    }

}

 代码：

https://gitee.com/li-ear/dbutils.git

LI耳
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JDBCUtils工具类
学习笔记
02-19 136
代码： import com.alibaba.druid.pool.DruidDataSource; import com.alibaba.druid.pool.DruidDataSourceFactory; import javax.sql.DataSource; import java.io.IOException; import java.io.InputStream; import ...
重构JDBCUtils
Ferryman23333的博客
06-10 244
1.上一节我们用到JDBC并设置了连接数据库必要的四个变量：dreiver url user password 在实际应用中，JDBC可设置的还有很多属性如最大连接数量，连接等待时间等，我们可以自己写一个JDBC的工具类实现对JDBC属性的设置(重构JDBCUtils类) package cn.itheima.gjp.tools; import javax.sql.DataSource; impo...
java datasouce jdbc_javaSE JDBC, 连接池DBCP, 获取DataSource的工具类
weixin_30449673的博客
02-28 211
Demo.java(工具测试类)：package cn.xxx.demo; import java.sql.SQLException; import java.util.List; import org.apache.commons.dbutils.QueryRunner; import org.apache.commons.dbutils.handlers.ArrayListHandler;...
【JDBC-6】数据库连接池
only-code的博客
04-24 950
类似于线程池，准备一些预先的资源，到使用的时候直接拿出。 之前我们在对数据库进行连接操作时，每次连接都需要连接 connection = JDBCUtils.getConnection(); 操作完毕后还需要释放 JDBCUtils.release(connection,preparedStatement,resultSet); 这些操作是非常消耗系统资源的，因此就推出了数据库连接池的概念。类似于线程池，在事先定义好连接次数后，不用每次操作都要进行数据库的连接和释放 热门的开源数据源实..
14.JdbcUtils框架
weixin_34364071的博客
08-14 103
1.编写自己的JdbcUtils 框架 2.使用 dbUtils 框架 　　1.视频中自己编写的JdbcUtils框架差不多就是dbUtils框架 　　2.使用 　　　　使用dbutils框架完成curd,以及批处理 　　　　使用dbutils各种类型的处理器完成结果集的处理 1 @Test 2 public void find() throws SQLExcepti...
数据库连接池和DBUtils使用1
08-04
【数据库连接池与DBUtils详解】 数据库连接池是数据库管理中的一个重要概念，它解决了传统JDBC操作数据库时频繁创建和关闭连接导致的性能问题。在Java编程中，数据库连接池的使用可以显著提升应用程序的效率，因为...
JDBC连接池&DBUtils1
08-08
JDBC 连接池 & DBUtils ...总结来说，JDBC 连接池和 DBUtils 是 Java 中两个非常重要的技术，用于提高数据库连接的效率和简化 JDBC 操作。通过使用连接池和 DBUtils，可以提高数据库应用程序的性能和可维护性。
java学习笔记之DBUtils工具包详解
08-28
* 参数一：连接池对象 * 参数二：sql语句 * 参数三：可变参数（就是sql占位符的值） * 返回值：int类型的 返回受影响的行数 示例代码： public class Demo { public static void main(String[] args) throws ...
使用dbutils获取tomcat数据库连接池.pdf
09-29
【使用dbutils获取tomcat数据库连接池】 Apache Commons DBUtils是一个轻量级的Java库，它简化了对JDBC API的使用，通过提供一个抽象层来处理常见的数据库操作，如查询、更新等，从而减少代码量和出错的可能性。本...
java-dbutils笔记
06-18
总的来说，Java DBUtils 提供了一种简洁、高效的方式来处理数据库操作，通过它我们可以避免编写大量重复的 JDBC 代码，同时利用连接池优化性能。使用时，可以根据需求选择合适的方式和 Handler 类，以实现灵活的数据...
javaSE JDBC, 连接池DBCP, 获取DataSource的工具类
houyanhua1的专栏
06-23 3332
MySql驱动(jar包)下载：https://pan.baidu.com/s/19BYnGbO3l5MOOic5K4Ooaw  密码：mwoh第三方插件(commons-dbutils)下载：https://pan.baidu.com/s/17cyAXHZLgiayx5Y_VHvawQ  密码：6om2连接池DBCP下载(jar包)：https://pan.baidu.com/s/1U3dGaA...
Java JDBC基本操作(增,删,改,查)总结
月夜归醉
05-09 7016
JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序，同时，JDBC也是个商标名。
java mysql dbutils_JAVA基础之DBUtils与连接池
weixin_42170790的博客
01-26 151
利用DBUtils进一步简化JDBC数据库的增删改查的代码，同时利用从连接池中接取连接，进而进行简化和减少资源的消耗！一、DBUtils：1、DBUtils就是JDBC的简化开发工具包。需要项目导入commons-dbutils-1.6.jar才能够正常使用DBUtils工具。2、DBUtils是java编程中的数据库操作实用工具，小巧简单实用。DBUtils封装了对JDBC的操作，简化了JDBC...
java mysql dbutils_Java数据库--DBUtils
weixin_39731782的博客
02-01 191
一、DBUtils简介Commons DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能。DBUtils是java编程中的数据库操作实用工具，小巧简单实用。下载地址：http://commons.apache.org/proper/commons-dbutils/对于数据表的读操作，他可以把结果转换成Lis...
java 反射 封装_Java使用反射封装一个方便操作数据库的类
weixin_39519072的博客
02-15 188
刚开始学JavaWeb时，我是调用N个setter方法将从数据库中查询出的数据封装成JavaBean的，极其繁琐。后来了解SpringJDBC后，发现它提供的接口非常简单，然后就想自己封装一个简单的用。原理很简单，就是使用反射代替手动调用 setter 方法，JavaBean中的属性名要和数据库查询语句中的字段名相同，一一对应。数据库配置文件(config.properities)格式为：db.u...
Java基础学习到进阶自我总结
qq_42366871的博客
01-16 176
Java基础学习到进阶自我总结八2020-01-16sql语句占位符的使用和操作占位符赋值查询返回结果集Oracle存储过程的调用和传参 2020-01-16 sql语句占位符的使用和操作 占位符赋值 /* * 占位符?:在sql语句中占据了赋值的位置,有一定顺序 */ //传参到sql语句中 public static void main(String[] args) { ...
Connection conn = JdbcConnection.getConnection();
热门推荐
BAOXF专栏
09-30 1万+
JDBC里面连接数据库的时候用的一句话. 其中Connection是接口，JdbcConnection是一个普通的类，getConnection（）方法是静态方法，它们之所以能用 = 连起来，因为getConnection（）方法返回的是实现了Connection接口的类的实例。 其实Connection是类还是接口对这句话都是正确的，正常情况下是用类声明一个变量，而接口是一个被特殊化了的
javaDB数据源的配置
xxqn的专栏
08-24 669
javaDB数据库是java自带的数据库，就是原来的derby数据库，用于测试或者小型应用，完全应付自如。最重要的是随手就能用，不用太多的安装配置，可以吧更多的精力花在核心问题上，利于学习和开发测试。以下是个配置例子： org.hibernate.ejb.HibernatePersistence cn.jhc.bean.Employee ...
java--DBUtils和连接池
weixin_30415801的博客
09-15 125
DBUtils 一、DBUtils的使用 DBUtils就是JDBC的简化开发工具包。需要项目导入commons-dbutils-1.6.jar才能够正常使用DBUtils工具。如果只使用JDBC进行开发，我们会发现冗余代码过多，为了简化JDBC开发，本案例我们讲采用apache commons组件一个成员：DBUtils。 二、DBUtils概述 DBUtils是jav...
public class UserServiceImpl implements UserService { @Override public boolean login(String username, String password) { Connection connection = JDBCUtils.getConnection(); boolean result = false; try { connection.setAutoCommit(false); UserDaoImpl userDao = new UserDaoImpl(); User user = userDao.selectByName(username); if (user != null && user.getPassword().equals(password)){ result = true; } connection.commit(); }catch (Exception e){ try { connection.rollback(); }catch (SQLException throwables){ throwables.printStackTrace(); } e.printStackTrace(); throw new RuntimeException(e); }finally { JDBCUtils.close(connection,null,null); } return result; }
最新发布
07-10
根据你提供的代码，我仍然没有找到静态初始化块或静态变量的定义。所以，ExceptionInInitializerError 异常可能是由于其他原因导致的。 根据堆栈跟踪信息，异常发生在 com.zengsq.service.impl.UserServiceImpl 类的 login 方法中的第15行。这个异常可能是由于以下原因之一引起的： 1. `JDBCUtils.getConnection()` 方法返回了一个 null 的连接对象，导致在调用 `connection.setAutoCommit(false)` 时出现了 NullPointerException 异常。 2. `UserDaoImpl` 类的 `selectByName` 方法在执行过程中抛出了异常，导致在比较密码时出现了 NullPointerException 或其他异常。 为了解决这个问题，你可以按照以下步骤进行调试： 1. 确保数据库连接配置正确，并且能够成功连接到数据库。 2. 检查 `JDBCUtils.getConnection()` 方法的实现，确保它返回一个有效的连接对象，而不是 null。 3. 检查 `UserDaoImpl` 类的 `selectByName` 方法的实现，确保它能够正确地查询用户信息，并且没有抛出异常。 4. 检查数据库中是否存在与传入的用户名相匹配的用户记录。确保查询结果不为 null，并且能够正确地获取用户对象和密码进行比较。 如果以上步骤都没有解决问题，请提供更多的代码和错误信息，我将尽力为你提供帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值