DbUtils的一个操作类

合集下载

黑马程序员小鲁哥哥白话笔记-DBUtils

小鲁哥哥白话笔记-DBUtils上一篇里我们聊了关于Properties配置文件的相关内容，今天我们和大家聊一聊关于DBUtils工具类的使用。

在说DBUtils工具类之前我们先给大家介绍一下什么是JavaBean类。

JavaBean：JavaBean就是一个类，在开发中常用封装数据。

具有如下特性：1.需要实现接口：java.io.Serializable ，通常实现接口这步骤省略了，不会影响程序。

2. 提供私有字段：private 类型字段名;3. 提供getter/setter方法：4. 提供无参构造DBUtils工具类：DButils工具类的介绍个三个核心类：* DBUtils是java编程中的数据库操作实用工具，小巧简单实用。

* DBUtils封装了对JDBC的操作，简化了JDBC操作，可以少写代码。

* DBUtils就是JDBC的简化开发工具包。

需要项目导入commons-dbutils-1.6.jar才能够正常使用DBUtils工具。

Dbutils三个核心功能介绍：* QueryRunner中提供对sql语句操作的API.* update(Connection conn, String sql, Object... params) ，用来完成表数据的增加、删除、更新操作* query(Connection conn, String sql, ResultSetHandler<T>rsh, Object... params) ，用来完成表数据的查询操作* ResultSetHandler接口，用于定义select操作后，怎样封装结果集.* DbUtils类，它就是一个工具类,定义了关闭资源与事务处理的方法QueryRunner类的update方法介绍：* update(Connection conn, String sql, Object... params) ，用来完成表数据的增加、删除、更新操作* 使用QueryRunner类,实现对数据表的insert delete update* 调用QueryRunner类的方法update (Connection con,Stringsql,Object...param) * Object...param 可变参数,Object类型,SQL语句会出现?占位符* 数据库连接对象,自定义的工具类传递QueryRunner类实现insert添加数据：案例代码：public class QueryRunnerDemo {private static Connection con = JDBCUtilsConfig.getConnection();public static void main(String[] args)throws SQLException {insert();}/** 定义方法,使用QueryRunner类的方法update向数据表中,添加数据*/public static void insert()throws SQLException{//创建QueryRunner类对象QueryRunnerqr = new QueryRunner();String sql = "INSERT INTO sort (sname,sprice,sdesc)VALUES(?,?,?)"; //将三个?占位符的实际参数,写在数组中Object[] params = {"体育用品",289.32,"购买体育用品"};//调用QueryRunner类的方法update执行SQL语句int row = qr.update(con, sql, params);System.out.println(row);DbUtils.closeQuietly(con);}}QueryRunner类实现update修改数据：案例代码public class QueryRunnerDemo {private static Connection con = JDBCUtilsConfig.getConnection();public static void main(String[] args)throws SQLException {update();}/** 定义方法,使用QueryRunner类的方法update将数据表的数据修改*/public static void update()throws SQLException{//创建QueryRunner类对象QueryRunnerqr = new QueryRunner();//写修改数据的SQL语句String sql = "UPDATE sort SET sname=?,sprice=?,sdesc=? WHERE sid=?";//定义Object数组,存储?中的参数Object[] params = {"花卉",100.88,"情人节玫瑰花",4};//调用QueryRunner方法updateint row = qr.update(con, sql, params);System.out.println(row);DbUtils.closeQuietly(con);}}QueryRunner类实现delete删除数据：案例代码public class QueryRunnerDemo {private static Connection con = JDBCUtilsConfig.getConnection();public static void main(String[] args)throws SQLException {delete();}/** 定义方法,使用QueryRunner类的方法delete将数据表的数据删除*/public static void delete()throws SQLException{//创建QueryRunner类对象QueryRunnerqr = new QueryRunner();//写删除的SQL语句String sql = "DELETE FROM sort WHERE sid=?";//调用QueryRunner方法updateint row = qr.update(con, sql, 8);System.out.println(row);/** 判断insert,update,delete执行是否成功* 对返回值row判断* if(row>0) 执行成功*/DbUtils.closeQuietly(con);}}DBUtils工具类结果集处理的方式：* a: QueryRunner实现查询操作* query(Connection conn, String sql, ResultSetHandler<T>rsh, Object... params) ，用来完成表数据的查询操作* b: ResultSetHandler结果集处理类* ArrayHandler 将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值* ArrayListHandler 将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。

如何使用DBUtils

如何使用DBUtils?1.什么是DBUtils？Commons DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，由于JDBC 资源清理非常的繁琐且容易出错，使用它能够简化JDBC应用程序的开发，抽出复杂重复的代码，同时也不会影响程序的性能，便于编程人员进行数据库的操作。

2.DBUtils的优点1）DBUtils对JDBC的编程步骤进行简单的封装，只需要提供连接池对象或者是连接对象即可；2）对于数据表的读操作，它可以把结果转换成List，Array等java对象，便于程序员操作；3）对于数据表的写操作，也变得很简单（只需写sql语句）。

3. DbUtils中的核心组件* QueryRunner，替换了原生jdbc中的语句平台(Statement 以及PreparedStatement),是用来简化SQL语句操作的，可以连接参数，可以有效的防止sql注入。

* ResultSetHandler，这个接口是针对于封装查询结果集的，用于定义select操作后面，怎么样进行封装及结果集。

它还提供了八大结果集实现类，可以保证不管是单行单列、多行多列、单列多行、单行多列都有对应的结果集。

* DbUtils，主要用来释放资源、处理事务。

但需要注意的是DbUtils类是一个工具类，定义了关闭资源与事务处理的方法。

4. 核心组件简介QueryRunner1）QueryRunner(DataSource ds):传入参数为连接池，返回QueryRuner对象2）update(String sql，Object params):执行insert update delete操作(创建，修改，删除等操作)注解：括号内的是sql语句和sql语句当中的问号指定的值3）query(String sql，ResultSetHandler rsh，Object…params):执行select操作注解：ResultSetHandler rsh是用来将查询结果封装成对象简要说明:QueryRunner的update()方法可以用来执行insert、update、delete语句。

commons-dbutils使用介绍,commons-dbutils是JDBC的替代品

commons-dbutils使⽤介绍,commons-dbutils是JDBC的替代品commons-dbutils是Apache开源组织提供的⽤于操作数据库的⼯具包。

今天为⼤家介绍⼀下该包的常⽤⽅法。

对于数据库的操作⽆外乎增删改查，⽽增删改本质上可以归为⼀类，操作⽅式相同，只是SQL语法不同⽽已，所以我将以修改和查询两类来介绍commons-dbutils的⽤法。

⾸先我们来创建⼀个测试类，使⽤JUnit进⾏测试。

import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;import mons.dbutils.DbUtils;import mons.dbutils.QueryRunner;import org.junit.After;import org.junit.Before;import org.junit.Test;public class DBUtilsTest{private Connection conn = null;@Beforepublic void initConnection() throws SQLException, ClassNotFoundException{printCurrentMethodName();Class.forName("org.h2.Driver");conn = DriverManager.getConnection("jdbc:h2:h2.db", "test", "123");}@Beforepublic void initDatabase() throws SQLException{printCurrentMethodName();QueryRunner runner = new QueryRunner();runner.update(conn,"CREATE TABLE IF NOT EXISTS USER_INFO (userId VARCHAR(20) PRIMARY KEY, userName VARCHAR(50))");}@Afterpublic void destory(){printCurrentMethodName();DbUtils.closeQuietly(conn);}/*** 打印当前运⾏⽅法名称*/public void printCurrentMethodName(){System.out.println(Thread.currentThread().getStackTrace()[2].getMethodName());System.out.println("==================================================");}}在这段测试代码中，我们是⽤h2作为数据库进⾏测试以及定义了⼀些连接、数据库的初始化及销毁的⽅法。

黑马程序员：DBUtils讲义(汇总).doc

黑马程序员：DBUtils讲义今日内容介绍◆Properties配置文件◆DBUtils第1章properties配置文件1.1使用properties配置文件开发中获得连接的4个参数（驱动、URL、用户名、密码）通常都存在配置文件中，方便后期维护，程序如果需要更换数据库，只需要修改配置文件即可。

通常情况下，我们习惯使用properties文件，此文件我们将做如下要求：1.文件位置：任意，建议src下2.文件名称：任意，扩展名为properties3.文件内容：一行一组数据，格式是“key=value”.a)key命名自定义，如果是多个单词，习惯使用点分隔。

例如：jdbc.driverb)value值不支持中文，如果需要使用非英文字符，将进行unicode转换。

