连接池&jdbcTemplate主要将 jdbcTemplate模板以及连接池 c3p0的使用

小灰灰 2022-04-06 01:37 350阅读 0赞

jar包需要自行下载  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDI0NTc4Nw_size_16_color_FFFFFF_t_70]  
1.将参数封装到配置文件中  
设置连接池配置参数：初始连接数、最大连接数、最长等待时间、最长空闲等待时间

<?xml version="1.0" encoding="UTF-8"?>
    <c3p0-config>
        
        <default-config>
            
            <property name="driverClass">com.mysql.jdbc.Driver</property>
            <property name="jdbcUrl">jdbc:mysql:///jdbctemplate?useUnicode=true&characterEncoding=utf8</property>
            <property name="user">root</property>
            <property name="password">123456</property>
    
            
            
            <property name="initialPoolSize">5</property>
            
            <property name="maxPoolSize">10</property>
            
            <property name="checkoutTimeout">2000</property>
        </default-config>
    
        
        <named-config name="otherc3p0">
            
            <property name="driverClass">com.mysql.jdbc.Driver</property>
            <property name="jdbcUrl">jdbc:mysql:///c3p0test</property>
            <property name="user">root</property>
            <property name="password">root</property>
    
            
            <property name="initialPoolSize">5</property>
            <property name="maxPoolSize">8</property>
            <property name="checkoutTimeout">1000</property>
        </named-config>
    </c3p0-config>

<table> 
 <thead> 
  <tr> 
   <th>常用参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>初始连接数</strong></td> 
   <td>连接池一开始已经创建好的连接数</td> 
  </tr> 
  <tr> 
   <td><strong>最大连接数</strong></td> 
   <td>连接池中最大的连接个数</td> 
  </tr> 
  <tr> 
   <td><strong>最长等待时间</strong></td> 
   <td>如果连接池中所有的连接对象都在使用，设置等待多久的时间，单位是毫秒。如果超时会抛出异常。</td> 
  </tr> 
  <tr> 
   <td><strong>最大空闲数</strong></td> 
   <td>设置最多有多少个没有使用的连接数</td> 
  </tr> 
  <tr> 
   <td><strong>命名配置</strong></td> 
   <td>可以跟句name属性连接多个数据库</td> 
  </tr> 
 </tbody> 
</table>

ComboPooledDataSource() 使用无参构造创建对象,会默认加载src文件夹下的c3p0-config.xml文件,并且默认会读取default-config下的配置信息.

ComboPooledDataSource(命名配置) 使用有参构造 可以将named-config name=“otherc3p0” 中的name值传递进去,会默认加载src文件夹下的c3p0-config.xml文件,并且会读取name对应下的配置信息.

**配置文件的要求**

1.  文件名：一定叫c3p0-config.xml
2.  路径：放在src目录下
3.  默认配置：
    
    如果是使用无参的构造方法实例化连接池对象的时候，使用的是默认配置
4.  命名配置： named-config
    
    可以指定多个命名配置，可以选择其中的任何一个配置。

**多个配置方案的好处：**

1.  可以连接不同的数据库，如：jdbctest,c3p0test
2.  可以连接不同厂商的数据库，如：mysql，oracle
3.  可以指定不同的连接池参数

**5) 创建数据源的实现类ComboPooledDataSource，使用默认配置**

#### 创建工具类 ####

经过使用c3p0连接池之后我们发现,之前JDBCUtils工具类已经不再适用,而且**现在我们每一次创建连接都会创建一个连接池对象**,要知道连接池对象是比连接对象更加耗费资源的.

所以我们需要对之前的工具类进行创建.

1.  创建私有静态数据源成员变量ComboPooledDataSource
2.  创建公有的得到数据源(ComboPooledDataSource)的方法getDataSource()
3.  创建得到连接对象的方法 getConnection()
4.  创建释放资源的方法 release()

