apache-commons-dbutils + Druid + JDBC 简单实现 CRUD

一、类库介绍

首先简单介绍一下以上三种类库的区别与联系:

JDBC

JDBC 是 sun 公司定义的一套使用 java 连接数据库的规范,是一套接口加部分实现类,他规定了各大数据库厂商要想使用 java 语言操作他们的数据库就必须实现这些接口,可以说 JDBC 是一套规范。比如 MySQL 就实现了这一套接口,在com.mysql.jdbc包下。

DBUtils

Apache-commons 是 Apache 的一个工具类库,相信大家都听说过这些工具类,非常实用,我们使用的Apache-commons-dbutils就是其中一个类库,它对 JDBC 进行了简单的封装(其实也不是很简单的封装,只是相对于框架来说是简单封装),简化了 JDBC 操作。当然我们也可以不使用他提供的类库而自己实现,但是这是非常麻烦的,而且没有必要浪费时间在这上面,就好像你着急上班,别人有汽车你不坐,说跑步可以锻炼身体,所以走过去。但是这太浪费时间了,所以我们要学会开车,然后研究他的原理,这样我们也会进步。

Druid

Druid 是阿里巴巴研发的一套数据库连接池技术,这个类库并不是必须使用的,我们在这里使用的目的是因为它可以增强性能,因为我们如果使用原生的 JDBC,不使用数据库连接池,那么每进行一次数据库查询操作就会建立一条连接,而数据库连接池是首先创建很多连接,当你需要用的时候就拿走,用完了之后归还,这样可以提高资源的利用率。常用的数据库连接池有 C3P0 和 Druid,我选择 Druid的原因是因为这是 web 项目模板,而且 Druid 提供强大的数据库监控技术和统计技术。详情可以看这篇文章:JavaWeb 使用 Druid 连接池查询数据库

二、功能分析

我们主要实现的功能有以下几个:

  • 首先建立数据库连接池类,用于和 Druid 交互;
  • 然后建立连接数据库操作的 BaseDao 基类,用于和 DBUtils 交互;
  • 由于 DBUtils 已经实现了和 JDBC 交互,所以我们只需要封装以上两层即可简化 JDBC 操作;
  • 为了简化业务层操作,我们继续封装 DBUtils ,实现 CRUD 接口,这样业务层只需要调用接口即可实现与数据库交互。

三、代码实现

这里是一个 JavaWeb 项目
在这里插入图片描述

建表

