Java | 详解 Java连接MySQL、编写JdbcUtils工具类、使用数据库连接池、使用JavaTemplate

一、连接mysql数据库 1、启动 MySQL

以管理员身份打开 cmd 命令行，输入 net start mysql

mysql数据库工具_mysql数据库工具软件_mysql数据库设计工具

2、MySQL 创建表

创建一张 user 表，有id、name、三个字段。

3、导入jar包

(1) 创建新项目，在项目下创建lib包，用于存放所需要的jar包

mysql数据库设计工具_mysql数据库工具软件_mysql数据库工具

(2) 拷贝 mysql 驱动包mysql--j-8.0.31.jar 到 lib 目录下。

右键jar包，点击添加为库。

mysql数据库工具_mysql数据库工具软件_mysql数据库设计工具

添加后 jar 包旁出现一个小三角，可以点开查看里面的内容，此时导入成功。

mysql数据库工具_mysql数据库设计工具_mysql数据库工具软件

mysql 驱动 jar 包下载：

官网：

CSDN：mysql--j-8.0.31-Java文档类资源-CSDN文库

4、创建类 Demo01.java 5、注册驱动

Class.forName("com.mysql.cj.jdbc.Driver");

6、获取数据库连接对象

private static final String URL = "jdbc:mysql://localhost:3306/db1";
private static final String USER = "root";
private static final String PASSWORD = "root";
... ...
Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);

Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1?user=root&password=root");

Properties p = new Properties();
p.setProperty("user","root");
p.setProperty("password","root")
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1", p);

【注意】需要填写3个参数，分别是数据库连接URL、用户名、密码，需要填写你自己的。

其中URL的构成：

jdbc:mysql:// localhost:3306  /     db1
   协议         IP地址   端口  要连接的数据库名称

7、获取执行SQL语句的对象

Statement stat = conn.createStatement();

8、执行SQL语句增删改：

stat.executeUpdate("insert into user value(1,'admin','root')");
stat.executeUpdate("update user set name = 'sunny' where id = 1");
stat.executeUpdate("delete from user where id = 1");

查：

ResultSet rs = stat.executeQuery("select * from user");
while (rs.next()){
    int id = rs.getInt("id");
    String name = rs.getString("name");
    String password = rs.getString("password");
    System.out.println("id="+id+",name="+name+",password="+password);
}

方法解析：

9、释放连接

rs.close();
stat.close();
conn.close();

完整代码：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class Demo01 {
    private static final String URL = "jdbc:mysql://localhost:3306/db1";
    private static final String USER = "root";
    private static final String PASSWORD = "root";
    public static void main(String[] args) throws Exception {
        // 注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        // 获取数据库连接对象
        // 方法1
        Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);
        // 方法2
        /*Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1?user=root&password=root");*/
        // 方法3
        /*
        Properties p = new Properties();
        p.setProperty("user","root");
        p.setProperty("password","root")
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1", p);
        */
        // 获取执行SQL语句的对象
        Statement stat = conn.createStatement();
        // 执行SQL语句
        stat.executeUpdate("insert into user value(1,'admin','root')");
        stat.executeUpdate("update user set name = 'sunny' where id = 1");
        stat.executeUpdate("delete from user where id = 1");
        ResultSet rs = stat.executeQuery("select * from user");
        while (rs.next()) {
            int id = rs.getInt("id");
            String name = rs.getString("name");
            String password = rs.getString("password");
            System.out.println("id=" + id + ",name=" + name + ",password=" + password);
        }
        // 释放连接
        rs.close();
        stat.close();
        conn.close();
    }
}

二、编写使用工具类

观察上面的代码我们可以发现，除了执行SQL的语句有所不同外，其他代码的格式基本上都是固定的。我们可以编写一个工具类，提供获取数据库连接对象、关闭数据库相关资源等相关方法。

1、编写工具类 .java

创建 Utils 文件夹，将代码相关的工具类都放到里面。编写.java，代码首先运行静态代码块类的语句，获得数据库连接对象。

