zhangskills
- 浏览: 27823 次
- 性别:
- 来自: 上海
-
最新评论
-
狂战天下：
hehe:D
国外大师所积累的20条编程经验(转载) -
hellolaojiang：
很不错，共勉。
展望未来，总结过去10年的程序员生涯，给程序员小弟弟小妹妹们的一些总结性忠告（转） -
wenke：
学习了，谢谢分享。
展望未来，总结过去10年的程序员生涯，给程序员小弟弟小妹妹们的一些总结性忠告（转） -
ilinxiao：
国外大师所积累的20条编程经验(转载) -
haiyangyiba：
要是有原理说明最好了
java版俄罗斯方块（原创）
package com.drug.db;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
/**
* 自己写的一个数据库工具类，希望可以封装所有的数据库操作
* 直接对封装好的数据库对象javaBean进行操作
*
* 数据库中表中的字段名必须首字母大写
* 封装好的数据对象类javaBean中的变量必须和数据库表中的字段相对应，（首字母不用大写）
*
* 这样以后修改数据库，只需要对应的修改一下数据对象类javaBean就行了，呵呵
*
* 本人java还在自学中，望大家多多指正
*/
public class DBUtil {
/**
* 方 法 名： getTableRowCount
* 功能描述： 获取表的行数
* 输入参数: tableName:表名
* 返 回 值： int
* 编 码 人: zmj
* 编码时间: 2010-2-8 上午11:10:26
*/
public int getTableRowCount(String tableName) {
Connection con = null;
PreparedStatement pst = null;
ResultSet rs = null;
int rowCount = -1;
try {
String sql = "select * from " + tableName;
con = getCon();
pst = con.prepareStatement(sql, ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
rs = pst.executeQuery();
rs.last();
rowCount = rs.getRow();
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
close(con, pst, rs);
}
return rowCount;
}
/**
* 方 法 名：hasElem
* 功能描述：判断表中是否含有该元素
* 输入参数: tableName：表名，keyName：查询的键值，key用来查询的键
* 返 回 值： boolean
* 编 码 人: zmj
* 编码时间: 2010-2-20 上午10:26:33
*/
public boolean hasElem(String tableName, String keyName, Object key) {
Connection con = null;
PreparedStatement pst = null;
ResultSet rs = null;
String sql = "select * from " + tableName + " where "
+ firstUpper(keyName) + "=?";
try {
con = getCon();
pst = con.prepareStatement(sql);
setObject(pst, 1, key);
rs = pst.executeQuery();
if (rs.next()) {
return true;
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
} finally {
close(con, pst, rs);
}
return false;
}
/**
* 方 法 名：getTableElem
* 功能描述： 获取数据库中一个表中的全部数据
* 输入参数:tableName：表名，beanName：用来封闭的javaBean
* 返 回 值： ArrayList<Object>
* 编 码 人: zmj
* 编码时间: 2010-2-20 上午08:16:52
*/
public ArrayList<Object> getTableElem(String tableName, String beanName) {
return getElemList(tableName, beanName, 1, -1);
}
/***
* 方 法 名：getTable
* 功能描述：获取数据库中一个表中的数据
* 输入参数:tableName:表名，beanName：用来封装的javaBean，offset：偏移量，count：取出的记录条数，为-1时表示全部
* 返 回值：ArrayList<Object>
* 编 码 人: zmj
* 编码时间: 2010-2-8
* **/
public ArrayList<Object> getElemList(String tableName, String beanName,
int offset, int count) {
Connection con = null;
PreparedStatement pst = null;
ResultSet rs = null;
ArrayList<Object> rs_list = new ArrayList<Object>();
try {
String sql = "select * from " + tableName;
con = getCon();
pst = con.prepareStatement(sql, ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
rs = pst.executeQuery();
String[] paramName = tableColName(rs);
Class<?> beanClass = Class.forName(beanName);
if (offset > 1)
rs.absolute(offset - 1);
else if (offset < 0 && offset != -1)
return rs_list;
while (rs.next() && (count == -1 || count-- > 0)) {
Object bean = beanClass.newInstance();
saveBean(bean, rs, paramName);
rs_list.add(bean);
}
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} finally {
close(con, pst, rs);
}
return rs_list;
}
/**
* 方 法 名：fuzzySearch
* 功能描述： 进行模糊查询
* 输入参数: tableName：表名，beanName：用来封装的javaBean，
keyName：查询的键值，key用来查询的键，offset：偏移量，count：返回的最大个数，-1表示全部
* 返 回 值： ArrayList<Object>
* 编 码 人: zmj
* 编码时间: 2010-2-8 下午01:44:23
*/
public ArrayList<Object> fuzzySearch(String tableName, String beanName,
String fuzzyKeyName, String fuzzyKey, Object[][] key, int offset,
int count) {
Connection con = null;
PreparedStatement pst = null;
ResultSet rs = null;
ArrayList<Object> rs_list = new ArrayList<Object>();
try {
String sql = "select * from " + tableName + " where "
+ firstUpper(fuzzyKeyName) + " like ?";
for (int i = 0; i < key.length; i++) {
if (key[i].length == 2) {
sql += " and " + firstUpper((String) key[i][0]) + "=?";
}
}
con = getCon();
pst = con.prepareStatement(sql, ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
pst.setObject(1, "%" + fuzzyKey + "%");
for (int i = 0; i < key.length; i++) {
if (key[i].length == 2) {
this.setObject(pst, i + 2, key[i][1]);
}
}
rs = pst.executeQuery();
String[] paramName = tableColName(rs);
Class<?> beanClass = Class.forName(beanName);
if (offset > 1)
rs.absolute(offset - 1);
else if (offset < 0 && offset != -1)
return rs_list;
while (rs.next() && (count == -1 || count-- > 0)) {
Object bean = beanClass.newInstance();
saveBean(bean, rs, paramName);
rs_list.add(bean);
}
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} finally {
close(con, pst, rs);
}
return rs_list;
}
/***
* 方 法 名：getElem
* 功能描述：获取数据库中一个表中的一条记录
* 输入参数:tableName:表名，beanName：javaBean的名字
* 返 回 值：Object
* 编 码 人: zmj
* 编码时间: 2010-2-8
* @throws SQLException
* **/
public Object getElem(String tableName, String keyName, Object key,
String beanName) {
Connection con = null;
PreparedStatement pst = null;
ResultSet rs = null;
String sql = "select * from " + tableName + " where "
+ firstUpper(keyName) + "=?";
String[] paramName = null;
try {
con = getCon();
pst = con.prepareStatement(sql);
setObject(pst, 1, key);
rs = pst.executeQuery();
paramName = tableColName(rs);
Class<?> beanClass;
beanClass = Class.forName(beanName);
Object bean = null;
bean = beanClass.newInstance();
if (rs.next()) {
saveBean(bean, rs, paramName);
}
return bean;
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} finally {
close(con, pst, rs);
}
return null;
}
/***
* 方 法 名：insert
* 功能描述：将JavaBean添加到数据库表table中
* 输入参数: tableName:表名，bean：javaBean
* 返 回 值：int
* 编 码 人: zmj
* 编码时间: 2010-2-8
* **/
public int insert(String tableName, Object bean) {
Connection con = null;
PreparedStatement pst = null;
StringBuilder sql = new StringBuilder("insert into " + tableName + "(");
try {
Object[][] beanObj = bean2Array(bean);
int n = beanObj.length;
if (n < 1) {
return 0;
}
for (int i = 0; i < n; i++) {
if (i != 0)
sql.append(",");
sql.append(beanObj[i][0]);
}
sql.append(") values(");
for (int i = 0; i < n; i++) {
if (i != 0)
sql.append(",");
sql.append("?");
}
sql.append(")");
con = getCon();
pst = con.prepareStatement(sql.toString());
for (int i = 0; i < n; i++) {
setObject(pst, i + 1, beanObj[i][1]);
}
return pst.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} finally {
close(con, pst);
}
return 0;
}
/**
* 方 法 名：updateElem
* 功能描述： 更新表中的一个元素
* 输入参数: tableName，keyName，key，bean
* 返 回 值： int
* 编 码 人: zmj
* 编码时间: 2010-2-8 上午11:30:18
*/
public int updateElem(String tableName, String keyName, Object key,
Object bean) {
Connection con = null;
PreparedStatement pst = null;
StringBuilder sql = new StringBuilder("update " + tableName + " set ");
try {
Object[][] beanObj = bean2Array(bean);
int n = beanObj.length;
if (n < 1) {
return 0;
}
for (int i = 0; i < n; i++) {
if (i != 0)
sql.append(",");
sql.append(beanObj[i][0] + "=?");
}
sql.append(" where " + firstUpper(keyName) + "=?");
con = getCon();
pst = con.prepareStatement(sql.toString());
int i = 0;
for (; i < n; i++) {
setObject(pst, i + 1, beanObj[i][1]);
}
setObject(pst, i + 1, key);
return pst.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} finally {
close(con, pst);
}
return 0;
}
/**
* 方 法 名： deleteElem
* 功能描述： 删除表中的一条记录
* 输入参数: tableName：表名， keyName：键名 key：键值
* 返 回 值： int
* 编 码 人: zmj
* 编码时间: 2010-2-8 下午01:47:08
*/
public int deleteElem(String tableName, String keyName, Object key) {
Connection con = null;
PreparedStatement pst = null;
StringBuilder sql = new StringBuilder("delete from " + tableName);
try {
sql.append(" where " + firstUpper(keyName) + "=?");
con = getCon();
pst = con.prepareStatement(sql.toString());
setObject(pst, 1, key);
int count = pst.executeUpdate();
return count;
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} finally {
close(con, pst);
}
return 0;
}
/**
* 方 法 名：setObject
* 功能描述：私有方法，设置preparedStatement的setXXX项
* 输入参数: pst：PreparedStatement对象，i：列的位置，obj：要插入的对象
* 返 回 值： void
* 编 码 人: zmj
* 编码时间: 2010-2-8 上午11:13:02
*/
private void setObject(PreparedStatement pst, int i, Object obj)
throws SQLException {
if (obj == null) {
pst.setString(i, null);
} else if (obj.getClass() == java.util.Date.class) {
long l = ((java.util.Date) obj).getTime();
java.sql.Timestamp t = new java.sql.Timestamp(l);
pst.setTimestamp(i, t);
} else {
pst.setObject(i, obj);
}
}
// 私有方法，把javabean存放到Object二维数组中
private Object[][] bean2Array(Object bean) {
Class<? extends Object> beanClass = bean.getClass();
Field[] field = beanClass.getDeclaredFields();
Method[] method = beanClass.getDeclaredMethods();
ArrayList<Object> list = new ArrayList<Object>();
for (int i = 0; i < field.length; i++) {
for (int j = 0; j < method.length; j++) {
String methodName = method[j].getName();
if (isGetMethod(methodName)
&& methodName.contains(firstUpper(field[i].getName()))) {
Object o = null;
try {
o = method[j].invoke(bean);
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
if (o != null) {
list.add(field[i].getName());
list.add(o);
}
}
}
}
int m = list.size();
if (m < 1 || m % 2 != 0) {
return new Object[0][0];
}
Object[][] bean_obj = new Object[m / 2][2];
Iterator<Object> iter = list.iterator();
int i = 0;
while (iter.hasNext()) {
bean_obj[i][0] = iter.next();
bean_obj[i][1] = iter.next();
i++;
}
return bean_obj;
}
// 私有方法，返回表中列名
private String[] tableColName(ResultSet rs) throws SQLException {
ResultSetMetaData rsmd = rs.getMetaData();
int n = rsmd.getColumnCount();
String[] name = new String[n];
for (int i = 0; i < n; i++) {
name[i] = rsmd.getColumnName(i + 1);
}
return name;
}
// 私有方法，保存ResultSet一行记录到一个javaBean中
private void saveBean(Object bean, ResultSet rs, String[] paramName)
throws SQLException {
Method[] method = bean.getClass().getDeclaredMethods();
for (int i = 0; i < paramName.length; i++) {
for (int j = 0; j < method.length; j++) {
String methodName = method[j].getName();
if (methodName.endsWith(paramName[i])
&& isSetMethod(methodName)) {
Object param = rs.getObject(paramName[i]);
if (param != null) {
// 如果为Timestamp类，则转换为Date类
if (param.getClass() == java.sql.Timestamp.class) {
long l = ((java.sql.Timestamp) param).getTime();
param = new java.util.Date(l);
}
try {
method[j].invoke(bean, param);
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
}
}
}
// 私有方法，判断是否为getter方法
private boolean isGetMethod(String methodName) {
if (methodName == null)
return false;
return methodName.startsWith("is") || methodName.startsWith("get");
}
// 私有方法，判断是否为setter方法
private boolean isSetMethod(String methodName) {
if (methodName == null)
return false;
return methodName.startsWith("set");
}
// 私有方法，将首字母大写
private String firstUpper(String s) {
return s.substring(0, 1).toUpperCase() + s.substring(1);
}
// 私有方法，获取数据库连接
private Connection getCon() throws ClassNotFoundException, SQLException {
DB.getInstance();
return DB.getConnection();
}
// 私有方法，关闭数据库操作1,用于查询数据库操作
private void close(Connection con, PreparedStatement pst, ResultSet rs) {
try {
if (rs != null)
rs.close();
if (pst != null)
pst.close();
if (con != null)
DB.release(con);
} catch (SQLException e) {
e.printStackTrace();
}
}
// 私有方法，关闭数据库操作2,用于更新数据库操作
//我用的数据库为access，不知道为什么，数据库Connection不关闭，数据库不更新，求解！！
private void close(Connection con, PreparedStatement pst) {
try {
if (pst != null)
pst.close();
if (con != null) {
con.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/*
* 自己写的一个很简单的数据库连接池
*/
package com.drug.db;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Stack;
public class DB {
private static DB DB_INSTANCE = null;
private static int MAX = 40;
private static Stack<Connection> CON_POOL = new Stack<Connection>();
// 数据库配置
private static String className = "sun.jdbc.odbc.JdbcOdbcDriver";
private static String url = "jdbc:odbc:test";
// 同步对象
private final static byte[] lock = new byte[0];
private DB() throws ClassNotFoundException {
Class.forName(className);
}
// 返回单一实例
public static DB getInstance() throws ClassNotFoundException {
if (DB_INSTANCE == null) {
DB_INSTANCE = new DB();
}
return DB_INSTANCE;
}
// 获取连接
public static Connection getConnection() throws SQLException {
synchronized (lock) {
if (CON_POOL.isEmpty()) {
return DriverManager.getConnection(url);
}
return CON_POOL.pop();
}
}
// 释放连接
public static void release(Connection con) throws SQLException {
synchronized (lock) {
if (con == null || con.isClosed()) {
return;
} else if (CON_POOL.size() < MAX + 1) {
CON_POOL.push(con);
} else {
con.close();
}
}
}
}
分享到：
发表评论
-
java 数据库连接池 c3p0 使用及参数详解,支持重连（转）
2011-10-24 16:00 1239import java.sql.Connection; ... -
Myeclipse8.6正确安装svn插件的方法
2011-08-28 15:47 688使用eclipse的svn时，没有出现问题，不过用myec ... -
md5加密
2011-01-08 11:05 758import java.security.Message ... -
java版俄罗斯方块（原创）
2010-03-19 11:22 1521刚开始学习java的时候学习了一下awt，当时就没怎么学好，现 ... -
把一个long型阿拉伯数字转换成中文数字（原创）
2010-02-04 17:20 1295刚申请的博客，写几个小程序练练手，也正好充一下门面，呵呵，欢迎 ... -
自己用递归写的组合算法遇到的问题
2010-02-03 08:33 974public List zuhe(char[] c, i ...
相关推荐
在IT领域，数据库是存储和管理数据的核心工具，而QT是一个强大的跨平台应用程序开发框架，尤其在GUI设计和网络编程方面表现出色。本项目通过QT封装了对多种数据库的接口类，包括SQL Server、MySQL、SQLite和ODBC，...
使用这些模板，开发者可以快速地根据自己的数据库表结构定制出相应的数据库操作类，大大提高了开发效率。同时，由于MFC对ODBC和DAO的封装，使得数据库操作更加面向对象，代码可读性和可维护性也得到了提升。 在实际...
MySQL数据库封装类是一种为了简化与MySQL数据库交互而设计的编程工具。在开发过程中，通过封装类，开发者可以更高效、...在实际项目中，选择或编写一个适合自己项目的数据库封装类，能有效提升开发效率和系统稳定性。
总的来说，"sqlite数据库操作封装类"是一个强大的工具，可以帮助开发者更高效、更安全地操作SQLite数据库，无论是简单的数据存储还是复杂的业务逻辑，都能提供便利。通过合理的接口设计和内部实现，可以极大地提升...
在数据库操作中，封装可以将数据库连接、查询、插入、更新和删除等操作集中在一个类中，对外提供简洁的接口，隐藏内部复杂实现，从而降低代码的耦合度。 对于"Access数据库操作封装类库"，我们可以设计一个名为`...
同时，为了适应不同数据库，可以设计成模板方法模式，提供一个抽象的数据库操作类，然后针对每个数据库（如MySQL、Oracle、SQL Server等）创建具体的实现类。 总之，`MySql数据库连接封装类`是Java编程中常用的一种...
数据库Dao（Data Access Object）封装类是软件开发中一个重要的设计模式，特别是在Java或类似的面向对象编程语言中，用于处理数据库交互。 Dao层是MVC（Model-View-Controller）架构的一部分，它作为业务逻辑层与...
在这个名为"JAVA操作数据库模板代码"的压缩包中，我们有两个关键文件：`ConnToDB.java`和`DBConf.properties`。这两个文件共同构成了一个简单的JDBC数据库操作模板。 首先，`DBConf.properties`文件是配置文件，...
本讲义可能包含实际案例，例如如何设计和实现一个基于面向对象数据库的图形设计系统，或者在生物信息学中如何利用面向对象数据库来存储和检索基因序列数据。 通过学习这门课程，读者将能够理解和运用面向对象数据库...
在这个特定的场景中，数据库连接类是一个封装了与MySQL交互逻辑的对象，它可以简化数据库连接、查询执行、结果处理等操作。这样的类通常包含方法如`connect()`、`disconnect()`、`query()`、`fetch()`等。 在描述中...
本资源"简单三层模板_代码生成_C#_数据库模板_"提供了一个基于C#语言的数据库模板，适用于快速开发和代码生成，使得开发者可以更高效地处理数据库操作。 1. **表现层（Presentation Layer）**： 表现层是用户与...
总结来说，"对java jdbc轻量级封装的一个jar包"是一个优化了数据库操作的工具，它简化了原本JDBC的使用流程，提高了开发效率，降低了出错的可能性，并且往往集成了连接池和一些其他便利功能，为Java开发者提供了一种...
例如，你可以创建一个`LMDBEnv`对象，然后开启一个读写事务，读取或修改数据库中的数据，最后在事务完成后自动提交或回滚。在这个过程中，你可以利用C++11的新特性来编写简洁、高效的代码。 在"drycpp-lmdbxx-842af...
这个"jsp连接数据库通用类"旨在为各种JSP应用提供一个标准的方式来访问和操作数据库，无论何时需要进行数据库交互，都可以便捷地调用此类。 通用数据库连接类通常包含以下几个核心组件和功能： 1. **配置信息**：...
这个类库提供了一个简便的方法来执行常见的数据库操作，如查询、插入、更新和删除数据。 首先，我们来看`IniFiles.cs`文件，这通常包含了处理INI配置文件的类。INI文件是一种简单的文本格式，用于存储应用程序的...
通过这种方式，我们可以将数据库操作的复杂性封装在一个独立的组件中，使得应用程序的其余部分专注于业务逻辑，而不是数据库交互的细节。 总结来说，这个压缩包提供的PHP类实现了面向对象的MySQL数据库操作，遵循了...
7. **对象映射（ORM）**：更高级的封装可能会实现对象关系映射，将数据库记录直接映射为C++对象，简化数据访问。 8. **示例和教程**：为了帮助用户快速上手，封装类可能附带了示例代码和使用教程，展示如何创建...
Java自定义的类似ORM的数据库操作框架是一种高效且灵活的数据访问解决方案，旨在简化数据库的交互过程，类似于流行的ORM（对象关系映射）框架，如Hibernate和MyBatis。ORM框架的核心理念是将数据库操作转化为面向...
总结来说，"jsp连Sql_server数据库模板"是一个帮助开发者快速实现JSP与SQL Server数据库连接的工具，它可能包含了JDBC驱动、连接配置、数据库操作的模板代码，以及必要的异常处理机制。掌握这些知识点对于开发基于...
首先，数据库通用类的设计目标是提供一个独立于具体数据库实现的接口，使得开发者可以编写一次代码，就能在MySQL、Oracle、SQL Server、PostgreSQL等多种数据库上运行。这类类通常会包含连接管理、查询执行、事务...