package com.SiyualChen.day07;
    
    import com.mchange.v2.c3p0.ComboPooledDataSource;
    
    import javax.sql.DataSource;
    import java.sql.Connection;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    /**
     * 1. 创建私有静态数据源成员变量ComboPooledDataSource
     * 2. 创建公有的得到数据源(ComboPooledDataSource)的方法getDataSource()
     * 3. 创建得到连接对象的方法 getConnection()
     * 4. 创建释放资源的方法 release()
     */
    public class JDBCUtils {
        //1. 创建私有静态数据源成员变量ComboPooledDataSource
        private static final ComboPooledDataSource cpds = new ComboPooledDataSource();
        //2. 创建公有的得到数据源(ComboPooledDataSource)的方法getDataSource()
        public static DataSource getDataSource(){
            return cpds;
        }
        //3. 创建得到连接对象的方法 getConnection()
        public static Connection getConnection(){
            try {
                return cpds.getConnection();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return null;
        }
        //创建释放资源的方法 release()  2个参数
        public static void release(Statement stmt,Connection conn){
            if(stmt != null){
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                stmt= null;
            }
            if (conn != null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                conn= null;
            }
        }
        //创建释放资源的方法 release()  3个参数
        public static void release(ResultSet rs ,Statement stmt,Connection conn){
            if (rs != null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                rs= null;
            }
            release(stmt,conn);
        }
    
    
    }

#### 工具类的使用 ####

### 案例一(DDL创建表) ###

**方法介绍**

**public void execute(final String sql)** 执行DDL语句，没有返回值。参数是SQL语句

**需求:**

创建一个员工表id,name,gender,birthday

1.  id是主键，整数类型，自增长
2.  name是varchar(20)，非空
3.  性别是varchar(2)类型
4.  生日是date类型

**开发步骤**

1.  创建JdbcTemplate对象
2.  编写建表的SQL语句
3.  使用JdbcTemplate对象的execute()方法执行DDL语句

package com.SiyualChen.day07;
    
    import org.springframework.jdbc.core.JdbcTemplate;
    
    public class JDBCTemplateC3p001 {
        /**
         * **需求:向user表中插入1条记录**
         *
         * **步骤:**
         *
         * 1. 通过数据源的工具类得到一个连接对象
         * 2. 创建PreparedStatement语句，使用insert
         * 3. 执行executeUpdate()插入到数据库
         * 4. 释放资源
         * @param args
         */
        public static void main(String[] args) {
            //1. 创建JdbcTemplate对象
            JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());
            //2. 编写建表的SQL语句
            //准备sql语句
            //1)id是主键，整数类型，自增长
            //2)name是varchar(20)，非空
            //3)性别是varchar(20)类型
            //4)生日是date类型
            String sql = "create table employee(" +
                    "id int primary key auto_increment," +
                    "name varchar(20) not null," +
                    "sex varchar(20)," +
                    "birthday date);";
            //3. 使用JdbcTemplate对象的execute()方法执行DDL语句
            jdbcTemplate.execute(sql);
    
    
        }
    }

![创建结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDI0NTc4Nw_size_16_color_FFFFFF_t_70 1]

### 案例二(DML增删改) ###

**方法介绍**

**public int update(final String sql, Object…args)**

执行DML语句，增删改操作

返回：影响的行数

参数：

1.  SQL语句
2.  args是用来替换占位符的真实值，可变的参数

**案例需求**

向表中添加6条记录,修改编号为2的学生名字和生日,删除编号为6的记录.

**1) 创建JdbcTemplate对象**

**2) 编写SQL语句**

**3) 使用JdbcTemplate对象的update方法进行增删改的操作**

1.  每条update向表中添加1条记录，添加6条记录
2.  修改编号为2的学生名字和生日
3.  删除编号为6的记录

**代码实现**

由于涉及多次操作,我们可以将 JdbcTemplate 提出来

private static JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());

1.每条update向表中添加1条记录，添加6条记录

public static void insert() {
            jdbcTemplate.update("insert into employee values (null, ?,?,?)", "孙悟空", "男", "1999-12-10");
            jdbcTemplate.update("insert into employee values (null, ?,?,?)", "孙悟天", "男", "1999-12-10");
            jdbcTemplate.update("insert into employee values (null, ?,?,?)", "孙悟饭", "男", "1999-12-10");
            jdbcTemplate.update("insert into employee values (null, ?,?,?)", "龟仙人", "男", "1999-12-10");
            jdbcTemplate.update("insert into employee values (null, ?,?,?)", "牛魔王", "男", "1999-12-10");
            jdbcTemplate.update("insert into employee values (null, ?,?,?)", "18号", "女", "1997-12-10");
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDI0NTc4Nw_size_16_color_FFFFFF_t_70 2]

2.修改编号为2的学生名字和生日

public static void update() {
            jdbcTemplate.update("update employee set name=?,birthday=? where id=?","陈思源","1993-11-7",2);
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDI0NTc4Nw_size_16_color_FFFFFF_t_70 3]

3.删除编号为6的记录

public static void delect() {
            jdbcTemplate.update("delete  from employee where id =?",6);
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDI0NTc4Nw_size_16_color_FFFFFF_t_70 4]  
**DML总结**

JdbcTemplate的update方法用于执行DML语句。同时还可以在SQL语句中使用？占位，在update方法的Object… args可变参数中传入对应的参数

