背景：
操作关系型数据库的框架很多，其实最好的是jdbc不过开发量稍高那么有没有其他的相对合适的框架呢？此处选择了dbutils。那么就需要spring和dbutils集成，对事务要求不高，基于spring注解集成
环境：
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>3.2.0.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>3.2.0.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>3.2.0.RELEASE</version> </dependency> <dependency> <groupId>commons-dbutils</groupId> <artifactId>commons-dbutils</artifactId> <version>1.5</version> </dependency> <dependency> <groupId>commons-pool</groupId> <artifactId>commons-pool</artifactId> <version>1.6</version> </dependency> <dependency> <groupId>commons-dbcp</groupId> <artifactId>commons-dbcp</artifactId> <version>20030825.184428</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.28</version> </dependency>
实现：
1.spring-source.xml：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:task="http://www.springframework.org/schema/task" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
xmlns:beans="http://www.springframework.org/schema/beans" xmlns:device="http://www.springframework.org/schema/mobile/device"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.2.xsd ">
<context:component-scan base-package=" org.apache.tools.source" />
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url"
value="jdbc:mysql://127.0.0.1:3306/demo?useUnicode=true&characterEncoding=UTF-8" />
<property name="username" value="root" />
<property name="password" value="root2013" />
</bean>
</beans>
2.DBUtilsTemplate
@Service("dbUtilsTemplate")
public class DBUtilsTemplate {
@Autowired
private DataSource dataSource;
private QueryRunner queryRunner;
private static final Log LOG = LogFactory.getLog(DBUtilsTemplate.class);
public void setDataSource(BasicDataSource dataSource) {
this.dataSource = dataSource;
}
/**
* 执行sql语句
*
* @param sql
* sql语句
* @param params
* 参数数组
* @return 受影响的行数
*/
public int update(String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource);
int affectedRows = 0;
try {
if (params == null) {
affectedRows = queryRunner.update(sql);
} else {
affectedRows = queryRunner.update(sql, params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to update data", e);
}
return affectedRows;
}
/**
* 执行批量sql语句
*
* @param sql
* sql语句
* @param params
* 二维参数数组
* @return 受影响的行数的数组
*/
public int[] batchUpdate(String sql, Object[][] params) {
queryRunner = new QueryRunner(dataSource);
int[] affectedRows = new int[0];
try {
affectedRows = queryRunner.batch(sql, params);
} catch (SQLException e) {
LOG.error("Error occured while attempting to batch update data", e);
}
return affectedRows;
}
/**
* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
*
* @param sql
* sql语句
* @return 查询结果
*/
public List<Map<String, Object>> find(String sql) {
return find(sql, null);
}
/**
* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
*
* @param sql
* sql语句
* @param param
* 参数
* @return 查询结果
*/
public List<Map<String, Object>> find(String sql, Object param) {
return find(sql, new Object[] { param });
}
/**
* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
*
* @param sql
* sql语句
* @param params
* 参数数组
* @return 查询结果
*/
public List<Map<String, Object>> find(String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource);
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
try {
if (params == null) {
list = (List<Map<String, Object>>) queryRunner.query(sql,
new MapListHandler());
} else {
list = (List<Map<String, Object>>) queryRunner.query(sql,
new MapListHandler(), params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return list;
}
/**
* 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中
*
* @param entityClass
* 类名
* @param sql
* sql语句
* @return 查询结果
*/
public <T> List<T> find(Class<T> entityClass, String sql) {
return find(entityClass, sql, null);
}
/**
* 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中
*
* @param entityClass
* 类名
* @param sql
* sql语句
* @param param
* 参数
* @return 查询结果
*/
public <T> List<T> find(Class<T> entityClass, String sql, Object param) {
return find(entityClass, sql, new Object[] { param });
}
/**
* 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中
*
* @param entityClass
* 类名
* @param sql
* sql语句
* @param params
* 参数数组
* @return 查询结果
*/
@SuppressWarnings("unchecked")
public <T> List<T> find(Class<T> entityClass, String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource);
List<T> list = new ArrayList<T>();
try {
if (params == null) {
list = (List<T>) queryRunner.query(sql, new BeanListHandler(
entityClass));
} else {
list = (List<T>) queryRunner.query(sql, new BeanListHandler(
entityClass), params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return list;
}
/**
* 查询出结果集中的第一条记录，并封装成对象
*
* @param entityClass
* 类名
* @param sql
* sql语句
* @return 对象
*/
public <T> T findFirst(Class<T> entityClass, String sql) {
return findFirst(entityClass, sql, null);
}
/**
* 查询出结果集中的第一条记录，并封装成对象
*
* @param entityClass
* 类名
* @param sql
* sql语句
* @param param
* 参数
* @return 对象
*/
public <T> T findFirst(Class<T> entityClass, String sql, Object param) {
return findFirst(entityClass, sql, new Object[] { param });
}
/**
* 查询出结果集中的第一条记录，并封装成对象
*
* @param entityClass
* 类名
* @param sql
* sql语句
* @param params
* 参数数组
* @return 对象
*/
@SuppressWarnings("unchecked")
public <T> T findFirst(Class<T> entityClass, String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource);
Object object = null;
try {
if (params == null) {
object = queryRunner.query(sql, new BeanHandler(entityClass));
} else {
object = queryRunner.query(sql, new BeanHandler(entityClass),
params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return (T) object;
}
/**
* 查询出结果集中的第一条记录，并封装成Map对象
*
* @param sql
* sql语句
* @return 封装为Map的对象
*/
public Map<String, Object> findFirst(String sql) {
return findFirst(sql, null);
}
/**
* 查询出结果集中的第一条记录，并封装成Map对象
*
* @param sql
* sql语句
* @param param
* 参数
* @return 封装为Map的对象
*/
public Map<String, Object> findFirst(String sql, Object param) {
return findFirst(sql, new Object[] { param });
}
/**
* 查询出结果集中的第一条记录，并封装成Map对象
*
* @param sql
* sql语句
* @param params
* 参数数组
* @return 封装为Map的对象
*/
public Map<String, Object> findFirst(String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource);
Map<String, Object> map = null;
try {
if (params == null) {
map = (Map<String, Object>) queryRunner.query(sql,
new MapHandler());
} else {
map = (Map<String, Object>) queryRunner.query(sql,
new MapHandler(), params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return map;
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
*
* @param sql
* sql语句
* @param columnName
* 列名
* @return 结果对象
*/
public Object findBy(String sql, String columnName) {
return findBy(sql, columnName, null);
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
*
* @param sql
* sql语句
* @param columnName
* 列名
* @param param
* 参数
* @return 结果对象
*/
public Object findBy(String sql, String columnName, Object param) {
return findBy(sql, columnName, new Object[] { param });
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
*
* @param sql
* sql语句
* @param columnName
* 列名
* @param params
* 参数数组
* @return 结果对象
*/
public Object findBy(String sql, String columnName, Object[] params) {
queryRunner = new QueryRunner(dataSource);
Object object = null;
try {
if (params == null) {
object = queryRunner.query(sql, new ScalarHandler(columnName));
} else {
object = queryRunner.query(sql, new ScalarHandler(columnName),
params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return object;
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
*
* @param sql
* sql语句
* @param columnIndex
* 列索引
* @return 结果对象
*/
public Object findBy(String sql, int columnIndex) {
return findBy(sql, columnIndex, null);
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
*
* @param sql
* sql语句
* @param columnIndex
* 列索引
* @param param
* 参数
* @return 结果对象
*/
public Object findBy(String sql, int columnIndex, Object param) {
return findBy(sql, columnIndex, new Object[] { param });
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
*
* @param sql
* sql语句
* @param columnIndex
* 列索引
* @param params
* 参数数组
* @return 结果对象
*/
public Object findBy(String sql, int columnIndex, Object[] params) {
queryRunner = new QueryRunner(dataSource);
Object object = null;
try {
if (params == null) {
object = queryRunner.query(sql, new ScalarHandler(columnIndex));
} else {
object = queryRunner.query(sql, new ScalarHandler(columnIndex),
params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return object;
}
}
3.测试：
public static ClassPathXmlApplicationContext context = null;
public static ClassPathXmlApplicationContext getContextInstance() {
if (context == null) {
start();
}
if (!context.isRunning()) {
CopyOfApp.context.refresh();
context.registerShutdownHook();
}
return context;
}
private static void start() {
context = new ClassPathXmlApplicationContext(
"classpath:spring-source.xml");
context.registerShutdownHook();
}
public static void main(String[] args) throws Exception {
App.start();
App.context.refresh();
DBUtilsTemplate dbUtilsTemplate = CopyOfApp.context.getBean(
"dbUtilsTemplate", DBUtilsTemplate.class);
String sql = "select count(1) from admin";
List<Map<String, Object>> list = dbUtilsTemplate.find(sql);
System.out.println(list + "--");
}
相关推荐
下面我们将深入探讨如何在SpringBoot项目中集成和使用DbUtils，以及涉及的增删改查（CRUD）操作、Controller、Model、DAO、Service层设计和事务管理。 1. **SpringBoot集成DbUtils** 在SpringBoot项目中引入...
在IT行业中，Spring框架是Java企业级应用开发的...通过学习和实践这个项目，你可以深入理解Spring如何集成DBUtils进行数据库操作，以及如何利用注解和XML配置进行事务管理。这将为你后续的Spring开发打下坚实的基础。
通过Spring的事务管理，我们可以确保业务操作的原子性和一致性，而DBUtils则帮助我们简化了数据库操作，提升了开发效率。这个"dbutils.rar"压缩包很可能包含了实现上述功能的代码示例，可以直接用于实际的开发项目中...
dbutils（Apache的一个数据库工具库）、spring-jdbc（Spring框架提供的JDBC抽象层）、MyBatis（一个优秀的持久层框架）、MyBatis-Spring（MyBatis与Spring的整合）以及MyBatis-Spring-Boot（MyBatis在Spring Boot...
3. Spring 框架的优点：可以和其他框架集成、可以使用 @Autowired 自动注入对象。 四、SpringMVC 框架 1. SpringMVC 框架的原理：使用中央控制器（DispatcherServlet）来处理请求，通过 HandlerMapping 找到对应的...
Spring MVC以其灵活性、可扩展性和与其他Spring组件的无缝集成而受到青睐；而Struts2则以其丰富的插件和拦截器机制闻名，它们都提供了MVC模式的实现，帮助开发者构建高效的Web应用。 6. **Spring AOP**： Spring ...
在SSM中，Spring负责管理Service层和DAO层的Bean，提供事务管理，并与其他两个框架进行集成。 **Spring MVC** Spring MVC是Spring框架的一个模块，用于构建Web应用程序。它提供了模型-视图-控制器的架构模式，分离...
SSM框架，全称Spring、SpringMVC和MyBatis，是Java开发中常用的一种轻量级Web应用框架组合。这个“ssm框架代码生成工具”是针对该框架的辅助开发工具，它能够帮助开发者自动生成一些基础的、与数据库交互的代码，...
SSM（Spring、SpringMVC、MyBatis）是一个经典的Java web开发框架组合，它将Spring的核心容器、Spring MVC作为视图层控制器以及MyBatis作为数据访问层进行了集成，大大简化了Java web应用程序的开发过程。...
DBUtils提供了一个简单的API，用于执行SQL语句并处理结果，而MyBatis则是一个强大的持久层框架，支持动态SQL和映射XML或注解方式定义SQL。 其次，数据库连接池是数据库工具类的核心组件，如HikariCP、C3P0、Druid等...
`mybatis`和`mybatis-spring`包分别提供了MyBatis的核心功能和与Spring框架的集成。 6. **Apache Commons DBUtils**： Apache Commons DBUtils是Apache Commons项目的一部分，提供了一些实用工具类，简化了JDBC的...
- 支持XML配置和注解，方便进行原始映射； - 将接口和Java的POJO映射成数据库记录。 #### 二、MyBatis与其他框架的关系 - **JDBC-dbutils-MyBatis-Hibernate**：这些技术代表了不同的数据库交互方式的发展历程。 ...