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

一、连接mysql数据库

        步骤：

        1、启动 MySQL ：以管理员身份打开 cmd 命令行，输入 net start mysql

        2、在 MySQL 创建一张表，用于后面的操作。我这里创建了一张 user 表，有id、name、password三个字段。

        3、导入jar包

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

         (2)拷贝 mysql 驱动包 mysql-connector-j-8.0.31.jar 到 lib 目录下。右键jar包，点击 添加为库。

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

mysql 驱动 jar 包下载：

        官网：https://dev.mysql.com/downloads/

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

        4、创建类 Demo01.java,用于编写数据库连接的代码

        5、注册驱动

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

        6、获取数据库连接对象
        方法1：

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

        方法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);

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

                 其中URL的构成：

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

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

Statement stat = conn.createStatement();

        8、执行SQL语句

        增删改：executeUpdate

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

        查：executeQuery

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.next —— 判断结果集是否有下一条记录，返回boolean类型。
• rs.getInt  —— 可以传入String或者int类型的参数，String类型的参数为数据表的对应列名，int类型的参数则为数据表的对应列数，推荐传入String类型。返回int类型的数据。
• rs. getString  —— 可以传入String或者int类型的参数，String类型的参数为数据表的对应列名，int类型的参数则为数据表的对应列数，推荐传入String类型。返回String类型的数据。

      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、编写工具类 JdbcUtils.java

        创建 Utils 文件夹，将代码相关的工具类都放到里面。编写JdbcUtils.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、password 等均写在代码中，程序的耦合性较高。可以将变量写在 .properties文件中，程序通过读取文件的方式获得相关信息。

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

          jdbc.properties

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

        JdbcUtils.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<Connection> 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个文件。        

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

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

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

<?xml version="1.0" encoding="utf-8"?>
<c3p0-config>
  <default-config>
    <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/db1</property>
    <property name="user">root</property>
    <property name="password">root</property>
    
    <property name="initialPoolSize">5</property>
    <property name="maxPoolSize">10</property>
    <property name="checkoutTimeout">3000</property>
  </default-config>

  <named-config name="otherc3p0"> 
  </named-config>
</c3p0-config>

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

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 配置文件，直接在代码中设置数据库连接相关参数。创建 C3P0Demo2 类，编写相关代码。

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包外，还需要导入一个 properties 配置文件，即如下2个文件。        

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

                (2)编写 druid.properties 配置文件。打开 druid.properties ，将里面与数据库连接相关的参数修改为自己的。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）创建 DruidDemo1 类，编写相关代码。

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.properties 配置文件，直接在代码中设置数据库连接相关参数。创建 DruidDemo2 类，编写相关代码。

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 工具类

        当然，你可以像上面的 JdbcUtils 一样编写 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);
    }
}

四、使用JavaTemplate

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

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

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

        2、简单使用

        步骤：

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

 JavaTemplate下载：JdbcTemplate-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）创建 JdbcTemplateDemo 类，编写相关代码

        （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）创建JdbcTemplate对象，将数据库连接池对象封装到JdbcTemplate对象

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

JdbcTemplate jt = new JdbcTemplate(dataSource);

                方式2：通过JdbcTemplate的setDataSource方法赋值

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<User> users = jt.query("select * from user", new BeanPropertyRowMapper<>(User.class));
for (User a : users) System.out.println(a);

• 查询一个数据 : 查询 id=1 的 name 值

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<User> 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、实际项目中的使用

        项目结构：

         （1）UserDao类

import java.util.List;

public interface UserDao {
    // 添加用户
    void add(User user);

    // 修改用户
    void update(User user);

    // 删除用户
    void delete(int id);

    // 查询所有
    List<User> findAll();

    // 查询一条数据
    User findById(int id);
}

        （2）UserDaoImpl 类

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<User> findAll() {
        List<User> 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）DruidUtils 类

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）UserTest 类

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<User> users = userDao.findAll();
        for (User a : users) {
            System.out.println(a);
        }
    }

    @Test
    public void findById() {
        User user = userDao.findById(1);
        System.out.println(user);
    }

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