本项目使用的数据库为 school,如果想和我一起操作请建表,并注意编码设置为 UTF-8

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (
  `id` int(100) NOT NULL AUTO_INCREMENT,
  `username` varchar(25) DEFAULT NULL,
  `password` varchar(25) DEFAULT NULL,
  `address` varchar(100) DEFAULT NULL,
  `phone` varchar(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

配置类代码

配置类代码分为 pomdruid

首先来看一下 pom文件:

<dependencies>
        <!--Junit 单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <!--servlet api-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.26</version>
            <scope>compile</scope>
        </dependency>

        <!--Druid 数据库连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.22</version>
        </dependency>

        <!--apache dbUtils : 简化 JDBC 操作-->
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.7</version>
        </dependency>

        <!--lombok : 自动生成 get set 方法-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.8</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>jdbc-demo</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
        <!--maven插件-->
        <plugins>
            <!--jdk编译插件-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>utf-8</encoding>
                </configuration>
            </plugin>
            <!--tomcat插件-->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <!-- tomcat7的插件, 不同tomcat版本这个也不一样 -->
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <!-- 通过maven tomcat7:run运行项目时,访问项目的端口号 -->
                    <port>8080</port>
                    <!-- 项目访问路径  本例:localhost:9090,  如果配置的aa, 则访问路径为localhost:9090/aa-->
                    <path>/</path>
                </configuration>
            </plugin>

        </plugins>
    </build>

然后是druid 配置文件:

driverClassName = com.mysql.jdbc.Driver
url = jdbc:mysql:///school?characterEncoding=utf-8
username = root
password = root
initialSize=5
maxActive=10
maxWait=3000

同时为了能够访问到 Druid 的图形化界面,我们还需要在 web.xml 中配置一下它自带的Servlet,具体解释请看这篇文章 https://blog.csdn.net/weixin_43941364/article/details/105851395

<web-app>
    <display-name>Archetype Created Web Application</display-name>
    <!-- 配置 Druid 监控信息显示页面 -->
    <servlet>
        <servlet-name>DruidStatView</servlet-name>
        <servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
        <init-param>
            <!-- 允许清空统计数据 -->
            <param-name>resetEnable</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-param>
            <!-- 用户名 -->
            <param-name>loginUsername</param-name>
            <param-value>root</param-value>
        </init-param>
        <init-param>
            <!-- 密码 -->
            <param-name>loginPassword</param-name>
            <param-value>root</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>DruidStatView</servlet-name>
        <url-pattern>/druid/*</url-pattern>
    </servlet-mapping>
</web-app>

封装 Druid

我们使用 DruidUtils 类对 Druid 进行简单封装。

package top.wsuo.util;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.util.Properties;
import java.sql.*;

/**
 * Druid数据库连接池工具类
 *
 * @Author shuo wang
 * @Date 2020/4/29 0029 14:46
 * @Version 1.0
 */
public class DruidUtils {

    // 数据源
    private static DataSource dataSource;

    // 注册驱动,使用静态代码块,类一旦加载就会执行
    static {
        try {
            // 获取类对象,读取配置文件
            InputStream resource = DruidUtils
                    .class
                    .getClassLoader()
                    .getResourceAsStream("druid.properties");
            Properties properties = new Properties();
            properties.load(resource);
            dataSource = DruidDataSourceFactory
                    .createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnect() {
        try {
            return dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取连接池对象供commons使用
     *
     * @return 返回Druid连接池对象
     */
    public static DataSource getDataSource() {
        return dataSource;
    }

    /**
     * 释放2个资源
     *
     * @param conn      连接对象
     * @param statement statement对象
     */
    public static void close(Connection conn,
                             PreparedStatement statement) {
        assert conn != null;
        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }

        assert statement != null;
        try {
            statement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 释放3个资源
     *
     * @param conn      连接对象
     * @param statement statement对象
     * @param resultSet 返回结果集
     */
    public static void close(Connection conn,
                             PreparedStatement statement,
                             ResultSet resultSet) {

        close(conn, statement);
        assert resultSet != null;
        try {
            resultSet.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

封装 DBUtils

我们使用 BaseDao 对 DBUtils 进行简单封装。

  • 这里为什么要定义成一个抽象类呢 ?
    • 对于一个父类,如果它的某个方法在父类中实现出来没有任何意义
    • 必须根据子类的实际需求来进行不同的实现,就要定义为抽象类
    • 像我们的 BaseDao ,我们需要它根据自己的业务需求灵活的变化
    • 比如有时候需要查询 User 类,有时候需要 Student 类。

可以看到这个抽象类没有抽象方法:

  • 因为我们知道抽象类是不能创建实例的,所以我们定义为抽象类就隐含的限制了其它用户的行为,即:你不可以直接使用此类,必须使用其它给你提供好的实现类。该类的灵感来自于org.apache.commons.dbutils.AbstractQueryRunner类,他也是没有一个抽象方法的抽象类,但是他有两个子类,这就限制了我们必须使用其子类完成操作。

另外,这里考虑到事务的操作,所以我在这里定义了一个 updateCommit 方法,它使用独立的 Connect 对象,而 DBUtils 使用默认的 Connect 对象,他默认每一条 SQL 语句就是一次事务,但是我们有时候业务需求比如银行转账,肯定是要多条 SQL 语句合成一次事务。这样定义一个专门的 updateCommit 方法之后当需要事务的时候就直接调用即可,然后调用 commit 方法完成一次事务操作。

这里使用了反射的思想来获取子类的类型。

package top.wsuo.dao;

import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import top.wsuo.util.DruidUtils;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

/**
 * 定义一个用来被继承的对数据库进行基本操作的 Dao
 * 这里为什么要定义成一个抽象类呢 ?
 * - 对于一个父类,如果它的某个方法在父类中实现出来没有任何意义,
 * - 必须根据子类的实际需求来进行不同的实现,就要定义为抽象类
 * - 像我们的BaseDao,我们需要它根据自己的业务需求灵活的变化
 * - 比如有时候需要查询User类,有时候需要Student类
 *
 * @param <T>
 */
public abstract class BaseDao<T> {

    /*
     * 注意这里可以使用 QueryRunner 的两个构造方法来获取该对象
     *  - 一个是无参构造: 默认自己管理事务,因为框架没有连接池无法获得数据库连接
     *  - 另外一个是有参构造: 传入一个连接池对象,
     *    数据库事务交给DBUtils框架进行管理 ---- 默认情况下每条SQL语句单独一个事务。
     *
     * */

    // 使用 Druid 的连接池
    private QueryRunner queryRunner =
            new QueryRunner(DruidUtils.getDataSource());

    // 定义一个变量来接收泛型的类型
    private Class<T> type;

    // 获取T的Class对象,获取泛型的类型,泛型是在被子类继承时才确定
    public BaseDao() {

        // 获取子类的类型
        Class clazz = this.getClass();

        // 获取父类的类型,ParameterizedType表示的是带泛型的类型,
        // getGenericSuperclass()用来获取当前类的父类的类型
        ParameterizedType parameterizedType =
                (ParameterizedType) clazz.getGenericSuperclass();

        // 获取具体的泛型类型 getActualTypeArguments获取具体的泛型的类型,
        // 这个方法会返回一个Type的数组
        Type[] types =
                parameterizedType.getActualTypeArguments();

        // 获取具体的泛型的类型
        // noinspection unchecked
        this.type = (Class<T>) types[0];
    }

    /**
     * 手动提交事务
     * 通用的-增删改-操作, 但是一般只用于修改
     * 这里使用的是用户自定义的 Connection 对象,这样的话用户可以自己控制事务
     * 其他的查询方法不提供 Connection 对象,因为查询不涉及事务的操作.
     */
    public int updateCommit(Connection conn, String sql, Object... params) {
        int count = 0;
        try {
            count = queryRunner.update(conn, sql, params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return count;
    }


    /**
     * 数据的增删改
     * 默认一个SQL语句为一个事务,数据库事务交给DBUtils框架进行管理
     *
     * @param sql    SQL语句
     * @param params 执行参数
     * @return 返回受影响的行数
     */
    public int update(String sql, Object... params) {
        int count = 0;
        try {
            count = queryRunner.update(sql, params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return count;
    }

    /**
     * 自动提交事务的查询方法
     *
     * @param sql    SQL 语句
     * @param params 查询参数
     * @return 返回泛型
     */
    public T queryBean(String sql, Object... params) {
        T t = null;
        try {
            t = queryRunner
                    .query(sql, new BeanHandler<>(type), params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return t;
    }

    /**
     * 自动提交事务的查询所有方法
     *
     * @param sql    SQL 语句
     * @param params 查询参数
     * @return 返回泛型集合
     */
    public List<T> queryBeanList(String sql, Object... params) {
        List<T> list = null;
        try {
            list = queryRunner
                    .query(sql, new BeanListHandler<>(type), params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 自动提交事务的值查询
     *
     * @param sql    SQL 语句
     * @param params 参数
     * @return 返回数值如 count(*) sum(total) ...
     */
    public Object queryValue(String sql, Object... params) {
        Object count = null;
        try {
            count = queryRunner
                    .query(sql, new ScalarHandler<>(), params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return count;
    }

    /**
     * 处理事务提交与回滚
     *
     * @param connection 连接的对象
     */
    public void commit(Connection connection) {
        try {
            DbUtils.commitAndClose(connection);
        } catch (SQLException e) {
            System.out.println("事务提交失败!");
            DbUtils.rollbackAndCloseQuietly(connection);
            e.printStackTrace();
        }
    }
}

封装 Dao

首先定义一个接口UserDao

使用了 Page类,所以我们先介绍 Page 类:

package top.wsuo.pojo;

import java.util.List;

/**
 * 分页类
 *
 * @Author shuo wang
 * @Date 2020/4/30 0030 21:07
 * @Version 1.0
 */
public class Page<T> {
    private static final int PAGE_CURR = 1; // 当前页码
    private static final int PAGE_SIZE = 5; // 每页的数量

    private List<T> list;   // 实体类
    private Integer current;    // 当前页码
    private Integer size;   // 每页的条数
    private int totalRecord;    // 总记录数

    public Page(Integer current, Integer size) {
        this.current = current;
        this.size = size;
    }

    public List<T> getList() {
        return list;
    }

    public void setList(List<T> list) {
        this.list = list;
    }

    public Integer getCurrent() {
        return this.current;
    }

    public void setCurrent(Integer current) {
        this.current = current;
    }

    public Integer getSize() {
        return this.size;
    }

    public void setSize(Integer size) {
        this.size = size;
    }

    public int getTotalRecord() {
        return totalRecord;
    }

    public void setTotalRecord(int totalRecord) {
        this.totalRecord = totalRecord;
    }

    @Override
    public String toString() {
        return "Page{\n" +
                "\tlist=" + list +
                ",\n \t当前页码=" + current +
                ",\n \t每页的数量=" + size +
                ",\n \t总记录数=" + totalRecord +
                "\n}";
    }
}

Page 类很简单,只定义了几个分页必须的属性。

package top.wsuo.dao;

import top.wsuo.pojo.Page;
import top.wsuo.pojo.User;

import java.util.List;

/**
 * 用户接口类
 *
 * @author shuo wang
 * @version 1.0
 * @date 2020/4/30 0030 20:27
 */
public interface UserDao {
    /**
     * 根据User对象中的用户名和密码从数据库中获取一条记录
     */
    User queryUser(User user);

    /**
     * 根据User对象中的条件从数据库中获取多条记录
     */
    List<User> queryAll();

    /**
     * 分页从数据库中获取多条记录
     */
    Page<User> queryPageList(Page<User> page);

    /**
     * 根据User对象中的用户名从数据库中获取一条记录
     */
    boolean checkUsername(User user);

    /**
     * 向数据库中插入User对象
     */
    int saveUser(User user);

    /**
     * 向数据库中修改User对象
     */
    int updateUser(User user);

    /**
     * 向数据库中删除User对象
     */
    int deleteUser(int id);
}

再定义其实现类。

该类中定义 SQL 语句,如果我们又业务上的改变,可以直接修改此类而不用关心其余底层的 JDBC 操作,所以这是不使用框架比较好的实现,而如果使用反射就和框架更像了。

这里使用 limit 进行分页查询,在页数和页码处进行了相关操作。

package top.wsuo.dao.impl;

import top.wsuo.dao.BaseDao;
import top.wsuo.dao.UserDao;
import top.wsuo.pojo.Page;
import top.wsuo.pojo.User;
import top.wsuo.util.DruidUtils;

import java.sql.Connection;
import java.util.List;

/**
 * 用户操作的DAO实现类
 *
 * @Author shuo wang
 * @Date 2020/4/30 0030 21:02
 * @Version 1.0
 */
public class UserDaoImpl extends BaseDao<User> implements UserDao {

    /**
     * 根据姓名和密码查询用户,登陆时用
     *
     * @param user 用户
     * @return 返回用户
     */
    @Override
    public User queryUser(User user) {
        String sql = "select * from user where username = ? and password = ?";
        return queryBean(sql, user.getUsername(), user.getPassword());
    }

    /**
     * 查询所有
     *
     * @return 返回集合
     */
    @Override
    public List<User> queryAll() {
        String sql = "select * from user";
        return queryBeanList(sql);
    }

    /**
     * 分页查询
     *
     * @param page 分页
     * @return 返回分页对象
     */
    @Override
    public Page<User> queryPageList(Page<User> page) {
        //  where username like concat('%', ? '%')
        String sql2 = "select * from user limit ? offset ?";
        int size = page.getSize();
        int curr = page.getCurrent();
        List<User> userList = queryBeanList(sql2, size, (curr - 1) * size);
        page.setTotalRecord(queryAll().size());
        page.setList(userList);
        return page;
    }

    /**
     * 检查用户名是否存在
     *
     * @param user 用户对象
     * @return 返回布尔值
     */
    @Override
    public boolean checkUsername(User user) {
        return queryUser(user) != null;
    }

    /**
     * 保存用户到数据库
     *
     * @param user 用户
     * @return 返回受影响的行数
     */
    @Override
    public int saveUser(User user) {
        String sql = "insert into user(username, password, address, phone) " +
                "values(?,?,?,?);";
        return update(sql, user.getUsername(), user.getPassword(),
                user.getAddress(), user.getPhone());
    }


    /**
     * 处理事务的修改方法
     *
     * @param user 实体类
     * @return 受影响的行数
     */
    @Override
    public int updateUser(User user) {
        Connection connection = DruidUtils.getConnect();
        int i = updateCommit(connection, "update user set username = ?, password = ?, " +
                        "address = ?, phone = ?", user.getUsername(),
                user.getPassword(), user.getAddress(), user.getPhone());
//        updateCommit(connection, "语句二", user);
        commit(connection); // 提交事务
        return i;
    }

    /**
     * 根据id删除
     *
     * @return 返回受影响的行数
     */
    @Override
    public int deleteUser(int id) {
        String sql = "delete from user where id = ?";
        return update(sql, id);
    }
}

至此,所有持久层代码就都写完了。

测试

我们使用 Junit 进行测试:

package top.wsuo.dao;

import org.junit.Test;
import top.wsuo.dao.impl.UserDaoImpl;
import top.wsuo.pojo.Page;
import top.wsuo.pojo.User;

/**
 * 测试类
 *
 * @Author shuo wang
 * @Date 2020/4/30 0030 21:53
 * @Version 1.0
 */
public class DaoTest {

    private UserDaoImpl dao = new UserDaoImpl();

    /**
     * 保存数据测试方法
     */
    @Test
    public void saveTest() {
        User user = new User("test1",
                "123",
                "东北",
                "123456789");
        int i = dao.saveUser(user);
        System.out.println("插入成功: " + i);
    }

    /**
     * 查询用户
     */
    @Test
    public void queryUser() {
        User user = new User("test2",
                "123",
                "东北",
                "123456789");
        User user1 = dao.queryUser(user);
        System.out.println(user1);
    }

    /**
     * 分页查询测试方法
     */
    @Test
    public void pageTest() {
        Page<User> page = new Page<>(2,3);
        Page<User> pageList = dao.queryPageList(page);
        System.out.println(pageList);
    }

    /**
     * 修改测试方法
     */
    @Test
    public void updateTest() {
        User user = new User(
                "test6",
                "456",
                "吉林",
                "34234234"
        );
    }

    /**
     * 删除测试方法
     */
    @Test
    public void deleteTest() {
        int i = dao.deleteUser(1);
        System.out.println("删除成功: " + i);
    }
}

我们致力仅展示一下分页查询的查询结果。
在这里插入图片描述
查询结果:

Page{
	list=[User(id=5, username=test5, password=123, address=东北, phone=123456789), User(id=6, username=test6, password=123, address=东北, phone=123456789), User(id=7, username=test1, password=123, address=东北, phone=123456789)],
 	当前页码=2,
 	每页的数量=3,
 	总记录数=7
}

再去看数据库,查询正确:
在这里插入图片描述
至此一个使用 JDBC 操作数据库的简单模板就完成了。

  • 1
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
commons-dbutils包是Apache开源组织提供的用于操作数据库的工具包。简单来讲,这个工具包就是用来更加方便我们操作数据库的,最近工作中使用了一下,感觉确实方便很多,基本告别自己封装JDBC代码对数据库进行增删改查了。代码看着也很简洁。 例如: 增删改查使用的类:QueryRunner类+ResultSetHandler类,使用这俩类就可以解决掉。 QueryRunner类的query()方法:new QueryRunner().query(Connection conn, String sql, ResultSetHandler rsh) query方法后面参数中加一个Connection连接,是在获取不到数据源的情况下,也就是说,QueryRunner的实例化构造函数使用无参的那个,下面我的实现代码就是用的这种方法。 当然还有一种实例化:new QueryRunner(new Datasource()).query(String sql, ResultSetHandler rsh) query方法中的参数 ResultSetHandler 参数中加上ResultSetHandler接口的实现类参数(下面这些实现类),执行完SQL后,返回的数据就是已经封装好的我们想要的结果了。 ArrayHandler :将ResultSet中第一行的数据转化成对象数组 ArrayListHandler将ResultSet中所有的数据转化成List,List中存放的是Object[] BeanHandler :将ResultSet中第一行的数据转化成Bean对象 BeanListHandler :将ResultSet中所有的数据转化成List ColumnListHandler :将ResultSet中某一列的数据存成List KeyedHandler :将ResultSet中存成映射,key为某一列对应为Map,Map中存放的是数据 MapHandler :将ResultSet中第一行的数据存成Map MapListHandler :将ResultSet中所有的数据存成List<Map> ScalarHandler :将ResultSet中一条记录的其中某一列的数据存成Object
好的,我来回答你的问题。 首先,在Java中操作数据库需要使用JDBC技术,而DBCP是JDBC技术的一种实现方式,它是一个开源的数据库连接池。 使用DBCP连接池可以有效地管理数据库连接,避免频繁地创建和销毁连接,提高程序的性能和稳定性。 下面是使用DBCP连接池实现查询操作的代码: 1. 创建DBCP连接池 ```java import org.apache.commons.dbcp2.BasicDataSource; public class DBCPUtils { private static BasicDataSource dataSource; static { dataSource = new BasicDataSource(); dataSource.setDriverClassName("com.mysql.jdbc.Driver"); dataSource.setUrl("jdbc:mysql://localhost:3306/test"); dataSource.setUsername("root"); dataSource.setPassword("123456"); } public static BasicDataSource getDataSource() { return dataSource; } } ``` 2. 创建QueryState类 ```java import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; public class QueryState { public static User queryById(int id) throws SQLException { Connection conn = null; PreparedStatement pstmt = null; ResultSet rs = null; User user = null; try { conn = DBCPUtils.getDataSource().getConnection(); pstmt = conn.prepareStatement("SELECT * FROM users WHERE id = ?"); pstmt.setInt(1, id); rs = pstmt.executeQuery(); if (rs.next()) { user = new User(); user.setId(rs.getInt("id")); user.setName(rs.getString("name")); user.setPassword(rs.getString("password")); user.setEmail(rs.getString("email")); user.setBirthday(rs.getDate("birthday")); } } finally { if (rs != null) { rs.close(); } if (pstmt != null) { pstmt.close(); } if (conn != null) { conn.close(); } } return user; } } ``` 3. 创建User类 ```java import java.util.Date; public class User { private int id; private String name; private String password; private String email; private Date birthday; // 省略getter和setter方法 } ``` 4. 调用查询方法 ```java public static void main(String[] args) throws SQLException { User user = QueryState.queryById(1); System.out.println(user); } ``` 输出结果: ``` User{id=1, name='zhangs', password='123456', email='zs@sina.com', birthday=1980-12-04} ``` 以上就是使用DBCP连接池实现查询操作的完整代码。需要注意的是,使用完连接池后一定要关闭连接,否则会导致连接泄漏。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

硕子鸽

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

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

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

打赏作者

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

抵扣说明:

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

余额充值