工具类的封装

package com.SiyualChen.day07;
    
    import com.mchange.v2.c3p0.ComboPooledDataSource;
    import org.springframework.jdbc.core.JdbcTemplate;
    
    import javax.sql.DataSource;
    
    public class JDBCTemplateUtils {
        private  static  final DataSource ds = new ComboPooledDataSource();
        public static JdbcTemplate getJdbcTemplate(){
            JdbcTemplate jdbcTemplate = new JdbcTemplate(ds);
            return jdbcTemplate;
        }
    }

### DQL查询语句 ###

#### API介绍 ####

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>query()</strong></td> 
   <td>通用的查询方法，有多个同名方法的重载，可以自定义查询结果集封装成什么样的对象。</td> 
  </tr> 
  <tr> 
   <td><strong>queryForMap()</strong></td> 
   <td>返回Map&lt;String,Object&gt;的查询结果，其中键是列名，值是表中对应的记录。用于查询结果只有1条记录的情况。如果结果集返回多条记录会出现异常.</td> 
  </tr> 
  <tr> 
   <td><strong>queryForObject()</strong></td> 
   <td>返回查询只有单一对象的结果，这个单一结果应该是简单的数据类型，如：Integer.class, Long.class,String.class,不能直接封装成JavaBean对象。 用于聚合函数的查询结果。</td> 
  </tr> 
  <tr> 
   <td><strong>queryForList()</strong></td> 
   <td>返回多条记录的查询结果，封装成一个List集合 默认List集合中的每个元素是Map对象，即List&lt;Map&lt;String,Object&gt;&gt; 如果要封装成List对象，使用query()方法。</td> 
  </tr> 
 </tbody> 
</table>

#### 一.查询一条数据存放至map ####

**查询一条记录封装成Map**

**需求:**

返回的结果集中如果只有一条记录，可以使用queryForMap()方法，将这条记录被封装成了Map对象

<table> 
 <thead> 
  <tr> 
   <th>作用</th> 
   <th>参数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>sql语句</td> 
   <td>sql</td> 
  </tr> 
  <tr> 
   <td>可变参数,用来接收sql语句中 <strong>?</strong> 的值</td> 
   <td>args</td> 
  </tr> 
 </tbody> 
</table>

**开发步骤**

1.  创建JdbcTemplate对象，传入数据源
2.  编写SQL语句
3.  使用JdbcTemplate对象的queryForMap()方法查询结果
4.  返回是一个Map对象

package com.SiyualChen.day07;
    
    import org.springframework.jdbc.core.JdbcTemplate;
    
    import java.util.Map;
    
    public class JDBCTemplateDemo01 {
        /**
         * 1. 创建JdbcTemplate对象，传入数据源
         * 2. 编写SQL语句
         * 3. 使用JdbcTemplate对象的queryForMap()方法查询结果
         * 4. 返回是一个Map对象
         * @param args
         */
        public static void main(String[] args) {
            JdbcTemplate jdbcTemplate = JDBCTemplateUtils.getJdbcTemplate();
            String sql = "select * from employee where id =?";
            Map<String, Object> map = jdbcTemplate.queryForMap(sql, 2);
            System.out.println(map);
    
    
        }
    }

运行结果

{id=2, name=陈思源, sex=男, birthday=1993-11-07}
    
    Process finished with exit code 0

#### 二.查询一条记录封装成bean(对象) ####

**需求**

查询id为1的一条记录封装成自定义的类

**分析**

使用queryForObject()查询1个学生，但queryForObject()必须要指定查询的结果集与JavaBean属性之间的对应关系，所以这个方法需要传递一个接口做为参数：RowMapper。

**RowMapper**

通过泛型传入要封装的Bean类 例如Student.

将结果集映射成一个实体JavaBean对象

**参数：**

**rs**:表示结果集

**rowNum**:表示结果集有多少条记录

我们需要重写这个方法，指定属性与列之间的映射关系，代码中可以使用匿名内部类。

**准备实体类**

代码