import java.sql.*;
public class JdbcUtils {
    private static final String driver = "com.mysql.cj.jdbc.Driver";
    private static final String url = "jdbc:mysql://localhost:3306/db1";
    private static final String name = "root";
    private static final String password = "root";
    private static final Connection conn;
    
    static {
        try {
            Class.forName(driver);
            conn = DriverManager.getConnection(url, name, password);
        } catch (ClassNotFoundException | SQLException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 获取数据库连接对象
     * @return 数据库连接对象
     */
    public static Connection getConnect() {
        return conn;
    }
    /**
     * 关闭数据库相关资源
     * @param conn 数据库连接对象
     * @param ps sql语句执行对象
     * @param rs 查询结果集
     */
    public static void close(Connection conn, PreparedStatement ps, ResultSet rs) {
        try {
            if (conn != null) conn.close();
            if (ps != null) ps.close();
            if (rs != null) rs.close();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 关闭数据库相关资源
     * @param conn 数据库连接对象
     * @param ps sql语句执行对象
     */
    public static void close(Connection conn, PreparedStatement ps) {
        close(conn, ps, null);
    }
    /**
     * 关闭数据库相关资源
     * @param conn 数据库连接对象
     * @param rs 查询结果集
     */
    public static void close(Connection conn, ResultSet rs) {
        close(conn, null, rs);
    }
}

2、解耦代码

分析工具类，可以发现关于数据库连接的相关参数，如 driver、url、user、等均写在代码中，程序的耦合性较高。可以将变量写在 .文件中，程序通过读取文件的方式获得相关信息。

首先创建 jdbc. 资源包，以 “ 键=值 ” 的形式写入相关参数。

mysql数据库设计工具_mysql数据库工具_mysql数据库工具软件

jdbc.

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/db1
name=root
password=root

.java

import java.io.IOException;
import java.sql.*;
import java.util.Properties;
public class JdbcUtils {
    private static final String driver;
    private static final String url;
    private static final String name;
    private static final String password;
    static {
        try {
            Properties p = new Properties();
            p.load(JdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties"));
            driver = p.getProperty("driver");
            url = p.getProperty("url");
            name = p.getProperty("name");
            password = p.getProperty("password");
            Class.forName(driver);
        } catch (ClassNotFoundException | IOException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 获取数据库连接对象
     * @return 数据库连接对象
     * @throws Exception 获取失败
     */
    public static Connection getConnect() throws Exception {
        return DriverManager.getConnection(url, name, password);
    }
    /**
     * 关闭数据库相关资源
     * @param conn 数据库连接对象
     * @param ps sql语句执行对象
     * @param rs 查询结果集
     */
    public static void close(Connection conn, PreparedStatement ps, ResultSet rs) {
        try {
            if (conn != null) conn.close();
            if (ps != null) ps.close();
            if (rs != null) rs.close();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 关闭数据库相关资源
     * @param conn 数据库连接对象
     * @param ps sql语句执行对象
     */
    public static void close(Connection conn, PreparedStatement ps) {
        close(conn, ps, null);
    }
    /**
     * 关闭数据库相关资源
     * @param conn 数据库连接对象
     * @param rs 查询结果集
     */
    public static void close(Connection conn, ResultSet rs) {
        close(conn, null, rs);
    }
}

3、使用工具类

import Utils.JdbcUtils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
public class JdbcUtilsDemo {
    public static void main(String[] args) throws Exception {
        query();
    }
    public static void query() throws Exception {
        Connection conn = JdbcUtils.getConnect();
        Statement stat = conn.createStatement();
        ResultSet rs = stat.executeQuery("select * from user");
        while (rs.next()) {
            int id = rs.getInt("id");
            String name = rs.getString("name");
            String password = rs.getString("password");
            System.out.println("id=" + id + ",name=" + name + ",password=" + password);
        }
        JdbcUtils.close(conn, rs);
    }
}

三、使用数据库连接池

数据库连接池是存储数据库连接对象的容器，你可以想象成一个已经提前装好数个连接对象的池子。当你需要连接对象时，可以直接从池子获取，用完归还即可。这样当程序在运行的时候，不用自己去创建数据库连接对象，从而提高了运行效率。常用的JDBC连接池有C3P0、Druid。

1、简单的数据库连接池

编写一个简陋的数据库连接池，用于理解原理。

import Utils.JdbcUtils;
import java.sql.Connection;
import java.util.LinkedList;
public class SimpleConnectPool {
    private static LinkedList pool = new LinkedList<>();
    static {
        try {
            for (int i = 1; i <= 5; i++) {
                // 获取数据库连接对象
                Connection conn = JdbcUtils.getConnect();
                // 将连接对象放到 pool 中
                pool.add(conn);
            }
        } catch (Exception e) {
            System.out.println("数据库连接池初始化失败!");
        }
    }
    // 提供 获取数据库连接对象 的方法（pool删除）
    public static synchronized Connection getConnect(){
        if(pool.size() > 0){

            return pool.removeFirst();
        }
        throw new RuntimeException("数据库连接池中 对象已用完");
    }
    // 提供 归还数据库连接对象 的方法（pool添加）
    public static void close(Connection conn){
        pool.addLast(conn);
    }
}

使用该连接池

import java.sql.Connection;
public class SimpleConnectPoolDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 6; i++) {
            Connection conn = SimpleConnectPool.getConnect();
            System.out.printf("第" + i + "次获取:" + conn+"\n");
            if (i == 3) {
                SimpleConnectPool.close(conn);
                System.out.printf("第" + i + "次归还:" + conn+"\n");
            }
        }
    }
}

2、使用 C3P0 数据库连接池

步骤：

（1）导入jar包。导入方式和mysql驱动包的导入一样，注意这次除了要导入一个jar包外，还需要导入一个 xml 配置文件，即如下2个文件。

mysql数据库工具软件_mysql数据库工具_mysql数据库设计工具

C3P0下载：c3p0-0.9.5.2-Java文档类资源-CSDN文库

（2）编写 c3p0-config.xml 配置文件。打开 c3p0-config.xml ，将里面与数据库连接相关的4个参数修改为自己的。C3P0会根据这个配置文件中的参数连接你的mysql数据库。

【注意】该配置文件需放在 src 目录下。



  
    com.mysql.cj.jdbc.Driver
    jdbc:mysql://localhost:3306/db1
    root
    root
    
    5
    10
    3000

（3）创建类，编写相关代码。

import com.mchange.v2.c3p0.ComboPooledDataSource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
public class C3P0Demo1 {
    public static void main(String[] args) throws SQLException {
        // 创建数据库连接池对象
        DataSource dataSource = new ComboPooledDataSource();
        // 获取数据库连接对象
        Connection conn = dataSource.getConnection();
        System.out.println(conn);
        // 归还连接
        conn.close();
    }
}

（4）你也可以不编写 c3p0-config.xml 配置文件，直接在代码中设置数据库连接相关参数。创建类，编写相关代码。

import com.mchange.v2.c3p0.ComboPooledDataSource;
import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.SQLException;
public class C3P0Demo2 {
    public static void main(String[] args) throws PropertyVetoException, SQLException {
        // 创建数据库连接池对象
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        // 配置参数信息
        dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/db1");
        dataSource.setUser("root");
        dataSource.setPassword("root");
        // 获取数据库连接对象
        Connection conn = dataSource.getConnection();
        System.out.println(conn);
        // 归还连接
        conn.close();
    }
}

3、使用 Druid 数据库连接池

（1）导入jar包。导入方式和mysql驱动包的导入一样，注意这次除了要导入一个jar包外，还需要导入一个配置文件，即如下2个文件。

mysql数据库工具_mysql数据库设计工具_mysql数据库工具软件

Druid下载：druid-1.0.9-Java文档类资源-CSDN文库

(2)编写 druid. 配置文件。打开 druid. ，将里面与数据库连接相关的参数修改为自己的。Druid会根据这个配置文件中的参数连接你的mysql数据库。

【注意】该配置文件需放在 src 目录下。

driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/db1
username=root
password=root
initialSize=5
maxActive=10
maxWait=3000
filters=stat
timeBetweenEvictionRunsMillis=60000
minEvictableIdleTimeMillis=300000
validationQuery=SELECT 1
testWhileIdle=true
testOnBorrow=false
testOnReturn=false
poolPreparedStatements=false
maxPoolPreparedStatementPerConnectionSize=200

（3）创建类，编写相关代码。

import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.sql.Connection;
import java.util.Properties;
public class DruidDemo1 {
    public static void main(String[] args) throws Exception {
        // 创建数据库连接池对象
        Properties p = new Properties();
        p.load(DruidDemo1.class.getClassLoader().getResourceAsStream("druid.properties"));
        DataSource dataSource = DruidDataSourceFactory.createDataSource(p);
        // 获取数据库连接对象
        Connection conn = dataSource.getConnection();
        System.out.println(conn);
        // 归还连接
        conn.close();
    }
}

（4）同样的，你也可以不编写 druid. 配置文件，直接在代码中设置数据库连接相关参数。创建类，编写相关代码。

import com.alibaba.druid.pool.DruidDataSource;
import java.sql.Connection;
public class DruidDemo2 {
    public static void main(String[] args) throws Exception {
        // 创建数据库连接池对象
        DruidDataSource dataSource = new DruidDataSource();
        // 配置参数信息
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/db1");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        // 获取数据库连接对象
        Connection conn = dataSource.getConnection();
        System.out.println(conn);
        // 归还连接
        conn.close();
    }
}

4、编写 Druid 工具类

当然，你可以像上面的一样编写 Druid 的工具类。工具类代码放在Utils 目录下。我这里使用的是编写配置文件的方式，配置文件不用改变。

package Utils;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;
public class DruidUtils {
    public static DataSource dataSource;
    static {
        try {
            Properties p = new Properties();
            p.load(DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            dataSource = DruidDataSourceFactory.createDataSource(p);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    // 获取数据库连接池对象的方法
    public static DataSource getDataSource() {
        return dataSource;
    }
    // 获取数据库连接对象的方法
    public static Connection getConnection() throws Exception {
        return dataSource.getConnection();
    }
    // 归还数据库连接对象的方法
    public static void close(Connection conn, PreparedStatement ps, ResultSet rs) {
        try {
            // 归还数据库连接对象
            if (conn != null) conn.close();
            // 释放sql语句执行对象
            if (ps != null) ps.close();
            // 释放查询结果集
            if (rs != null) rs.close();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

使用：

package Pool;
import Utils.DruidUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public class DruidUtilsDemo3 {
    public static void main(String[] args) throws Exception {
        // 获取数据库连接对象
        Connection conn = DruidUtils.getConnection();
        // 获取执行sql语句执行对象
        PreparedStatement ps = conn.prepareStatement("select * from user");
        // 执行sql语句,获得结果集
        ResultSet rs = ps.executeQuery();
        // 解析结果集
        while (rs.next()) {
            int id = rs.getInt("id");
            String name = rs.getString("name");
            String password = rs.getString("password");
            System.out.println("id=" + id + ",name=" + name + ",password=" + password);
        }
        // 归还连接,释放sql语句执行对象、结果集
        DruidUtils.close(conn,ps,rs);
    }
}

四、使用

是由Spring框架对JDBC进行封装的基于ORM思想的工具类，他可以帮助我们简化代码。

1.ORM 对象关系映射思想（Object Mapping）

以我们浏览网站为例，当我们向网站的服务器发送请求（例如登录操作），服务器会收到我们请求相关的信息（例如登录的用户名、密码）。ORM的思想是先将这些信息封装到一个名为user的类中，这个类中的字段比如id,name,等，会和数据库中表的列名一一对应。通过JDBC的解封装、反射等技术，将数据传递给数据库以及返回给服务器。

mysql数据库设计工具_mysql数据库工具_mysql数据库工具软件

2、简单使用

（1）导入jar包。需要导入5个包，包名如下：

mysql数据库工具_mysql数据库设计工具_mysql数据库工具软件

下载：-Java文档类资源-CSDN文库

（2）创建 User 类，类中的字段和你的数据库里面的表一一对应。这段代码推荐使用工具自动生成，尽量不要自己写。

public class User {
    private int id;
    private String name;
    private String password;
    public User() {
    }
    public User(int id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public String getPassword() {
        return password;
    }
    @Override
    public String toString() {
        return "User{" + "id=" + id + ", name='" + name + '\'' + ", password='" + password + '\'' + '}';
    }
}

【注意】不要忘记无参构造！不要忘记漏了setXXX()、getXXX()方法！

（3）创建类，编写相关代码

（4）创建数据库连接池对象（C3P0或者Druid）

C3P0:

DataSource dataSource = new ComboPooledDataSource();

Druid:

Properties p = new Properties();
p.load(JdbcTemplateDemo.class.getClassLoader().getResourceAsStream("druid.properties"));
DataSource dataSource = DruidDataSourceFactory.createDataSource(p);

（5）创建对象，将数据库连接池对象封装到对象

方式1：通过的有参构造赋值

mysql数据库工具软件_mysql数据库设计工具_mysql数据库工具

JdbcTemplate jt = new JdbcTemplate(dataSource);

方式2：通过的方法赋值

JdbcTemplate jt = new JdbcTemplate();
jt.setDataSource(dataSource);

(6)执行 sql 语句

增删改：

User user = new User(1,"admin","1234");
jt.update("insert into user value (?,?,?)",user.getId(),user.getName(),user.getPassword());
jt.update("update user set name = ? where id = ?", user.getName(), user.getId());
jt.update("delete from user where id = ?", user.getId());

查：

int id = 1; // 仅为简单示范
User user = jt.queryForObject("select * from user where id = ?",new BeanPropertyRowMapper<>(User.class),id);
System.out.println(user);

List users = jt.query("select * from user", new BeanPropertyRowMapper<>(User.class));
for (User a : users) System.out.println(a);

int id = 1; // 仅为简单示范
String name = jt.queryForObject("select name from user where id = ?", String.class, id);
System.out.println(name);

int count = jt.queryForObject("select count(*) from user",int.class);
System.out.println(count);

(7)所有代码：

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import javax.sql.DataSource;
import java.util.List;
public class JdbcTemplateDemo {
    public static void main(String[] args) throws Exception {
        // 1.创建数据库连接池对象
        /* C3P0 */
        DataSource dataSource = new ComboPooledDataSource();
        /* Druid */
        /*
        Properties p = new Properties();
        p.load(JdbcTemplateDemo.class.getClassLoader().getResourceAsStream("druid.properties"));
        DataSource dataSource = DruidDataSourceFactory.createDataSource(p);
        */
        // 2.创建 JdbcTemplate 对象,将数据库连接池封装到 JdbcTemplate 对象
        /* 方法一 : 提供有参构造赋值 */
        // JdbcTemplate jt = new JdbcTemplate(dataSource);
        /* 方法二 : 通过setDataSource赋值 */
        JdbcTemplate jt = new JdbcTemplate();
        jt.setDataSource(dataSource);
        // 3.执行 sql 语句
        /* 增删改 */
        User user1 = new User(1,"admin","1234");  // 仅为简单示范
        jt.update("insert into user value (?,?,?)", user1.getId(), user1.getName(),user1.getPassword());
        jt.update("update user set name = ? where id = ?", user1.getName(), user1.getId());
        jt.update("delete from user where id = ?", user1.getId());
        /* 查 */
        // 查询一条数据
        int id = 1; // 仅为简单示范
        User user2 = jt.queryForObject("select * from user where id = ?",new BeanPropertyRowMapper<>(User.class),id);
        System.out.println(user2);
        // 查询多条记录
        List users = jt.query("select * from user", new BeanPropertyRowMapper<>(User.class));
        for (User a : users) System.out.println(a);
        // 查询一个数据 : 查询 id=1 的 name 值
        String name = jt.queryForObject("select name from user where id = ?", String.class, 1);
        System.out.println(name);
        // 查询一个数据 : 查询表中有多少条记录
        int count = jt.queryForObject("select count(*) from user",int.class);
        System.out.println(count);
    }
}

public class User {
    private int id;
    private String name;
    private String password;
    public User() {
    }
    public User(int id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public String getPassword() {
        return password;
    }
    @Override
    public String toString() {
        return "User{" + "id=" + id + ", name='" + name + '\'' + ", password='" + password + '\'' + '}';
    }
}

3、实际项目中的使用

项目结构：

mysql数据库工具_mysql数据库设计工具_mysql数据库工具软件

mysql数据库设计工具_mysql数据库工具软件_mysql数据库工具

（1）UserDao类

import java.util.List;
public interface UserDao {
    // 添加用户
    void add(User user);
    // 修改用户
    void update(User user);
    // 删除用户
    void delete(int id);
    // 查询所有
    List findAll();
    // 查询一条数据
    User findById(int id);
}

（2）类

import Utils.DruidUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.List;
public class UserDaoImpl implements UserDao {
    // 创建 JdbcTemplate 对象
    private final JdbcTemplate jt = new JdbcTemplate(DruidUtils.getDataSource());
    @Override
    public void add(User user) {
        jt.update("insert into user values(?,?,?)", user.getId(), user.getName(), user.getPassword());
    }
    @Override
    public void update(User user) {
        jt.update("update user set name = ?,password = ? where id = ?", user.getName(), user.getPassword(), user.getId());
    }
    @Override
    public void delete(int id) {
        jt.update("delete from user where id = ?", id);
    }
    @Override
    public List findAll() {
        List users = jt.query("select * from user", new BeanPropertyRowMapper<>(User.class));
        return users;
    }
    @Override
    public User findById(int id) {
        User user = jt.queryForObject("select * from user where id = ?", new BeanPropertyRowMapper<>(User.class), id);
        return user;
    }
}

（3）User 类

import java.io.Serializable;
public class User implements Serializable {
    private int id;
    private String name;
    private String password;
    public User() {
    }
    public User(int id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public String getPassword() {
        return password;
    }
    @Override
    public String toString() {
        return "User{" + "id=" + id + ", name='" + name + '\'' + ", password='" + password + '\'' + '}';
    }
}

（4）类

import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;
public class DruidUtils {
    public static DataSource dataSource;
    static {
        try {
            Properties p = new Properties();
            p.load(DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            dataSource = DruidDataSourceFactory.createDataSource(p);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    // 获取数据库连接池对象的方法
    public static DataSource getDataSource() {
        return dataSource;
    }
    // 获取数据库连接对象的方法
    public static Connection getConnection() throws Exception {
        return dataSource.getConnection();
    }
    // 归还数据库连接对象的方法
    public static void close(Connection conn, PreparedStatement ps, ResultSet rs) {
        try {
            // 归还数据库连接对象
            if (conn != null) conn.close();
            // 释放sql语句执行对象
            if (ps != null) ps.close();
            // 释放查询结果集
            if (rs != null) rs.close();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

（5）类

import org.junit.Test;
import java.util.List;
public class UserTest {
    // 创建 Dao 对象
    private final UserDao userDao = new UserDaoImpl();
    @Test
    public void add() {
        User user = new User(1, "ketty", "eee");
        userDao.add(user);
    }
    @Test
    public void update() {
        User user = new User(1, "hello", "root");
        userDao.update(user);
    }
    @Test
    public void delete() {
        userDao.delete(1);
    }
    @Test
    public void findAll() {
        List users = userDao.findAll();
        for (User a : users) {
            System.out.println(a);
        }
    }
    @Test
    public void findById() {
        User user = userDao.findById(1);
        System.out.println(user);
    }

类中使用了 JUnit 的 @Test ，以便更快进行测试。你也可以在main方法中进行测试。

在线咨询

上一篇：微信小程序的微信开发者工具的快捷键查找和设置
下一篇：基于JavaScript的餐厅点餐系统微信小程序的设计与实现

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

整合营销服务商

Java | 详解 Java连接MySQL、编写JdbcUtils工具类、使用数据库连接池、使用JavaTemplate

您的项目需求