devbox
神奇cpp
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：神奇cpp | 2024-08-19 13:22:35

赞

踩

java连接mysql工具类

一、连接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：
  1. private static final String URL = "jdbc:mysql://localhost:3306/db1";
  2. private static final String USER = "root";
  3. private static final String PASSWORD = "root";
  4.  
  5. ... ...
  6.  
  7. Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);
  • 方法2：
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1?user=root&password=root");
  • 方法3：
  1. Properties p = new Properties();
  2. p.setProperty("user","root");
  3. p.setProperty("password","root")
  4. Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1", p);

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

                 其中URL的构成：

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

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

Statement stat = conn.createStatement();

        8、执行SQL语句

        增删改：executeUpdate

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

        查：executeQuery

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

         方法解析：

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

      9、释放连接

  1. rs.close();
  2. stat.close();
  3. conn.close();

        完整代码：

  1. import java.sql.Connection;
  2. import java.sql.DriverManager;
  3. import java.sql.ResultSet;
  4. import java.sql.Statement;
  5.  
  6. public class Demo01 {
  7.     private static final String URL = "jdbc:mysql://localhost:3306/db1";
  8.     private static final String USER = "root";
  9.     private static final String PASSWORD = "root";
  10.  
  11.     public static void main(String[] args) throws Exception {
  12.         // 注册驱动
  13.         Class.forName("com.mysql.cj.jdbc.Driver");
  14.  
  15.         // 获取数据库连接对象
  16.         // 方法1
  17.         Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);
  18.         // 方法2
  19.         /*Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1?user=root&password=root");*/
  20.         // 方法3
  21.         /*
  22.         Properties p = new Properties();
  23.         p.setProperty("user","root");
  24.         p.setProperty("password","root")
  25.         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1", p);
  26.         */
  27.  
  28.         // 获取执行SQL语句的对象
  29.         Statement stat = conn.createStatement();
  30.  
  31.         // 执行SQL语句
  32.         stat.executeUpdate("insert into user value(1,'admin','root')");
  33.         stat.executeUpdate("update user set name = 'sunny' where id = 1");
  34.         stat.executeUpdate("delete from user where id = 1");
  35.  
  36.         ResultSet rs = stat.executeQuery("select * from user");
  37.         while (rs.next()) {
  38.             int id = rs.getInt("id");
  39.             String name = rs.getString("name");
  40.             String password = rs.getString("password");
  41.             System.out.println("id=" + id + ",name=" + name + ",password=" + password);
  42.         }
  43.  
  44.         // 释放连接
  45.         rs.close();
  46.         stat.close();
  47.         conn.close();
  48.     }
  49. }
  50.