package com.SiyualChen.day07;
    
    import java.util.Date;
    
    public class Employee {
        private int id ;
        private String name;
        private String sex;
        private Date birthday;
    
        @Override
        public String toString() {
            return "Employee{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", sex='" + sex + '\'' +
                    ", birthday=" + birthday +
                    '}';
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public Date getBirthday() {
            return birthday;
        }
    
        public void setBirthday(Date birthday) {
            this.birthday = birthday;
        }
    }

**开发步骤**

1.  创建JdbcTemplate对象，传入数据源对象
2.  编写SQL语句
3.  使用JdbcTemplate对象的queryForObject ()方法查询结果，方法中传入一个接口的匿名内部类

package com.SiyualChen.day07;
    
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.jdbc.core.RowMapper;
    
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    public class JDBCTemplateDemo02 {
        /**
         * 1. 创建JdbcTemplate对象，传入数据源对象
         * 2. 编写SQL语句
         * 3. 使用JdbcTemplate对象的queryForObject ()方法查询结果，方法中传入一个接口的匿名内部类
         * @param args
         */
        public static void main(String[] args) {
            JdbcTemplate jdbcTemplate = JDBCTemplateUtils.getJdbcTemplate();
            String sql ="select * from employee where id=?";
            Employee employee = jdbcTemplate.queryForObject(sql, new RowMapper<Employee>() {
                @Override
                public Employee mapRow(ResultSet resultSet, int i) throws SQLException {
                    Employee employee = new Employee();
                    employee.setId(resultSet.getInt("id"));
                    employee.setName(resultSet.getString("name"));
                    employee.setSex(resultSet.getString("sex"));
                    employee.setBirthday(resultSet.getDate("birthday"));
    
                    return employee;
                }
            }, 2);
            System.out.println(employee);
    
        }
    }

运行结果

Employee{id=2, name='陈思源', sex='男', birthday=1993-11-07}
    
    Process finished with exit code 0

#### 三.查询一条记录封装成bean类(星星) ####

**需求**

**查询id为1的一条记录封装成自定义的类**

如果每个JavaBean都需要自己封装每个属性，那开发效率将大打折扣，所以Spring JDBC提供了这个接口的实现类BeanPropertyRowMapper，使用起来更加方便。只需要在构造方法中传入Employee.class类对象即可，它会自动封装所有同名的属性。请看另一种写法：

**使用BeanPropertyRowMapper实现类**

**构造方法**

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>mappedClass</td> 
   <td>传入bean类的字节码对象,底层运用反射将数据封装到当前bean类中.</td> 
  </tr> 
 </tbody> 
</table>

**开发步骤**

1.  创建JdbcTemplate对象，传入数据源对象
2.  编写SQL语句
3.  使用JdbcTemplate对象的queryForObject ()方法查询结果，方法中传入BeanPropertyRowMapper的实现类

**代码实现**

package com.SiyualChen.day07;
    
    import org.springframework.jdbc.core.BeanPropertyRowMapper;
    import org.springframework.jdbc.core.JdbcTemplate;
    
    /**
     *
     1. 创建JdbcTemplate对象，传入数据源对象
     2. 编写SQL语句
     3. 使用JdbcTemplate对象的queryForObject ()方法查询结果，方法中传入BeanPropertyRowMapper的实现类
     */
    public class JDBCTemplateDemo03 {
        public static void main(String[] args) {
            JdbcTemplate jdbcTemplate = JDBCTemplateUtils.getJdbcTemplate();
            String sql = "select * from employee where id=? ";
            Employee employee = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(Employee.class), 2);
            System.out.println(employee);
    
    
        }
    }

运行结果

Employee{id=2, name='陈思源', sex='男', birthday=1993-11-07 00:00:00.0}
    
    Process finished with exit code 0

#### 四.查询多条记录封装Bean（星星星） ####

**需求**

查询多条记录封装成List

这里需要使用**query**方法来实现

**BeanPropertyRowmapper实现了 RowMapper接口**

**可以将BeanPropertyRowmapper的对象作为参数传递给RowMapper – 多态**

**代码**

package com.SiyualChen.day07;
    
    import org.springframework.jdbc.core.BeanPropertyRowMapper;
    import org.springframework.jdbc.core.JdbcTemplate;
    
    import java.util.List;
    
    public class JDBCTempDemo04 {
        public static void main(String[] args) {
            JdbcTemplate jdbcTemplate = JDBCTemplateUtils.getJdbcTemplate();
            String sql = "select * from employee ";
    
            List<Employee> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Employee.class));
            for (Employee employee : query) {
                System.out.println(employee);
            }
        }
    }

运行结果

Employee{id=1, name='孙悟空', sex='男', birthday=1999-12-10 00:00:00.0}
    Employee{id=2, name='陈思源', sex='男', birthday=1993-11-07 00:00:00.0}
    Employee{id=3, name='孙悟饭', sex='男', birthday=1999-12-10 00:00:00.0}
    Employee{id=4, name='龟仙人', sex='男', birthday=1999-12-10 00:00:00.0}
    Employee{id=5, name='牛魔王', sex='男', birthday=1999-12-10 00:00:00.0}
    
    Process finished with exit code 0

#### 查询一列数据 ####

**需求:查询一列**