1.2创建配置文件在项目跟目录下，创建文件，输入“db.properties”文件名。

●文件中的内容driver=com.mysql.jdbc.Driverurl=jdbc:mysql://localhost:3306/mydbuser=rootpassword=root1.3加载配置文件：Properties对象对应properties文件处理，开发中也使用Properties对象进行。

我们将采用加载properties文件获得流，然后使用Properties对象进行处理。

JDBCUtils.java中编写代码public class JDBCUtils {private static String driver;private static String url;private static String user;private static String password;// 静态代码块static {try {// 1 使用Properties处理流// 使用load()方法加载指定的流Properties props = new Properties();Reader is = new FileReader("db.properties");props.load(is);// 2 使用getProperty(key)，通过key获得需要的值，driver = props.getProperty("driver");url = props.getProperty("url");user = props.getProperty("user");password = props.getProperty("password");} catch (Exception e) {throw new RuntimeException(e);}}/*** 获得连接*/public static Connection getConnection() {try {// 1 注册驱动Class.forName(driver);// 2 获得连接Connection conn = DriverManager.getConnection(url, user, password);return conn;} catch (Exception e) {throw new RuntimeException(e);}}}1.4使用JDBCUtils工具类测试类public class Demo {@Testpublic void insert(){try{//1,获取连接对象Connection conn = JDBCUtils.getConnection();//2,指定要执行的SQL语句String sql = "INSERT INTO zhangwu(name,money,parent) VALUES(?,?,?)";//4，获取SQL语句的执行对象PreparedStatementPreparedStatement ppstat = conn.prepareStatement(sql);//5,执行SQL语句ppstat.setString(1, "股票收入");ppstat.setDouble(2, 5000);ppstat.setString(3, "收入");int line = ppstat.executeUpdate();//6,处理结果集System.out.println("line=" + line);//7,关闭连接ppstat.close();conn.close();} catch(SQLException e){throw new RuntimeException(e);}}}第2章DBUtils如果只使用JDBC进行开发，我们会发现冗余代码过多，为了简化JDBC开发，本案例我们讲采用apache commons组件一个成员：DBUtils。

dbutil 参数

dbutil 参数
DBUtil是一个常见的数据库连接工具类，用于简化数据库操作。

它通常包含一些参数，用于配置数据库连接和操作。

1. 数据库驱动参数，DBUtil需要指定数据库驱动程序，以便
正确加载和使用数据库。

这个参数通常是一个字符串，指定数据库
驱动的类名或JDBC URL。

2. 数据库连接参数，DBUtil需要提供数据库连接的相关参数，以便建立与数据库的连接。

这些参数可以包括数据库的URL、用户名、密码等。

3. 连接池参数，如果使用连接池来管理数据库连接，DBUtil
可能还会包含一些连接池相关的参数。

这些参数可以包括最大连接数、最小空闲连接数、连接超时时间等。

4. SQL语句参数，DBUtil通常需要提供执行的SQL语句和相应
的参数。

这些参数可以是查询条件、更新数据等操作所需的参数。

5. 数据库操作参数，DBUtil可能还会包含其他一些数据库操
作相关的参数，例如事务管理、批量操作等。

需要注意的是，具体的参数列表和使用方式可能因不同的DBUtil实现而有所差异。

在使用DBUtil时，可以参考相应的文档或示例代码，以了解具体的参数要求和使用方式。

总结起来，DBUtil的参数包括数据库驱动参数、数据库连接参数、连接池参数、SQL语句参数以及其他数据库操作参数，这些参数共同配置和指导DBUtil的数据库连接和操作行为。

DButils

DButilsDBUtils什么是DBUtilsDBUtils是⼀个实⽤⼩巧的⼯具,封装了JDBC.简化了JDBC的操作.对于数据库的读操作,只需要知道sql语句即可.DBUtils会将查询的结果集以指定的⽅式封装起来,⽐如List, javaBean等.同时⽀持数据源技术.使⽤时需要引⼊DButils的jar包:密码：f6l6DBUtils的APIQueryRunner对象1.对象描述该对象⽤来提供执⾏增删改查的⽅法.2.⽅法query() 查询⽅法update() 增删改⽅法ResultSetHandler对象(接⼝)1.对象描述⽤来对查询的结果集进⾏封装2.该接⼝常⽤实现类ArrayHandler适合结果集是⼀⾏数据,该实现类会将这⾏数据封装成⼀个数组对象,元素即为查询出来的字段值.ArrayListHandler适合结果集是多⾏数据,会将这些数据封装成⼀个List集合,该集合的元素是数组,数组即为每⾏数据ColumnListHandler适合结果集是多⾏单列,会将这些数据封装到⼀个List集合KeyedHandler适合取多条数据,会将每条数据封装成⼀个map集合,最后再把这些map集合封装成⼤map中MapHandler适合结果集是⼀条数据,封装到map集合中MapListHandler适合取多条数据,会将每条数据封装成⼀个map集合,最后再把这些map集合封装成List中ScalarHandler适合取单⾏单列数据,⽐如聚合函数BeanHandler适合取单⾏数据,将数据封装成对象BeanListHandler适合取多⾏数据,将每⾏数据封装成⼀个对象,再把这些对象封装成⼀个List集合举个栗⼦BeanListHandlerpublic class Demo {public static void main(String[] args) throws SQLException {//执⾏查询//创建QueryRunner对象QueryRunner queryRunner = new QueryRunner();Connection connection = JDBCUtil.getConnection(); //此⽅法是⾃定义实现的参考连接池那篇随笔//查询多⾏,并封装成对象,再放进List集合中List<Employee> list = queryRunner.query(connection, "select * from emp", new BeanListHandler<Employee>(Employee.class));for(Enployee e:list){System.out.println(e);}}}栗⼦BeanHandler：//执⾏查询//创建QueryRunner对象QueryRunner queryRunner = new QueryRunner();Connection connection = JDBCUtil.getConnection();//查询⼀⾏,封装成对象Employee emp = queryRunner.query(connection, "select * from emp where e_id = ?", new BeanHandler<Employee>(Employee.class), 1); //此处的1是where语句等号后⾯的?，做参数栗⼦KeyedHandler：//执⾏查询//创建QueryRunner对象QueryRunner queryRunner = new QueryRunner();Connection connection = JDBCUtil.getConnection();Map<Object, Map<String, Object>> map = queryRunner.query(connection, "select * from emp", new KeyedHandler(2));//遍历map集合Set<Map.Entry<Object, Map<String, Object>>> set = map.entrySet();for(Map.Entry<Object, Map<String, Object>> entry : set){Object bigKey = entry.getKey();Map<String, Object> smallMap = entry.getValue();System.out.println(bigKey); //关⽻Set<String> smallSet = smallMap.keySet();for(String smallKey : smallSet) {Object value = smallMap.get(smallKey);System.out.println(smallKey + ":" + value);}}栗⼦ScalarHandler：//执⾏查询//创建QueryRunner对象QueryRunner queryRunner = new QueryRunner();Connection connection = JDBCUtil.getConnection();//聚合函数long num = (long) queryRunner.query(connection, "select count(*) from emp", new ScalarHandler());System.out.println(num);栗⼦://执⾏查询//创建QueryRunner对象QueryRunner queryRunner = new QueryRunner();Connection connection = JDBCUtil.getConnection();//增Employee employee = new Employee();employee.setE_id(18);employee.setE_name("吕布");employee.setE_salary(10000.0);employee.setE_did(1);employee.setHiretime(new Date());employee.setE_job("staff");Object[] param = {employee.getE_id(), employee.getE_name(), employee.getE_salary(), employee.getE_job(), employee.getE_did(), employee.getHiretime()}; int row = queryRunner.update(connection, "delete from emp where e_name = ?", employee.getE_name());System.out.println(row);JDBCUtil.close(connection);。

dbutils的使用

dbutils的使用dbutils是一个在Java中使用数据库的工具类库，它提供了简单而强大的API，使得数据库操作变得更加容易。

在这篇文章中，我将向您介绍如何使用dbutils进行常见的数据库操作，包括查询、插入、更新和删除数据。

1. 查询数据使用dbutils查询数据非常简单。

首先，您需要创建一个QueryRunner对象，并传入一个数据源。

然后，您可以使用`query`方法执行查询语句，并将结果集转换为您需要的对象或列表。

例如，下面的代码将执行一个简单的查询，并将结果集转换为一个列表：```javaQueryRunner queryRunner = new QueryRunner(dataSource);String sql = "SELECT * FROM users";List<User> users = queryRunner.query(sql, new BeanListHandler<>(User.class));```2. 插入数据要向数据库中插入数据，您可以使用`update`方法。

首先，您需要创建一个UpdateRunner对象，并传入一个数据源。

然后，您可以使用`update`方法执行插入语句，并传入相应的参数。

例如，下面的代码将向数据库中插入一条新的用户记录：```javaUpdateRunner updateRunner = new UpdateRunner(dataSource); String sql = "INSERT INTO users (name, age) VALUES (?, ?)"; updateRunner.update(sql, "John Doe", 25);```3. 更新数据使用dbutils更新数据也非常简单。

您可以使用`update`方法执行更新语句，并传入相应的参数。

数据库操作之DBUtils

数据库操作之DBUtils概述DBUtils是Java编程中的数据库操作实⽤⼯具，⼩巧简单实⽤。

DBUtils封装了对JDBC的操作，简化了JDBC操作，可以少写代码。

DBUtils三个核⼼功能介绍QueryRunner中提供对sql语句操作的APIResultSetHandler接⼝，⽤于定义select操作后，怎样封装结果集DBUtils类，它就是⼀个⼯具类，定义了关闭资源与事务处理的⽅法QueryRunner核⼼类QueryRunner(DataSourcr ds),提供数据源（连接池），DbUtils底层⾃动维护连接connectionupdate（String sql，Obj...params），执⾏更新数据query（String sql，ResultSetHandler<T>rsh,Object...panrams)，执⾏查询ResultSetHandler结果集处理类ArrayHandler：适合取1条记录，把结果集中的第⼀⾏数据转成对象数组。

ArrayListHandler：适合取多条记录，把结果集中的每⼀⾏数据都转成⼀个对象数组，再存放到List中。

BeanHandler：将结果集中的第⼀⾏数据封装到⼀个对应的JavaBean实例中（把每条记录封装成对象，适合取⼀条记录）BeanListHandler：将结果集中的每⼀⾏数据都封装到⼀个对应的JavaBean实例中，存放到List⾥。

//重点MapHandler：将结果集中的第⼀⾏数据封装到⼀个Map⾥，key是列名，value就是对应的值。

//重点MapListHandler：将结果集中的每⼀⾏数据都封装到⼀个Map⾥，然后再存放到ListColumnListHandler：将结果集中某⼀列的数据存放到List中。

KeyedHandler(name)：将结果集中的每⼀⾏数据都封装到⼀个Map⾥(List<Map>)，再把这些map再存到⼀个map⾥，其key为指定的列。

python dbutils 用法

`dbUtils` 是一个用于操作数据库的Python 库，它提供了简单、高效的方法来连接、查询和操作各种数据库。

`dbUtils` 是一个跨平台库，支持多种数据库，如MySQL、PostgreSQL、SQLite 和Oracle 等。

以下是一个使用`dbUtils` 连接到MySQL 数据库的示例：
首先，需要安装`dbUtils` 库，可以使用以下命令进行安装：
```bash
pip install dbUtils
```
然后，可以使用以下代码连接到MySQL 数据库：
```python
from dbUtils import MySQL
# 创建一个MySQL 连接对象
conn = MySQL(host='localhost', user='your_username', password='your_password', database='your_database')
# 创建一个游标对象
cursor = conn.cursor()
# 执行SQL 查询
sql = "SELECT * FROM your_table"
cursor.execute(sql)
# 获取查询结果
result = cursor.fetchall()
# 打印查询结果
for row in result:
print(row)
# 关闭游标和连接
cursor.close()
conn.close()
```。

dbtuils的用法python

dbutils是Databricks公司开发的一款Python工具包，用于在Apache Spark上执行一些通用的任务，例如数据清理、数据转换和数据探索等。

以下是dbutils的一些常见用法：1. 安装dbutils在开始使用dbutils之前，需要先安装它。

可以使用以下命令在Python中安装dbutils：```python!pip install dbutils```2. 使用dbutils创建UDF（用户自定义函数）UDF是用户自定义函数的缩写，可以将其视为Python中的函数，但在Spark中执行。

dbutils提供了一些工具来创建和使用UDF。

以下是一个创建UDF的示例：```pythonfrom pyspark.sql.functions import udffrom pyspark.sql.types import IntegerTypefrom dbutils import UDFContextdef square(x):return x ** 2udf_square = udf(square, IntegerType())```在这个例子中，我们定义了一个名为square的函数，该函数将输入的数字平方并返回结果。

然后，我们使用udf函数将该函数转换为UDF，并指定返回类型为IntegerType。

最后，我们使用UDFContext 将UDF注册到Spark中。

3. 使用dbutils执行SQL查询使用dbutils可以执行SQL查询，并与Spark DataFrame交互。

以下是一个执行SQL查询的示例：```pythonfrom pyspark.sql import SparkSessionfrom dbutils import spark_sessionspark = spark_session() # 获取SparkSession实例df = spark.sql("SELECT * FROM table") # 执行SQL查询并返回DataFrame```在这个例子中，我们使用spark_session函数获取SparkSession实例，并使用该实例执行SQL查询。

day14--dbutils的使用,事务处理,多表操作,oracle大数据处理

params[i] = new Object[]{i,"batch"}; } runner.batch(sql, params); }
/** * 大文本操作 * @throws Exception */
@Test public void testClob() throws Exception{
String sql = "insert into clob values(?)"; File file = new File("c:/a.txt"); Long l = file.length(); char[] buffer = new char[l.intValue()]; FileReader reader = new FileReader(file); reader.read(buffer); SerialClob clob = new SerialClob(buffer); runner.update(sql, clob); }
Object[] params = {"update",1};
runner.update(sql, params);
}
/**
* 查询列表操作
* @throws Exception
*/
@Test
public void testListQuery() throws Exception{
String sql = "select * from demo";
|
+-------+-------------+------+-----+---------+-------+
*/

开源框架：DBUtils使用详解

开源框架：DBUtils使⽤详解⼀、先熟悉DBUtils的API：简介:DbUtils是⼀个为简化JDBC操作的⼩类库。

(⼀)整个dbutils总共才3个包：1、包mons.dbutils接⼝摘要ResultSetHandler 将ResultSet转换为别的对象的⼯具。

RowProcessor 将ResultSet⾏转换为别的对象的⼯具。

类摘要BasicRowProcessor RowProcessor接⼝的基本实现类。

BeanProcessor BeanProcessor匹配列明到Bean属性名，并转换结果集列到Bean对象的属性中。

DbUtils ⼀个JDBC辅助⼯具集合。

ProxyFactory 产⽣JDBC接⼝的代理实现。

QueryLoader 属性⽂件加载器，主要⽤于加载属性⽂件中的 SQL 到内存中。

QueryRunner 使⽤可插拔的策略执⾏SQL查询并处理结果集。

ResultSetIterator 包装结果集为⼀个迭代器。

2、包mons.dbutils.handlersResultSetHandler 接⼝的实现类类摘要AbstractListHandler 将ResultSet转为List的抽象类ArrayHandler 将ResultSet转为⼀个Object[]的ResultSetHandler实现类ArrayListHandler 将ResultSet转换为List<Object[]>的ResultSetHandler实现类BeanHandler 将ResultSet⾏转换为⼀个JavaBean的ResultSetHandler实现类BeanListHandler 将ResultSet转换为List<JavaBean>的ResultSetHandler实现类ColumnListHandler 将ResultSet的⼀个列转换为List<Object>的ResultSetHandler实现类KeyedHandler 将ResultSet转换为Map<Map>的ResultSetHandler实现类MapHandler 将ResultSet的⾸⾏转换为⼀个Map的ResultSetHandler实现类MapListHandler 将ResultSet转换为List<Map>的ResultSetHandler实现类ScalarHandler 将ResultSet的⼀个列到⼀个对象。

DbUtils介绍和使用实例

DbUtils是apache上的一个开源工具包.对数据库的操作进行了二次的封装.DbUtils提供了三个包,分别是:mons.dbutils;mons.dbutils.handlers;mons.dbutils.wrappers;mons.dbutilsDbUtils 关闭链接等操作QueryRunner 进行查询的操作mons.dbutils.handlersArrayHandler ：将ResultSet中第一行的数据转化成对象数组ArrayListHandler将ResultSet中所有的数据转化成List，List中存放的是Object[] BeanHandler ：将ResultSet中第一行的数据转化成类对象BeanListHandler ：将ResultSet中所有的数据转化成List，List中存放的是类对象ColumnListHandler ：将ResultSet中某一列的数据存成List，List中存放的是Object对象KeyedHandler ：将ResultSet中存成映射，key为某一列对应为Map。

Map中存放的是数据MapHandler ：将ResultSet中第一行的数据存成Map映射MapListHandler ：将ResultSet中所有的数据存成List。

List中存放的是Map ScalarHandler ：将ResultSet中一条记录的其中某一列的数据存成Objectmons.dbutils.wrappersSqlNullCheckedResultSet ：对ResultSet进行操作，改版里面的值StringTrimmedResultSet ：去除ResultSet中中字段的左右空格。

Trim()可以去网上下载官方的测试以及使用实例.今天下午自己闲没有事做,自己写了一些常用方法的测试数据.首先我用的是mysql数据库,创建一个测试用的表,具体的sql语句如下:DROP TABLE IF EXISTS `person`;CREATE TABLE `person` (`id` int(11) NOT NULL AUTO_INCREMENT,`name` varchar(10) DEFAULT NULL,`age` int(11) DEFAULT NULL,`address` varchar(100) DEFAULT NULL,PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8;然后创建表对应的javabean:具体的代码如下:package net.ybx.test;public class Person {public int id;public String name;public int age;public String address;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}public String toString(){return "id="+id+" name="+name+" address="+address+" age="+age; }}然后具体的测试类如下:package net.ybx.test;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;import java.util.List;import mons.dbutils.DbUtils;import mons.dbutils.ProxyFactory;import mons.dbutils.QueryRunner;import mons.dbutils.handlers.BeanHandler;import mons.dbutils.handlers.BeanListHandler;import mons.dbutils.handlers.ScalarHandler;import mons.dbutils.wrappers.SqlNullCheckedResultSet;import mons.dbutils.wrappers.StringTrimmedResultSet;public class DbUtilsTest {private static final String DRIVERCLASS = "com.mysql.jdbc.Driver";private static final String CONNECTURL = "jdbc:mysql://localhost/test?useUnicode=true&characterEncoding=utf-8"; private static final String USER = "root";private static final String PASSWORD = "3769221";public static Connection conn;public static void main(String[] args) {// TODO Auto-generated method stubDbUtils DB = new DbUtils();// 加载数据库mysql的jdbc驱动DB.loadDriver(DRIVERCLASS);PreparedStatement stmt = null;QueryRunner qr = new QueryRunner();try {conn = DriverManager.getConnection(CONNECTURL, USER, PASSWORD);// 获得PreparedStatement对象stmt = conn.prepareStatement("insert into person(name,age,address) values(?,?,?)"); Person person = new Person();person.setAddress("上海");person.setName("南信大");person.setAge(50);qr.fillStatementWithBean(stmt, person, new String[] { "name","age", "address" });stmt.execute();// 删除数据;qr.update(conn, "delete from person where id=?",new Object[] { 4 });// 查询一个bean数据person = (Person) qr.query(conn, "select * from person where id=?",new Object[] { 10 }, new BeanHandler(Person.class));System.out.println("查询出的数据为:" + person.toString());// 查询一个ListList<Person> list = (List<Person>) qr.query(conn,"select * from person", new BeanListHandler(Person.class));// 遍历一个listfor (int i = 0; i < list.size(); i++)System.out.println(list.get(i).toString());// 返回刚刚插入数据的ID(自动递增的)Long id = (Long) qr.query(conn, "select last_insert_id()",new ScalarHandler(1));System.out.println("最新自动增加的值为:" + id.longValue());// SqlNullCheckedResult 测试System.out.println("-------------------------------一道华丽的分界线-----------------------");Statement stat = conn.createStatement();ResultSet rs = stat.executeQuery("select * from person where id=18");SqlNullCheckedResultSet wrapper = new SqlNullCheckedResultSet(rs);wrapper.setNullString("------N/A------");wrapper.setNullInt(1000);rs = ProxyFactory.instance().createResultSet(wrapper);while (rs.next())System.out.println(rs.getInt("id") + rs.getString("address")+ " " + rs.getInt("age"));System.out.println("--------------------又是一个华丽的分割线----------------");rs = stat.executeQuery("select * from person where id=17");while (rs.next()) {System.out.println("长度为:"+rs.getString(2).length());rs = StringTrimmedResultSet.wrap(rs);System.out.println("现在长度为:"+rs.getString(2).length());System.out.println(rs.getString(2));}} catch (SQLException e) {// TODO Auto-generated catch blockDB.rollbackAndCloseQuietly(conn);e.printStackTrace();} finally {DbUtils.closeQuietly(conn);DbUtils.closeQuietly(stmt);}}}具体的一些截图如下:具体的代码可以到下面的地址去下载:/file/id_18825567507841057.htmlDbUtils对于一些小的项目作为公共类可以提高开发效率,可以简化DAO层的代码,同时对于一些查询出的ResultSet可以很简单的做一些转化.比如转化为bean,array,list,map之类的.是操作变得比较的简单.。

DBUtils介绍

一、DBUtils介绍DBUtils封装了对JDBC的操作，简化了JDBC操作。

可以少写代码。

1.对于数据表的读操作，他可以把结果转换成List，Array，Set等java集合，便于程序员操作；2.对于数据表的写操作，也变得很简单（只需写sql语句）3.可以使用数据源，使用JNDI，数据库连接池等技术来优化性能--重用已经构建好的数据库连注意，在使用DBUtils过程中，需要在C3P0Utils中添加getDateSource方法。

二、DBUtils的三个核心对象> QueryRunner类：它主要有三个方法query() 用于执行selectupdate() 用于执行insert update deletebatch() 批处理构造方法：> new QueryRunner(); 它的事务可以手动控制。

也就是说此对象调用的方法（如：query、update、batrch）参数中要有Connec> new QueryRunner(DataSource ds); 它的事务是自动控制的。

一个sql一个事务此对象调用的方法（如：query、update、batrch）参数中无需Connection对象。

方法query(sql,ResultSetHandler,Object...params); 参数分别代表（查询语句，结果query(conn,sql,ResultSetHandler,Object...params); 这表示手动控制事务，参数分update(sql,Object...params);update(conn,sql,Object...params);batch(sql,Object...params); 批处理。

object二维数组中高维表示循环操作次数batch(conn,sql,Object[][]); 手动控制事务的批处理。

>ResultSetHandler接口：结果处理器。

ApacheCommonsDbUtils工具包使用介绍

ApacheCommonsDbUtils⼯具包使⽤介绍⼀、介绍DBUtils是个⼩巧的JDBC轻量级封装的⼯具包，其最核⼼的特性是在JDBC的基础上做了⼀层封装，主要是对结果集的封装，可以直接将查询出来的结果集封装成JavaBean，旨在简化JDBC代码混乱与重复。

JDBC代码开发，存在很多难点：1）操作过程复杂，代码操作⼀个模式，⼤量的重复。

2）结果集难以处理。

3）到处都强制检查SQLException，影响代码的美观和可读性。

⼆、熟悉DBUtils在使⽤DBUtils之前，应该注意⼀些问题：1）DBUtils是JDBC的简单封装，可以和JDBC混合使⽤。

2）DBUtils对结果集⾃动封装为JavaBean是有着苛刻要求的：必须满⾜JavaBean的规范；其次Bean的getter与setter⽅法的名字与结果集的列名必须⼀⼀对应；不要求JavaBean的私有成员与表结果集列名⼀⼀对应。

3）DBUtils可以将结果集封装为各种类型主要有：Bean/List<Bean>，Map/List<Map>/Map<Map>，数组/List<数组>，列/List<列>，这些类型。

对于Map<Map>的类型使⽤KeyedHandler作为结果集处理器，内层的Map是“列名-值"对，外层的Map是“主键-内层Map的引⽤”，但此处的主键不⼀定就是数据库的主键，可以随意指定。

4）DBUtils执⾏插⼊操作的时候，⽆法返回⾃增主键，这是⼀个很严重的问题，当然不能怪DBUtils，可以通过变通的⽅法来实现，⽐如在MySQL中，执⾏完了⼀个插⼊SQL后，接着执⾏SELECT LAST_INSERT_ID()语句，就可以获取到⾃增主键。

5）DBUtils的性能和JDBC性能是⼀样，测试过程中没发现性能损失，拥有了很⾼性能的同时，⽽不失JDBC的灵活性。

dbutils开发步骤

dbutils开发步骤一、什么是dbutils？dbutils是Apache Commons项目的一部分，是一个用于简化JDBC 编程的开源Java库。

它提供了一组简单的API，使得数据库操作变得简单、直观且易于维护。

使用dbutils可以避免手动编写大量重复的JDBC代码，提高开发效率。

二、使用dbutils的开发步骤使用dbutils进行数据库操作的一般步骤如下：1. 引入依赖需要在项目中引入dbutils的依赖。

可以通过Maven或Gradle等构建工具来添加依赖，或者手动下载jar包并导入到项目中。

2. 创建数据库连接使用JDBC的标准方式创建数据库连接，可以使用DriverManager.getConnection()方法来获取Connection对象。

3. 创建QueryRunner对象QueryRunner是dbutils提供的核心类，负责执行SQL语句。

可以通过创建QueryRunner对象并传入Connection对象来进行初始化。

4. 编写SQL语句根据需求编写相应的SQL语句，可以是查询语句、更新语句等。

5. 执行SQL语句使用QueryRunner对象的相应方法来执行SQL语句，例如query()方法用于执行查询语句，update()方法用于执行更新语句。

6. 处理结果根据执行的SQL语句不同，可以使用不同的方法来处理查询结果。

例如，使用ResultSetHandler接口的实现类来处理查询结果集，或者使用int类型的返回值来表示更新操作的结果。

7. 关闭资源使用完数据库连接和相关资源后，需要手动关闭它们，以释放资源。

可以使用try-with-resources语句块来自动关闭资源，或者在finally块中手动关闭。

三、样例代码下面是一个使用dbutils进行查询操作的示例代码：```javaimport mons.dbutils.QueryRunner;import mons.dbutils.handlers.BeanListHandler; import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;import java.util.List;public class DbUtilsExample {public static void main(String[] args) {// 创建数据库连接try (Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db _example", "username", "password")) {// 创建QueryRunner对象QueryRunner queryRunner = new QueryRunner();// 编写SQL语句String sql = "SELECT * FROM users WHERE age > ?";// 执行SQL语句并处理结果List<User> userList = queryRunner.query(conn, sql, new BeanListHandler<>(User.class), 18);for (User user : userList) {System.out.println(user.getName());}} catch (SQLException e) {e.printStackTrace();}}}```在上述代码中，我们首先创建了数据库连接，然后创建了一个QueryRunner对象。

Apache_Commons_DbUtils数据库工具类说明

Apache_Commons_DbUtils数据库⼯具类说明这⼏天在学习jdbc时，⽆意中发现apache的DbUtils⼯具类。

⽤DbUtils执⾏sql语句，和将查询结果封装为JavaBean超级好⽤，省时省⼒。

DBUtils是个⼩巧的JDBC轻量级封装的⼯具包，其最核⼼的特性是结果集的封装，可以直接将查询出来的结果集封装成JavaBean，这就为我们做了最枯燥乏味、最容易出错的⼀⼤部分⼯作。

⼀、DbUtils下载⽂件解压后得到commons-dbutils-1.6.jar，这个就是所需的jar包。

⼆、准备⼯作1、sql脚本CREATE TABLE `user` (`id` int(4) NOT NULL AUTO_INCREMENT,`name` varchar(50) NOT NULL,`password` varchar(50) DEFAULT NULL,PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=4DEFAULT CHARSET=utf8;2、建⽴与数据库表相对应的user java bean。

package testDbUtils;/*** 与user表对应的java bean**/public class User {//DBUtils对结果集⾃动封装为JavaBean是有着苛刻要求的：必须满⾜JavaBean的规范，其次Bean的getter与setter⽅法的名字与结果集的列名⼀⼀对应//不要求JavaBean的私有成员与表结果集列名⼀⼀对应。

String name;String password;//⼀定要有⽆参的构造函数，否则会报错public User() {}public User(String name, String password) { = name;this.password = password;}//Bean的getter与setter⽅法的名字与结果集的列名⼀⼀对应public String getName() {return name;}public void setName(String name) { = name;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}}3、随便写个数据库连接获取类package testDbUtils;import java.sql.*;public class ConnTools {private static String dirverClassName = "com.mysql.jdbc.Driver";private static String url = "jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8";private static String user = "root";private static String password = "aaaaaa";public static Connection makeConnection() {Connection conn = null;try {Class.forName(dirverClassName);} catch (ClassNotFoundException e) {e.printStackTrace();}try {conn = DriverManager.getConnection(url, user, password);} catch (SQLException e) {e.printStackTrace();}return conn;}}三、⽰例1、insert、update、delete//获取Connection Connection conn = ConnTools.makeConnection();//获取dbUtils的QueryRunner对象。

python使用dbutils的PooledDB连接池，操作数据库

python使⽤dbutils的PooledDB连接池，操作数据库1、使⽤dbutils的PooledDB连接池，操作数据库。

这样就不需要每次执⾏sql后都关闭数据库连接，频繁的创建连接，消耗时间2、如果是使⽤⼀个连接⼀直不关闭，多线程下，插⼊超长字符串到数据库，运⾏⼀段时间后很容易出现OperationalError: (2006, ‘MySQL server has gone away’)这个错误。

使⽤PooledDB解决。

# coding=utf-8"""使⽤DBUtils数据库连接池中的连接，操作数据库OperationalError: (2006, ‘MySQL server has gone away’)"""import jsonimport pymysqlimport datetimefrom DBUtils.PooledDB import PooledDBimport pymysqlclass MysqlClient(object):__pool = None;def__init__(self, mincached=10, maxcached=20, maxshared=10, maxconnections=200, blocking=True,maxusage=100, setsession=None, reset=True,host='127.0.0.1', port=3306, db='test',user='root', passwd='123456', charset='utf8mb4'):""":param mincached:连接池中空闲连接的初始数量:param maxcached:连接池中空闲连接的最⼤数量:param maxshared:共享连接的最⼤数量:param maxconnections:创建连接池的最⼤数量:param blocking:超过最⼤连接数量时候的表现，为True等待连接数量下降，为false直接报错处理:param maxusage:单个连接的最⼤重复使⽤次数:param setsession:optional list of SQL commands that may serve to preparethe session, e.g. ["set datestyle to ...", "set time zone ..."]:param reset:how connections should be reset when returned to the pool(False or None to rollback transcations started with begin(),True to always issue a rollback for safety's sake):param host:数据库ip地址:param port:数据库端⼝:param db:库名:param user:⽤户名:param passwd:密码:param charset:字符编码"""if not self.__pool:self.__class__.__pool = PooledDB(pymysql,mincached, maxcached,maxshared, maxconnections, blocking,maxusage, setsession, reset,host=host, port=port, db=db,user=user, passwd=passwd,charset=charset,cursorclass=pymysql.cursors.DictCursor)self._conn = Noneself._cursor = Noneself.__get_conn()def__get_conn(self):self._conn = self.__pool.connection();self._cursor = self._conn.cursor();def close(self):try:self._cursor.close()self._conn.close()except Exception as e:print edef__execute(self, sql, param=()):count = self._cursor.execute(sql, param)print countreturn count@staticmethoddef__dict_datetime_obj_to_str(result_dict):"""把字典⾥⾯的datatime对象转成字符串，使json转换不出错"""if result_dict:result_replace = {k: v.__str__() for k, v in result_dict.items() if isinstance(v, datetime.datetime)}result_dict.update(result_replace)return result_dictdef select_one(self, sql, param=()):"""查询单个结果"""count = self.__execute(sql, param)result = self._cursor.fetchone()""":type result:dict"""result = self.__dict_datetime_obj_to_str(result)return count, resultdef select_many(self, sql, param=()):"""查询多个结果:param sql: qsl语句:param param: sql参数:return: 结果数量和查询结果集"""count = self.__execute(sql, param)result = self._cursor.fetchall()""":type result:list"""[self.__dict_datetime_obj_to_str(row_dict) for row_dict in result]return count, resultdef execute(self, sql, param=()):count = self.__execute(sql, param)return countdef begin(self):"""开启事务"""self._conn.autocommit(0)def end(self, option='commit'):"""结束事务"""if option == 'commit':self._conn.autocommit()else:self._conn.rollback()if__name__ == "__main__":mc = MysqlClient()sql1 = 'SELECT * FROM shiji WHERE id = 1'result1 = mc.select_one(sql1)print json.dumps(result1[1], ensure_ascii=False)sql2 = 'SELECT * FROM shiji WHERE id IN (%s,%s,%s)'param = (2, 3, 4)print json.dumps(mc.select_many(sql2, param)[1], ensure_ascii=False)如果独⽴使⽤pymysql数据库，最好是配合DButils库。

queryrunner类_insert_的使用方法_示例及概述说明

queryrunner类insert 的使用方法示例及概述说明1. 引言1.1 概述引言部分将为读者提供文章的背景信息和主题概述。

在这篇文章中，我们将探讨Java编程语言中的QueryRunner类的insert方法的使用方法。

QueryRunner 类是Apache Commons DbUtils库中的一部分，它简化了与数据库的交互，并提供了一种方便快捷的方式执行SQL查询。

1.2 文章结构本文将按照以下结构进行介绍QueryRunner类insert方法的使用：- 引言：提供文章背景和概述。

- 正文：详细讲解QueryRunner类以及其在数据库操作中的作用。

- queryrunner类insert方法的使用方法：给出具体示例代码，并解释每个参数的含义及其作用。

- 结论：总结本文并提供应用场景分析。

1.3 目的本文旨在帮助读者理解并正确使用QueryRunner类的insert方法。

通过详细说明示例代码和参数说明，读者将能够灵活运用该方法来进行数据库操作，从而提高编程效率和准确性。

通过对该方法实际应用场景进行分析，读者也能更好地掌握如何在自己项目中合理利用该功能。

请根据以上内容进行回答，谢谢！2. 正文正文部分将详细介绍queryrunner类的相关内容。

queryrunner类是一个功能强大的数据库操作类，可以用于执行SQL查询和更新操作。

它提供了方便且易于使用的方法来执行各种数据库操作。

首先，我们需要创建一个QueryRunner对象。

可以通过以下代码实现：```QueryRunner queryRunner = new QueryRunner(dataSource);```其中，dataSource是一个数据源对象，用于连接数据库。

接下来，我们可以使用QueryRunner对象执行insert操作。

insert操作用于向数据库中插入一条数据。

例如，我们要向`user`表中插入一条记录，该表包含字段`id`、`name`和`age`：```javaString sql = "INSERT INTO user (id, name, age) VALUES (?, ?, ?)";Object[] params = {1, "John", 25};queryRunner.update(sql, params);```在上述示例中：- `sql`变量存储了插入语句的SQL语句。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

50.}
51.
52./**
53.*执行sql语句
54.* <code>
55.* executeUpdate("update user set username = 'kitty' where username = ?", "hello kitty");
56.* </code>
57.* @param sql ql语句
159.* @return查询结果
160.*/
161.public<T> List<T> find(Class<T> entityClass, String sql, Object param) {
162.returnfind(entityClass, sql,newObject[] { param });
23.*本类已经在Spring中配置好，在需要的地方，set注入后即可调用
24.* <code>
25.* private DbUtilsTemplate dbUtilsTemplate;
26.* public void setDbUtilsTemplate(DbUtilsTemplate dbUtilsTemplate) {
8.<propertyname="username"value="${ername}"/>
9.<propertyname="password"value="${jdbc.password}"/>
10.</bean>
11.
12.<beanid="dbUtilsTemplate"class="pany.project.dao.template.DbUtilsTemplate">
mons.dbutils.handlers.MapHandler;
mons.dbutils.handlers.MapListHandler;
mons.dbutils.handlers.ScalarHandler;
67.* @param sql sql语句
68.* @param params参数数组
69.* @return受影响的行数
70.*/
71.publicintupdate(String sql, Object[] params) {
72.queryRunner =newQueryRunner(dataSource);
13.<propertyname="dataSource"ref="dataSource"/>
14.</bean>
然后，是这个模板操作类，在需要用到原生SQL的地方，注入这个类即可：
Java代码
pany.project.dao.template;
2.
3.importjava.sql.SQLException;
140.}
141.returnlist;
142.}
143.
144./**
145.*执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中
146.* @param entityClass类名
147.* @param sql sql语句
148.* @return查询结果
149.*/
150.public<T> List<T> find(Class<T> entityClass, String sql) {
118.publicList<Map<String, Object>> find(String sql, Object param) {
119.returnfind(sql,newObject[] {param});
120.}
121.
122./**
123.*执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
79.}
80.}catch(SQLException e) {
81.LOG.error("Error occured while attempting to update data", e);
82.}
83.returnaffectedRows;
84.}
85.
86./**
87.*执行批量sql语句
88.* @param sql sql语句
99.}
100.returnaffectedRows;
101.}
102.
103./**
104.*执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
105.* @param sql sql语句
106.* @return查询结果
107.*/
108.publicList<Map<String, Object>> find(String sql) {
151.returnfind(entityClass, sql,null);
152.}
153.
154./**
155.*执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中
156.* @param entityClass类名
157.* @param sql sql语句
158.* @param param参数
73.intaffectedRows =0;
74.try{
75.if(params ==null) {
76.affectedRows = queryRunner.update(sql);
77.}else{
78.affectedRows = queryRunner.update(sql, params);
mons.logging.Log;
mons.logging.LogFactory;
19.
20./**
21.*调用Apache Commons DBUtil组件的数据库操作类
22.*采用DBCP作为数据源，数据源在Spring中已经配置好
35.privateDataSource dataSource;
36.privateQueryRunner queryRunner;
37.privatestaticfinalLog LOG = LogFactory.getLog(DbUtilsTemplate.class);
38.
39.publicvoidsetDataSource(BasicDataSource dataSource) {
94.int[] affectedRows =newint[0];
95.try{
96.affectedRows = queryRunner.batch(sql, params);
97.}catch(SQLException e) {
98.LOG.error("Error occured while attempting to batch update data", e);
130.queryRunner =newQueryRunner(dataSource);
131.List<Map<String, Object>> list =newArrayList<Map<String,Object>>();
132.try{
133.if(params ==null) {
134.list = (List<Map<String, Object>>) queryRunner.query(sql,newMapListHandler());
4.importjava.util.ArrayList;
5.importjava.util.List;
6.importjava.util.Map;
7.
8.importjavax.sql.DataSource;
9.
mons.dbcp.BasicDataSource;
124.* @param sql sql语句
125.* @param params参数数组
126.* @return查询结果
127.*/
128.@SuppressWarnings("unchecked")
129.publicList<Map<String, Object>> find(String sql, Object[] params) {
3.class="mons.dbcp.BasicDataSource"
4.destroy-method="close">
5.<propertyname="driverClassName"
6.value="${jdbc.driverClassName}"/>
7.<propertyname="url"value="${jdbc.url}"/>
27.* this.dbUtilsTemplate = dbUtilsTemplate;
28.* }
29.* </code>
30.* @author Sunshine
31.* @version 1.0 2009-07-29
32.*/
33.publicclassDbUtilsTemplate {