二、编写使用工具类

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

        1、编写工具类 JdbcUtils.java

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

  1. import java.sql.*;
  2.  
  3. public class JdbcUtils {
  4.     private static final String driver = "com.mysql.cj.jdbc.Driver";
  5.     private static final String url = "jdbc:mysql://localhost:3306/db1";
  6.     private static final String name = "root";
  7.     private static final String password = "root";
  8.     private static final Connection conn;
  9.     
  10.     static {
  11.         try {
  12.             Class.forName(driver);
  13.             conn = DriverManager.getConnection(url, name, password);
  14.         } catch (ClassNotFoundException | SQLException e) {
  15.             throw new RuntimeException(e);
  16.         }
  17.     }
  18.  
  19.     /**
  20.      * 获取数据库连接对象
  21.      * @return 数据库连接对象
  22.      */
  23.     public static Connection getConnect() {
  24.         return conn;
  25.     }
  26.  
  27.     /**
  28.      * 关闭数据库相关资源
  29.      * @param conn 数据库连接对象
  30.      * @param ps sql语句执行对象
  31.      * @param rs 查询结果集
  32.      */
  33.     public static void close(Connection conn, PreparedStatement ps, ResultSet rs) {
  34.         try {
  35.             if (conn != null) conn.close();
  36.             if (ps != null) ps.close();
  37.             if (rs != null) rs.close();
  38.         } catch (SQLException e) {
  39.             throw new RuntimeException(e);
  40.         }
  41.     }
  42.  
  43.     /**
  44.      * 关闭数据库相关资源
  45.      * @param conn 数据库连接对象
  46.      * @param ps sql语句执行对象
  47.      */
  48.     public static void close(Connection conn, PreparedStatement ps) {
  49.         close(conn, ps, null);
  50.     }
  51.  
  52.     /**
  53.      * 关闭数据库相关资源
  54.      * @param conn 数据库连接对象
  55.      * @param rs 查询结果集
  56.      */
  57.     public static void close(Connection conn, ResultSet rs) {
  58.         close(conn, null, rs);
  59.     }
  60. }
  61.

        2、解耦代码

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

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

          jdbc.properties

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

        JdbcUtils.java

  1. import java.io.IOException;
  2. import java.sql.*;
  3. import java.util.Properties;
  4.  
  5. public class JdbcUtils {
  6.     private static final String driver;
  7.     private static final String url;
  8.     private static final String name;
  9.     private static final String password;
  10.  
  11.     static {
  12.         try {
  13.             Properties p = new Properties();
  14.             p.load(JdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties"));
  15.             driver = p.getProperty("driver");
  16.             url = p.getProperty("url");
  17.             name = p.getProperty("name");
  18.             password = p.getProperty("password");
  19.  
  20.             Class.forName(driver);
  21.         } catch (ClassNotFoundException | IOException e) {
  22.             throw new RuntimeException(e);
  23.         }
  24.     }
  25.  
  26.     /**
  27.      * 获取数据库连接对象
  28.      * @return 数据库连接对象
  29.      * @throws Exception 获取失败
  30.      */
  31.     public static Connection getConnect() throws Exception {
  32.         return DriverManager.getConnection(url, name, password);
  33.     }
  34.  
  35.     /**
  36.      * 关闭数据库相关资源
  37.      * @param conn 数据库连接对象
  38.      * @param ps sql语句执行对象
  39.      * @param rs 查询结果集
  40.      */
  41.     public static void close(Connection conn, PreparedStatement ps, ResultSet rs) {
  42.         try {
  43.             if (conn != null) conn.close();
  44.             if (ps != null) ps.close();
  45.             if (rs != null) rs.close();
  46.         } catch (SQLException e) {
  47.             throw new RuntimeException(e);
  48.         }
  49.     }
  50.  
  51.     /**
  52.      * 关闭数据库相关资源
  53.      * @param conn 数据库连接对象
  54.      * @param ps sql语句执行对象
  55.      */
  56.     public static void close(Connection conn, PreparedStatement ps) {
  57.         close(conn, ps, null);
  58.     }
  59.  
  60.     /**
  61.      * 关闭数据库相关资源
  62.      * @param conn 数据库连接对象
  63.      * @param rs 查询结果集
  64.      */
  65.     public static void close(Connection conn, ResultSet rs) {
  66.         close(conn, null, rs);
  67.     }
  68. }
  69.

       3、使用工具类

  1. import Utils.JdbcUtils;
  2.  
  3. import java.sql.Connection;
  4. import java.sql.ResultSet;
  5. import java.sql.Statement;
  6.  
  7. public class JdbcUtilsDemo {
  8.     public static void main(String[] args) throws Exception {
  9.         query();
  10.     }
  11.     public static void query() throws Exception {
  12.         Connection conn = JdbcUtils.getConnect();
  13.         Statement stat = conn.createStatement();
  14.  
  15.         ResultSet rs = stat.executeQuery("select * from user");
  16.         while (rs.next()) {
  17.             int id = rs.getInt("id");
  18.             String name = rs.getString("name");
  19.             String password = rs.getString("password");
  20.             System.out.println("id=" + id + ",name=" + name + ",password=" + password);
  21.         }
  22.  
  23.         JdbcUtils.close(conn, rs);
  24.     }
  25. }

三、使用数据库连接池

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

        1、简单的数据库连接池

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

  1. import Utils.JdbcUtils;
  2.  
  3. import java.sql.Connection;
  4. import java.util.LinkedList;
  5.  
  6. public class SimpleConnectPool {
  7.     private static LinkedList<Connection> pool = new LinkedList<>();
  8.  
  9.     static {
  10.         try {
  11.             for (int i = 1; i <= 5; i++) {
  12.                 // 获取数据库连接对象
  13.                 Connection conn = JdbcUtils.getConnect();
  14.                 // 将连接对象放到 pool 中
  15.                 pool.add(conn);
  16.             }
  17.         } catch (Exception e) {
  18.             System.out.println("数据库连接池初始化失败!");
  19.         }
  20.     }
  21.  
  22.     // 提供 获取数据库连接对象 的方法（pool删除）
  23.     public static synchronized Connection getConnect(){
  24.         if(pool.size() > 0){
  25.             return pool.removeFirst();
  26.         }
  27.         throw new RuntimeException("数据库连接池中 对象已用完");
  28.     }
  29.  
  30.     // 提供 归还数据库连接对象 的方法（pool添加）
  31.     public static void close(Connection conn){
  32.         pool.addLast(conn);
  33.     }
  34. }

        使用该连接池

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

        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 目录下。

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <c3p0-config>
  3.   <default-config>
  4.     <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
  5.     <property name="jdbcUrl">jdbc:mysql://localhost:3306/db1</property>
  6.     <property name="user">root</property>
  7.     <property name="password">root</property>
  8.     
  9.     <property name="initialPoolSize">5</property>
  10.     <property name="maxPoolSize">10</property>
  11.     <property name="checkoutTimeout">3000</property>
  12.   </default-config>
  13.  
  14.   <named-config name="otherc3p0"> 
  15.   </named-config>
  16. </c3p0-config>

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

  1. import com.mchange.v2.c3p0.ComboPooledDataSource;
  2.  
  3. import javax.sql.DataSource;
  4. import java.sql.Connection;
  5. import java.sql.SQLException;
  6.  
  7. public class C3P0Demo1 {
  8.     public static void main(String[] args) throws SQLException {
  9.         // 创建数据库连接池对象
  10.         DataSource dataSource = new ComboPooledDataSource();
  11.  
  12.         // 获取数据库连接对象
  13.         Connection conn = dataSource.getConnection();
  14.         System.out.println(conn);
  15.  
  16.         // 归还连接
  17.         conn.close();
  18.     }
  19. }

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

  1. import com.mchange.v2.c3p0.ComboPooledDataSource;
  2.  
  3. import java.beans.PropertyVetoException;
  4. import java.sql.Connection;
  5. import java.sql.SQLException;
  6.  
  7. public class C3P0Demo2 {
  8.     public static void main(String[] args) throws PropertyVetoException, SQLException {
  9.         // 创建数据库连接池对象
  10.         ComboPooledDataSource dataSource = new ComboPooledDataSource();
  11.  
  12.         // 配置参数信息
  13.         dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
  14.         dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/db1");
  15.         dataSource.setUser("root");
  16.         dataSource.setPassword("root");
  17.  
  18.         // 获取数据库连接对象
  19.         Connection conn = dataSource.getConnection();
  20.         System.out.println(conn);
  21.  
  22.         // 归还连接
  23.         conn.close();
  24.     }
  25. }

        3、使用 Druid 数据库连接池

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

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

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

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

  1. driverClassName=com.mysql.cj.jdbc.Driver
  2. url=jdbc:mysql://localhost:3306/db1
  3. username=root
  4. password=root
  5. initialSize=5
  6. maxActive=10
  7. maxWait=3000
  8.  
  9. filters=stat
  10. timeBetweenEvictionRunsMillis=60000
  11. minEvictableIdleTimeMillis=300000
  12. validationQuery=SELECT 1
  13. testWhileIdle=true
  14. testOnBorrow=false
  15. testOnReturn=false
  16. poolPreparedStatements=false
  17. maxPoolPreparedStatementPerConnectionSize=200

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

  1. import com.alibaba.druid.pool.DruidDataSourceFactory;
  2.  
  3. import javax.sql.DataSource;
  4. import java.sql.Connection;
  5. import java.util.Properties;
  6.  
  7. public class DruidDemo1 {
  8.     public static void main(String[] args) throws Exception {
  9.         // 创建数据库连接池对象
  10.         Properties p = new Properties();
  11.         p.load(DruidDemo1.class.getClassLoader().getResourceAsStream("druid.properties"));
  12.         DataSource dataSource = DruidDataSourceFactory.createDataSource(p);
  13.  
  14.         // 获取数据库连接对象
  15.         Connection conn = dataSource.getConnection();
  16.         System.out.println(conn);
  17.  
  18.         // 归还连接
  19.         conn.close();
  20.     }
  21. }

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

  1. import com.alibaba.druid.pool.DruidDataSource;
  2.  
  3. import java.sql.Connection;
  4.  
  5. public class DruidDemo2 {
  6.     public static void main(String[] args) throws Exception {
  7.         // 创建数据库连接池对象
  8.         DruidDataSource dataSource = new DruidDataSource();
  9.  
  10.         // 配置参数信息
  11.         dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
  12.         dataSource.setUrl("jdbc:mysql://localhost:3306/db1");
  13.         dataSource.setUsername("root");
  14.         dataSource.setPassword("root");
  15.  
  16.         // 获取数据库连接对象
  17.         Connection conn = dataSource.getConnection();
  18.         System.out.println(conn);
  19.  
  20.         // 归还连接
  21.         conn.close();
  22.     }
  23. }

         4、编写 Druid 工具类

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

  1. package Utils;
  2.  
  3. import com.alibaba.druid.pool.DruidDataSourceFactory;
  4.  
  5. import javax.sql.DataSource;
  6. import java.sql.Connection;
  7. import java.sql.PreparedStatement;
  8. import java.sql.ResultSet;
  9. import java.sql.SQLException;
  10. import java.util.Properties;
  11.  
  12. public class DruidUtils {
  13.     public static DataSource dataSource;
  14.  
  15.     static {
  16.         try {
  17.             Properties p = new Properties();
  18.             p.load(DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
  19.             dataSource = DruidDataSourceFactory.createDataSource(p);
  20.         } catch (Exception e) {
  21.             throw new RuntimeException(e);
  22.         }
  23.     }
  24.  
  25.     // 获取数据库连接池对象的方法
  26.     public static DataSource getDataSource() {
  27.         return dataSource;
  28.     }
  29.  
  30.     // 获取数据库连接对象的方法
  31.     public static Connection getConnection() throws Exception {
  32.         return dataSource.getConnection();
  33.     }
  34.  
  35.     // 归还数据库连接对象的方法
  36.     public static void close(Connection conn, PreparedStatement ps, ResultSet rs) {
  37.         try {
  38.             // 归还数据库连接对象
  39.             if (conn != null) conn.close();
  40.             // 释放sql语句执行对象
  41.             if (ps != null) ps.close();
  42.             // 释放查询结果集
  43.             if (rs != null) rs.close();
  44.         } catch (SQLException e) {
  45.             throw new RuntimeException(e);
  46.         }
  47.     }
  48. }

        使用：

  1. package Pool;
  2.  
  3. import Utils.DruidUtils;
  4.  
  5. import java.sql.Connection;
  6. import java.sql.PreparedStatement;
  7. import java.sql.ResultSet;
  8.  
  9. public class DruidUtilsDemo3 {
  10.     public static void main(String[] args) throws Exception {
  11.         // 获取数据库连接对象
  12.         Connection conn = DruidUtils.getConnection();
  13.  
  14.         // 获取执行sql语句执行对象
  15.         PreparedStatement ps = conn.prepareStatement("select * from user");
  16.  
  17.         // 执行sql语句,获得结果集
  18.         ResultSet rs = ps.executeQuery();
  19.  
  20.         // 解析结果集
  21.         while (rs.next()) {
  22.             int id = rs.getInt("id");
  23.             String name = rs.getString("name");
  24.             String password = rs.getString("password");
  25.             System.out.println("id=" + id + ",name=" + name + ",password=" + password);
  26.         }
  27.  
  28.         // 归还连接,释放sql语句执行对象、结果集
  29.         DruidUtils.close(conn,ps,rs);
  30.     }
  31. }

四、使用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 类，类中的字段 和 你的数据库里面的表 一一对应。这段代码推荐使用工具自动生成，尽量不要自己写。

  1. public class User {
  2.     private int id;
  3.     private String name;
  4.     private String password;
  5.  
  6.     public User() {
  7.     }
  8.     public User(int id, String name, String password) {
  9.         this.id = id;
  10.         this.name = name;
  11.         this.password = password;
  12.     }
  13.  
  14.     public void setId(int id) {
  15.         this.id = id;
  16.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  20.     public void setPassword(String password) {
  21.         this.password = password;
  22.     }
  23.  
  24.     public int getId() {
  25.         return id;
  26.     }
  27.     public String getName() {
  28.         return name;
  29.     }
  30.     public String getPassword() {
  31.         return password;
  32.     }
  33.  
  34.     @Override
  35.     public String toString() {
  36.         return "User{" + "id=" + id + ", name='" + name + '\'' + ", password='" + password + '\'' + '}';
  37.     }
  38. }

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

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

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

                C3P0:

DataSource dataSource = new ComboPooledDataSource();

                Druid:

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

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

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

JdbcTemplate jt = new JdbcTemplate(dataSource);

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

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

         (6)执行 sql 语句

                增删改：

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

                查：

  •  查询一条数据
  1. int id = 1; // 仅为简单示范
  2. User user = jt.queryForObject("select * from user where id = ?",new BeanPropertyRowMapper<>(User.class),id);
  3. System.out.println(user);
  • 查询多条记录
  1. List<User> users = jt.query("select * from user", new BeanPropertyRowMapper<>(User.class));
  2. for (User a : users) System.out.println(a);
  • 查询一个数据 : 查询 id=1 的 name 值
  1. int id = 1; // 仅为简单示范
  2. String name = jt.queryForObject("select name from user where id = ?", String.class, id);
  3. System.out.println(name);
  • 查询一个数据 : 查询表中有多少条记录
  1. int count = jt.queryForObject("select count(*) from user",int.class);
  2. System.out.println(count);

         (7)所有代码：

  1. import com.mchange.v2.c3p0.ComboPooledDataSource;
  2. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  3. import org.springframework.jdbc.core.JdbcTemplate;
  4.  
  5. import javax.sql.DataSource;
  6. import java.util.List;
  7.  
  8. public class JdbcTemplateDemo {
  9.     public static void main(String[] args) throws Exception {
  10.         // 1.创建数据库连接池对象
  11.         /* C3P0 */
  12.         DataSource dataSource = new ComboPooledDataSource();
  13.  
  14.         /* Druid */
  15.         /*
  16.         Properties p = new Properties();
  17.         p.load(JdbcTemplateDemo.class.getClassLoader().getResourceAsStream("druid.properties"));
  18.         DataSource dataSource = DruidDataSourceFactory.createDataSource(p);
  19.         */
  20.  
  21.  
  22.         // 2.创建 JdbcTemplate 对象,将数据库连接池封装到 JdbcTemplate 对象
  23.         /* 方法一 : 提供有参构造赋值 */
  24.         // JdbcTemplate jt = new JdbcTemplate(dataSource);
  25.  
  26.         /* 方法二 : 通过setDataSource赋值 */
  27.         JdbcTemplate jt = new JdbcTemplate();
  28.         jt.setDataSource(dataSource);
  29.  
  30.  
  31.         // 3.执行 sql 语句
  32.         /* 增删改 */
  33.         User user1 = new User(1,"admin","1234");  // 仅为简单示范
  34.         jt.update("insert into user value (?,?,?)", user1.getId(), user1.getName(),user1.getPassword());
  35.         jt.update("update user set name = ? where id = ?", user1.getName(), user1.getId());
  36.         jt.update("delete from user where id = ?", user1.getId());
  37.  
  38.         /* 查 */
  39.         // 查询一条数据
  40.         int id = 1; // 仅为简单示范
  41.         User user2 = jt.queryForObject("select * from user where id = ?",new BeanPropertyRowMapper<>(User.class),id);
  42.         System.out.println(user2);
  43.  
  44.         // 查询多条记录
  45.         List<User> users = jt.query("select * from user", new BeanPropertyRowMapper<>(User.class));
  46.         for (User a : users) System.out.println(a);
  47.  
  48.  
  49.         // 查询一个数据 : 查询 id=1 的 name 值
  50.         String name = jt.queryForObject("select name from user where id = ?", String.class, 1);
  51.         System.out.println(name);
  52.  
  53.         // 查询一个数据 : 查询表中有多少条记录
  54.         int count = jt.queryForObject("select count(*) from user",int.class);
  55.         System.out.println(count);
  56.     }
  57. }
  1. public class User {
  2.     private int id;
  3.     private String name;
  4.     private String password;
  5.  
  6.     public User() {
  7.     }
  8.     public User(int id, String name, String password) {
  9.         this.id = id;
  10.         this.name = name;
  11.         this.password = password;
  12.     }
  13.  
  14.     public void setId(int id) {
  15.         this.id = id;
  16.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  20.     public void setPassword(String password) {
  21.         this.password = password;
  22.     }
  23.  
  24.     public int getId() {
  25.         return id;
  26.     }
  27.     public String getName() {
  28.         return name;
  29.     }
  30.     public String getPassword() {
  31.         return password;
  32.     }
  33.  
  34.     @Override
  35.     public String toString() {
  36.         return "User{" + "id=" + id + ", name='" + name + '\'' + ", password='" + password + '\'' + '}';
  37.     }
  38. }

        3、实际项目中的使用

        项目结构：

         （1）UserDao类

  1. import java.util.List;
  2.  
  3. public interface UserDao {
  4.     // 添加用户
  5.     void add(User user);
  6.  
  7.     // 修改用户
  8.     void update(User user);
  9.  
  10.     // 删除用户
  11.     void delete(int id);
  12.  
  13.     // 查询所有
  14.     List<User> findAll();
  15.  
  16.     // 查询一条数据
  17.     User findById(int id);
  18. }

        （2）UserDaoImpl 类

  1. import Utils.DruidUtils;
  2. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  3. import org.springframework.jdbc.core.JdbcTemplate;
  4.  
  5. import java.util.List;
  6.  
  7. public class UserDaoImpl implements UserDao {
  8.     // 创建 JdbcTemplate 对象
  9.     private final JdbcTemplate jt = new JdbcTemplate(DruidUtils.getDataSource());
  10.  
  11.     @Override
  12.     public void add(User user) {
  13.         jt.update("insert into user values(?,?,?)", user.getId(), user.getName(), user.getPassword());
  14.     }
  15.  
  16.     @Override
  17.     public void update(User user) {
  18.         jt.update("update user set name = ?,password = ? where id = ?", user.getName(), user.getPassword(), user.getId());
  19.     }
  20.  
  21.     @Override
  22.     public void delete(int id) {
  23.         jt.update("delete from user where id = ?", id);
  24.     }
  25.  
  26.     @Override
  27.     public List<User> findAll() {
  28.         List<User> users = jt.query("select * from user", new BeanPropertyRowMapper<>(User.class));
  29.         return users;
  30.     }
  31.  
  32.     @Override
  33.     public User findById(int id) {
  34.         User user = jt.queryForObject("select * from user where id = ?", new BeanPropertyRowMapper<>(User.class), id);
  35.         return user;
  36.     }
  37. }

        （3）User 类

  1. import java.io.Serializable;
  2.  
  3. public class User implements Serializable {
  4.     private int id;
  5.     private String name;
  6.     private String password;
  7.  
  8.     public User() {
  9.     }
  10.     public User(int id, String name, String password) {
  11.         this.id = id;
  12.         this.name = name;
  13.         this.password = password;
  14.     }
  15.  
  16.     public void setId(int id) {
  17.         this.id = id;
  18.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  22.     public void setPassword(String password) {
  23.         this.password = password;
  24.     }
  25.  
  26.     public int getId() {
  27.         return id;
  28.     }
  29.     public String getName() {
  30.         return name;
  31.     }
  32.     public String getPassword() {
  33.         return password;
  34.     }
  35.  
  36.     @Override
  37.     public String toString() {
  38.         return "User{" + "id=" + id + ", name='" + name + '\'' + ", password='" + password + '\'' + '}';
  39.     }
  40. }

        （4）DruidUtils 类

  1. import com.alibaba.druid.pool.DruidDataSourceFactory;
  2.  
  3. import javax.sql.DataSource;
  4. import java.sql.Connection;
  5. import java.sql.PreparedStatement;
  6. import java.sql.ResultSet;
  7. import java.sql.SQLException;
  8. import java.util.Properties;
  9.  
  10. public class DruidUtils {
  11.     public static DataSource dataSource;
  12.  
  13.     static {
  14.         try {
  15.             Properties p = new Properties();
  16.             p.load(DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
  17.             dataSource = DruidDataSourceFactory.createDataSource(p);
  18.         } catch (Exception e) {
  19.             throw new RuntimeException(e);
  20.         }
  21.     }
  22.  
  23.     // 获取数据库连接池对象的方法
  24.     public static DataSource getDataSource() {
  25.         return dataSource;
  26.     }
  27.  
  28.     // 获取数据库连接对象的方法
  29.     public static Connection getConnection() throws Exception {
  30.         return dataSource.getConnection();
  31.     }
  32.  
  33.     // 归还数据库连接对象的方法
  34.     public static void close(Connection conn, PreparedStatement ps, ResultSet rs) {
  35.         try {
  36.             // 归还数据库连接对象
  37.             if (conn != null) conn.close();
  38.             // 释放sql语句执行对象
  39.             if (ps != null) ps.close();
  40.             // 释放查询结果集
  41.             if (rs != null) rs.close();
  42.         } catch (SQLException e) {
  43.             throw new RuntimeException(e);
  44.         }
  45.     }
  46. }

        （5）UserTest 类

  1. import org.junit.Test;
  2.  
  3. import java.util.List;
  4.  
  5. public class UserTest {
  6.     // 创建 Dao 对象
  7.     private final UserDao userDao = new UserDaoImpl();
  8.  
  9.     @Test
  10.     public void add() {
  11.         User user = new User(1, "ketty", "eee");
  12.         userDao.add(user);
  13.     }
  14.  
  15.     @Test
  16.     public void update() {
  17.         User user = new User(1, "hello", "root");
  18.         userDao.update(user);
  19.     }
  20.  
  21.     @Test
  22.     public void delete() {
  23.         userDao.delete(1);
  24.     }
  25.  
  26.     @Test
  27.     public void findAll() {
  28.         List<User> users = userDao.findAll();
  29.         for (User a : users) {
  30.             System.out.println(a);
  31.         }
  32.     }
  33.  
  34.     @Test
  35.     public void findById() {
  36.         User user = userDao.findById(1);
  37.         System.out.println(user);
  38.     }

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/神奇cpp/article/detail/1002448
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号