可以使用queryForList()方法，并且直接指定List中的每个元素的类型为String.class

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>sql</td> 
   <td>sql语句</td> 
  </tr> 
  <tr> 
   <td>elementType</td> 
   <td>要查询的数据的数据类型的字节码对象</td> 
  </tr> 
 </tbody> 
</table>

**代码**

package com.SiyualChen.day07;
    
            import org.springframework.jdbc.core.JdbcTemplate;
    
            import java.util.List;
            import java.util.Map;
    
    public class JDBCTemplateDemo04 {
        public static void main(String[] args) {
            JdbcTemplate jdbcTemplate = JDBCTemplateUtils.getJdbcTemplate();
            String sql = "select name from employee";
            List<String> list = jdbcTemplate.queryForList(sql, String.class);
            for (String s : list) {
                System.out.println(s);
            }
        }
    }

运行结果

孙悟空
    陈思源
    孙悟饭
    龟仙人
    牛魔王
    
    Process finished with exit code 0

#### 查询多列数据封装成List ####

**需求:查询学生的编号和姓名这两列，使用queryForList()方法，默认封装成List<Map<String,Object>>对象**

package com.SiyualChen.day07;
    
    import org.springframework.jdbc.core.JdbcTemplate;
    
    import java.util.List;
    import java.util.Map;
    
    public class JDBCTemplateDemo05 {
        public static void main(String[] args) {
            JdbcTemplate jdbcTemplate = JDBCTemplateUtils.getJdbcTemplate();
            String sql ="select id,name  from employee";
            List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
            for (Map<String, Object> map : maps) {
                System.out.println(map);
            }
        }
    }

运行结果

{id=1, name=孙悟空}
    {id=2, name=陈思源}
    {id=3, name=孙悟饭}
    {id=4, name=龟仙人}
    {id=5, name=牛魔王}
    
    Process finished with exit code 0

#### 七.查询所有数据封装成 List<Map<String,Object>> ####

**需求**

查询所有的员工，封装成List<Map<String,Object>>,使用queryForList()方法查询

package com.SiyualChen.day07;
    
    import org.springframework.jdbc.core.JdbcTemplate;
    
    import java.util.List;
    import java.util.Map;
    
    public class JDBCTemplateDemo06 {
        public static void main(String[] args) {
            JdbcTemplate jdbcTemplate = JDBCTemplateUtils.getJdbcTemplate();
            String sql = "select * from employee";
    
            List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
            for (Map<String, Object> map : maps) {
                System.out.println(map);
            }
        }
    }

运行结果

{id=1, name=孙悟空, sex=男, birthday=1999-12-10}
    {id=2, name=陈思源, sex=男, birthday=1993-11-07}
    {id=3, name=孙悟饭, sex=男, birthday=1999-12-10}
    {id=4, name=龟仙人, sex=男, birthday=1999-12-10}
    {id=5, name=牛魔王, sex=男, birthday=1999-12-10}
    
    Process finished with exit code 0

#### 案例八-聚合函数 ####

**需求：**

查询一共有多少个员工，使用queryForObject()方法，指定参数为Integer.class类型

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>sql</td> 
   <td>sql语句</td> 
  </tr> 
  <tr> 
   <td>requiredType</td> 
   <td>返回的数据类型的字节码对象</td> 
  </tr> 
 </tbody> 
</table>

**代码**

package com.SiyualChen.day07;
    
    import org.springframework.jdbc.core.JdbcTemplate;
    
    public class JDBCTemplateDemo07 {
        public static void main(String[] args) {
            JdbcTemplate jdbcTemplate = JDBCTemplateUtils.getJdbcTemplate();
            String sql = "select count(*) from employee";
            Integer integer = jdbcTemplate.queryForObject(sql, Integer.class);
            System.out.println(integer);
        }
    }

运行结果

5
    
    Process finished with exit code 0

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDI0NTc4Nw_size_16_color_FFFFFF_t_70]: /images/20220406/10d8476dc2d64daab90c76b22e91e2d4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDI0NTc4Nw_size_16_color_FFFFFF_t_70 1]: /images/20220406/ad0e7529290c4468ac52761ce172ad9c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDI0NTc4Nw_size_16_color_FFFFFF_t_70 2]: /images/20220406/a1fcaebd1a554c43b91a763fff188c6b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDI0NTc4Nw_size_16_color_FFFFFF_t_70 3]: /images/20220406/c6d581dc458f4d909dc050f34ee215cc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDI0NTc4Nw_size_16_color_FFFFFF_t_70 4]: /images/20220406/11051c7da06649e497dfe9ac6c7e1283.png