wjm901215
- 浏览: 154013 次
- 性别:
- 来自: 杭州
-
文章分类
最新评论
-
liveandevil：
我的一直出现驱动找不到的错误 你那个驱动jar文件时放在哪里 ...
JDBC数据库通用DAO -
zouc816：
hi,wjm901215
我看你这篇文章对mapXtreme ...
用mapXtreme Java开发web gis应用 (下)
数据库连接池
package org.dave.common.database;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ResourceBundle;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.jolbox.bonecp.BoneCP;
import com.jolbox.bonecp.BoneCPConfig;
/**
* 数据库连接池
* @author David Day
*/
public final class DatabaseConnectionPool {
private static final Logger LOG = LoggerFactory.getLogger(DatabaseConnectionPool.class);
private static final ResourceBundle BUNDLE = ResourceBundle.getBundle("connection");
private static final String DRIVER = "driver";
private static final String URL = "url";
private static final String USERNAME = "username";
private static final String PASSWORD = "password";
private static final String MAX_CONNECTION = "max_connection";
private static BoneCP pool;
/**
* 开启连接池
*/
public static void startup() {
try {
Class.forName(BUNDLE.getString(DRIVER));
BoneCPConfig config = new BoneCPConfig();
config.setJdbcUrl(BUNDLE.getString(URL));
config.setUsername(BUNDLE.getString(USERNAME));
config.setPassword(BUNDLE.getString(PASSWORD));
config.setMaxConnectionsPerPartition(Integer.parseInt(BUNDLE.getString(MAX_CONNECTION)));
pool = new BoneCP(config);
} catch (Exception e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DatabaseException(e);
}
}
/**
* 关闭连接池
*/
public static void shutdown() {
pool.shutdown();
}
/**
* @return 数据库连接
*/
public static Connection getConnection() {
try {
return pool.getConnection();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DatabaseException(e);
}
}
}
数据库异常
package org.dave.common.database;
/**
* 数据库异常
* @author David Day
*/
@SuppressWarnings("serial")
public class DatabaseException extends RuntimeException {
public DatabaseException(Throwable cause) {
super(cause);
}
}
事务控制
package org.dave.common.database;
import java.sql.Connection;
import java.sql.SQLException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 数据库事务
* @author David Day
*/
public class DatabaseTransaction {
/**
* 日志工具
*/
private static final Logger LOG = LoggerFactory.getLogger(DatabaseTransaction.class);
/**
* 数据库连接
*/
private Connection conn;
/**
* 实例化一个默认连接的事务
*/
private DatabaseTransaction() {
this(DatabaseConnectionPool.getConnection());
}
/**
* 实例化一个默认连接的事务
*/
private DatabaseTransaction(boolean openTransaction) throws DatabaseException {
this(DatabaseConnectionPool.getConnection(), openTransaction);
}
/**
* @param conn 数据库连接
*/
private DatabaseTransaction(Connection conn) {
this.conn = conn;
}
/**
* @param conn 数据库连接
*/
private DatabaseTransaction(Connection conn, boolean openTransaction) throws DatabaseException {
this.conn = conn;
setAutoCommit(!openTransaction);
}
/**
* @return 数据库连接
*/
public Connection getConnection() {
return conn;
}
/**
* 设置是否自动提交
* @param autoCommit 自动提交
* @throws DatabaseException
*/
private void setAutoCommit(boolean autoCommit) throws DatabaseException {
try {
conn.setAutoCommit(autoCommit);
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DatabaseException(e);
}
}
/**
* 开始事务
* @throws DatabaseException
*/
public void begin() throws DatabaseException {
setAutoCommit(false);
}
/**
* @return 是否打开事务
* @throws DatabaseException
*/
public boolean isBegin() throws DatabaseException {
try {
return !conn.getAutoCommit();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DatabaseException(e);
}
}
/**
* 提交
* @throws DatabaseException
*/
public void commit() throws DatabaseException {
try {
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DatabaseException(e);
}
}
/**
* 回滚
* @throws DatabaseException
*/
public void rollback() throws DatabaseException {
try {
conn.rollback();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DatabaseException(e);
}
}
/**
* 关闭连接
* @throws DatabaseException
*/
public void close() throws DatabaseException {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DatabaseException(e);
}
}
/**
* @return 连接是否关闭
* @throws DatabaseException
*/
public boolean isClose() throws DatabaseException {
try {
return conn.isClosed();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DatabaseException(e);
}
}
}
通用数据模型
package org.dave.common.database;
import java.io.Serializable;
@SuppressWarnings("serial")
public abstract class DataModel implements Serializable { }
结果转换器
package org.dave.common.database.convert;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* 结果映射器
* @author David Day
*/
public interface ResultConverter<T> {
/**
* 映射
* @param rs 结果集
* @return 映射结果
* @throws SQLException
*/
public T convert(ResultSet rs) throws SQLException ;
}
把结果转换为整型
package org.dave.common.database.convert;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* 整型映射工具
* @author David Day
*/
public class IntegerConverter implements ResultConverter<Integer> {
@Override
public Integer convert(ResultSet rs) throws SQLException {
return rs.getInt(1);
}
}
通用dao
package org.dave.common.database.access;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import org.dave.common.database.convert.ResultConverter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 数据存取类
* @author David Day
*/
public abstract class DataAccess {
/**
* 日志工具
*/
private static final Logger LOG = LoggerFactory.getLogger(DataAccess.class);
/**
* 数据库连接
*/
private Connection conn;
/**
* @param conn 数据库连接
*/
private DataAccess(Connection conn) {
this.conn = conn;
}
/**
* 插入数据
* @param sql
* @param generatedKeysConverter 主键映射
* @param params
* @return 主键
* @throws DataAccessException
*/
protected <T> T insert(String sql, ResultConverter<T> generatedKeysConverter, Object... params) throws DataAccessException {
try {
PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
setParameters(pstmt, params);
executeUpdate(pstmt);
ResultSet rs = pstmt.getGeneratedKeys();
nextResult(rs);
return convertResult(rs, generatedKeysConverter);
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DataAccessException(e);
}
}
/**
* 更新数据
* @param sql
* @param params
* @return 影响行数
* @throws DataAccessException
*/
protected int update(String sql, Object... params) throws DataAccessException {
return executeUpdate(getPreparedStatement(sql, params));
}
/**
* 查询单个结果
* @param <T>
* @param sql
* @param converter
* @param params
* @return
*/
protected <T> T queryForObject(String sql, ResultConverter<T> converter, Object... params) {
ResultSet rs = executeQuery(sql, params);
if (nextResult(rs)) {
return convertResult(rs, converter);
} else {
return null;
}
}
/**
* 查询结果列表
* @param <T>
* @param sql
* @param converter
* @param params
* @return
*/
protected <T> List<T> queryForList(String sql, ResultConverter<T> converter, Object... params) {
ResultSet rs = executeQuery(sql, params);
List<T> list = new ArrayList<T>();
while (nextResult(rs)) {
list.add(convertResult(rs, converter));
}
return list;
}
/**
* @param sql SQL语句
* @return 预编译声明
*/
private PreparedStatement getPreparedStatement(String sql, Object... params) throws DataAccessException {
PreparedStatement pstmt = getPreparedStatement(sql);
setParameters(pstmt, params);
return pstmt;
}
/**
* @param sql SQL语句
* @return 预编译声明
*/
private PreparedStatement getPreparedStatement(String sql) throws DataAccessException {
try {
return conn.prepareStatement(sql);
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DataAccessException(e);
}
}
/**
* 为预编译声明传入参数
* @param pstmt 预编译声明
* @param params 参数
* @throws DataAccessException
*/
private void setParameters(PreparedStatement pstmt, Object... params) throws DataAccessException {
try {
for (int i = 0; i < params.length; i++) {
pstmt.setObject(i + 1, params[i]);
}
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DataAccessException(e);
}
}
/**
* 执行更新操作
* @param pstmt
* @return 影响行数
* @throws DataAccessException
*/
private int executeUpdate(PreparedStatement pstmt) throws DataAccessException {
try {
return pstmt.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DataAccessException(e);
}
}
/**
* 执行查询操作
* @param pstmt 预编译声明
* @return 结果集
* @throws DataAccessException
*/
private ResultSet executeQuery(PreparedStatement pstmt) throws DataAccessException {
try {
return pstmt.executeQuery();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DataAccessException(e);
}
}
/**
* 执行查询操作
* @param sql SQL语句
* @param params 参数
* @return 结果集
* @throws DataAccessException
*/
private ResultSet executeQuery(String sql, Object... params) throws DataAccessException {
return executeQuery(getPreparedStatement(sql, params));
}
/**
* 移动到下一行记录
* @param rs 结果集
* @return 是否有下一行记录
* @throws DataAccessException
*/
private boolean nextResult(ResultSet rs) throws DataAccessException {
try {
return rs.next();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DataAccessException(e);
}
}
/**
* 映射
* @param rs 结果集
* @return 映射结果
* @throws DataAccessException
*/
private <T> T convertResult(ResultSet rs, ResultConverter<T> converter) throws DataAccessException {
try {
return converter.convert(rs);
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DataAccessException(e);
}
}
}
数据库存取异常
package org.dave.common.database.access;
/**
* 数据库存取异常
* @author David Day
*/
@SuppressWarnings("serial")
public class DataAccessException extends RuntimeException {
public DataAccessException(Throwable cause) {
super(cause);
}
}
分享到：
发表评论
相关推荐
自己写的一个JDBC通用DAO 有几点需要注意: 1.数据库命明目前只支持没下血杠命名(_) 2.表ID字段名取名有2种方式 (1)ID (2)TableName + ID 例如:user表 则取名为 id 或者 userid 因为没有用xml来映射表结构确定哪一个...
在实现通用DAO时，反射通常用于动态调用数据库操作的方法，比如SQL查询。例如，在`UsersDAO.java`中，可能有以下代码： ```java public class UsersDAO extends BaseDao<Users> { @Override public void save...
本篇将围绕“Spring3 JDBC通用DAO封装”这一主题展开，介绍如何实现一个高效的DAO层，并分享相关代码示例。 1. **Spring3 JDBC概述** Spring3 JDBC通过提供JdbcTemplate和SimpleJdbcInsert等工具类，帮助开发者...
在Java中，实现通用DAO通常涉及到JDBC（Java Database Connectivity）和JNDI（Java Naming and Directory Interface）两种不同的数据库连接方式。 首先，让我们来详细了解一下JDBC。JDBC是Java中用于与关系型数据库...
在这个"JDBCTemplate+JavaPOJO实现通用DAO"的项目中，我们将探讨如何利用这两者构建一个通用的DAO层。 首先，Java POJO（Plain Old Java Object）是指那些没有特殊约束的简单Java对象，通常用于表示数据库中的实体...
3. 数据库兼容性：通用数据库操作类应尽可能地兼容多种数据库，考虑使用JDBC的兼容层如Apache的DBUtils库，以减少不同数据库之间的差异。 4. 安全性：避免在代码中硬编码数据库凭据，而是使用配置文件，提高系统的...
**Hibernate原生通用DAO**是基于Hibernate框架设计的一种简化数据访问操作的方式，它模仿了Spring框架中的`HibernateTemplate`类，旨在提供一个简单易用的DAO（Data Access Object）层，方便开发人员进行数据库操作...
通用DAO的概念旨在减少数据库操作的重复性工作，提高代码的可复用性和可维护性。本文将深入探讨Java语言中如何使用反射机制实现通用DAO，并通过提供的"通用DAO源码及示例"来阐述这一概念。 首先，我们需要理解什么...
jdbc详细测试用例，包括connection ，statement，preparedstatement，resultset，BeanUtils，DBUtils，数据库连接池dbcp，cp03的单元测试，及dao层的统一封装，适合项目开发人员学习和项目中使用。
在这个"我的通用DAO理解"的资源中，我们可以看到作者提供了一个封装了数据库操作的DAO实现，这通常包括增删查改等基本功能，对于Java开发者来说，这是一个非常实用的工具或学习案例。 首先，让我们详细了解一下DAO...
通过使用`JdbcTemplate`，开发者可以避免编写大量重复的JDBC代码，同时减少数据库操作中的错误。 `JdbcTemplate`的泛型Dao实现是一种设计模式，目的是提高代码的可重用性和可维护性。通过定义一个泛型接口，我们...
通用Dao的核心思想是将数据库操作进行抽象，形成一套通用的方法，如增删改查（CRUD：Create, Read, Update, Delete）。这样，开发者可以专注于业务逻辑，而无需关心底层的SQL执行和资源管理。下面我们将详细探讨如何...
总结，"JSP数据库通用模块开发与系统移植"涉及到的技术和实践包括JSP语法、JDBC操作、模块化设计、DAO模式、系统移植策略、异常处理、安全性、性能优化、测试以及文档编写。掌握这些知识点，能够帮助开发者构建高效...
在IT领域，尤其是在数据库管理与应用开发中，DAO（Data Access Object）模式是一种常见的设计模式，用于封装对数据源（如关系数据库）的访问。它提供了一种将业务逻辑与数据访问逻辑分离的方法，使得代码更易于维护...
在"java编程技术-JDBC数据库访问.ppt"这个文件中，可能详细阐述了上述概念的实例和步骤，包括如何配置数据库连接，如何编写DAO类，如何使用预处理语句执行SQL，以及如何管理和关闭数据库资源等。 总的来说，这个...
标题中的“两个通用DAO”指的是在软件开发中，特别是Java后端开发中常见的两种数据库访问对象（DAO）设计模式。DAO是一种设计模式，用于封装对数据库的操作，将数据访问层与业务逻辑层分离，提高代码的可重用性和可...
Mybatis通用DAO设计封装主要涉及的是在Java开发中如何高效地使用Mybatis框架进行数据库操作。Mybatis是一款轻量级的持久层框架，它避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。通过提供自定义SQL、存储...
【基于Java的数据库通用转储工具的研究】 在现代企业信息化进程中，数据库是不可或缺的重要组成部分，企业根据业务需求可能会采用多种不同类型的数据库。为了确保数据库的安全性、提高效率、简化数据迁移过程并增强...