对于属性比较多的bean,如果不使用hibernate 或者ibatis等持久化解决方案,写查询函数时,单单将ResultSet 转换成Object就是一件很痛苦的事情,因此可以采用java反射机制做一个BaseDao,把ResultSet 映射到Object 的操作封装起来,简化了DAO的开发,
本文参照了[url]http://blog.csdn.net/cping1982/archive/2007/10/01/1808647.aspx
[/url]并且做了一点改进
public static String[][] proterty2Column =
{{"member_id","memberId"},
{"name", "name"}};
/**
* change the first char to upper case
* @param s
* @return
*/
private static String upperFirstChar(String s){
char [] chars = s.toCharArray();
chars[0] = Character.toUpperCase(chars[0]);
return new String(chars);
}
/**
* ResultSet 映射成 Object
* @param clzz
* @param rs
* @param obj
* @param fieldName
* @param varibleName
* @throws NoSuchMethodException
* @throws IllegalAccessException
* @throws InvocationTargetException
* @throws SQLException
* @throws NoSuchFieldException
* @throws SecurityException
*/
private void mapResultSet2Object(ResultSet rs, Object obj, String propertyName,
String columName)
throws NoSuchMethodException, IllegalAccessException,
InvocationTargetException, SQLException,
SecurityException, NoSuchFieldException {
Class < ? extends Object >clazz = obj.getClass();
Class < ? extends Object >propertyType = clazz.getDeclaredField(propertyName).
getType();
Method method = clazz.getDeclaredMethod("set"+
upperFirstChar( propertyName ), new Class[] { propertyType });
if (propertyType == String.class)
method.invoke(obj, (Object [])new String[]
{rs.getString( columName ) });
else if (propertyType == int.class)
method.invoke(obj, (Object [])new Integer[]
{new Integer( rs.getInt( columName )) });
else if (propertyType == float.class)
method.invoke(obj, (Object [])new Float[]
{new Float( rs.getFloat( columName )) });
else if (propertyType == long.class)
method.invoke(obj, (Object [])new Long[]
{new Long( rs.getLong( columName )) });
else if (propertyType == double.class)
method.invoke(obj, (Object [])new Double[]
{new Double( rs.getDouble( columName )) });
else if(propertyType == Date.class){
method.invoke(obj, (Object [])new Date[]
{rs.getDate(columName)});
}
}
/**
* 单行查询
* @param
* @param conn
* @param sql
* @param clazz
* @param params
* @return
* @throws Exception
*/
public <T> T getItem(Connection conn, String sql, Class<T> clazz,
String params[])throws Exception{
PreparedStatement pstmt = null;
ResultSet rset = null;
T t = null;
try {
pstmt = conn.prepareStatement(sql);
//set parameter
for(int i=0; i<params.length; i++){
pstmt.setString(i+1, (String)params[i]);
}
rset = pstmt.executeQuery();
if (rset.next()) {
t = clazz.newInstance();
for(int i=0; i< proterty2Column.length; i++) {
String propertyName = proterty2Column[i][1].trim();
String ColumnName = proterty2Column[i][0].trim();
mapResultSet2Object(rset, t, propertyName, ColumnName);
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
DBUtil.closeAll(conn, pstmt, rset);
}
return t;
}
/**
* 多行查询
* @param
* @param conn
* @param sql
* @param proterty2Column
* @param clazz
* @return
* @throws Exception
*/
public <T> List <T> getItems(Connection conn, String sql, Class<T> clazz,
String[] params) throws Exception{
if (proterty2Column.length == 0)
return null;
PreparedStatement pstmt = null;
ResultSet rset = null;
List<T> list = new ArrayList<T>();
try {
pstmt = conn.prepareStatement(sql);
for(int i=0; i<params.length; i++){
pstmt.setString(i+1, (String)params[i]);
}
rset = pstmt.executeQuery();
while (rset.next()) {
for(int i=0; i< proterty2Column.length; i++) {
String propertyName = proterty2Column[i][1].trim();
String ColumnName = proterty2Column[i][0].trim();
fetchResult2Object(rset, obj, propertyName, ColumnName);
}
if( null == obj ) continue;
list.add(obj);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
DBUtil.closeAll(conn, pstmt, rset);
}
return list;
}
分享到:
相关推荐
总的来说,Java泛型BaseDao与BaseService是企业级Java开发中的重要概念,它们结合了泛型的优势,为数据访问和业务处理提供了灵活、安全的抽象基础。理解并熟练运用这些技术,将使你的Java开发能力更上一层楼。
1. 泛型BaseDAO:`GenericBaseDao.java`和`GenericBaseDaoInter.java` 泛型BaseDAO的主要目的是为各种实体类提供一个通用的数据访问接口。`GenericBaseDao.java`实现了`GenericBaseDaoInter.java`接口。通过定义泛型...
例如,你可以创建一个泛型BaseDAO接口,如下所示: ```java public interface BaseDAO<T> { void save(T entity); void update(T entity); void deleteById(Object id); T findById(Object id); List<T> find...
"基于BaseDao的手动数据库操作"是一个常见的话题,尤其在Java开发中。BaseDao是一种设计模式,它通常被用来作为数据库访问对象(DAO)的基础,用于封装数据库的基本CRUD(创建、读取、更新、删除)操作。这种模式...
7. **泛型应用**:为了提高代码的可复用性和类型安全性,`BaseDAO`往往采用泛型设计。通过指定具体的实体类型,`BaseDAO<T>`可以为任何类型的实体提供数据访问服务。 8. **缓存支持**:Hibernate支持一级缓存...
在BaseDao中,泛型可以用来定义通用的类型参数,比如,使得BaseDao能够处理任何类型的实体对象,而无需为每种实体创建一个新的DAO类。 反射是Java的一个重要特性,它允许运行时动态地获取类的信息并调用其方法。在...
在`BaseDao.java`中,可能会定义一个泛型基类,如: ```java public abstract class BaseDao<T> { public abstract void save(T entity); public abstract T findById(ID id); // 其他通用操作 } ``` 这里的`...
1. **泛型**: BaseDAO通常会使用泛型来定义与特定实体类的关联,这样在具体使用时可以避免类型转换的麻烦。 2. **基本操作**: 包含CRUD(Create, Read, Update, Delete)等基本数据库操作,如insert、update、...
例如,我们可以定义一个`BaseDAO<T>`,其中`T`是代表实体类的泛型参数,然后在具体使用时传入如`User.class`或`Product.class`。 反射则常用于动态获取类的信息,如类名、属性、方法等,以及在运行时调用这些方法。...
在实际应用中,我们还需要为每个具体的实体类创建一个继承自`BaseDao`的子类,比如`UserDao`,然后通过泛型指定对应的实体类型。这样,我们就可以在子类中重写`BaseDao`的某些方法以实现特定的查询逻辑,或者添加新...
在SSH框架中,我们可以创建一个基础的泛型DAO接口,如`BaseDao<T>`,其中`T`代表任何实体类。这个接口通常包含基本的CRUD(创建、读取、更新、删除)操作,如`save()`, `get()`, `update()`, 和 `delete()`。然后,...
例如,我们可以创建一个`BaseDao<T>`接口,其中T代表任何实体类,然后针对每个实体类实现具体的DAO。 5. **分页**: 分页是Web应用中常用的一种功能,用于处理大数据量的查询结果,避免一次性加载所有数据导致性能...
例如,可以有一个`BaseDao<T>`接口,其中T代表任意实体类型,然后针对每种实体创建具体的Dao实现类。 在实际开发中,`base`可能是指基础配置文件或者示例代码,包括Spring的bean配置文件(如`beans.xml`)、Struts2...
接着,为了实现泛型Dao,我们需要定义一个基础的Dao接口,该接口扩展自ORMLite提供的`BaseDao, ID>`接口。`T`代表我们要操作的数据实体类,`ID`代表主键类型。例如: ```java public interface GenericDao, ID> ...
//获得当前类型的带有泛型类型的父类 ParameterizedType ptClass = (ParameterizedType) this.getClass().getGenericSuperclass(); //获得运行期的泛型类型 clazz = (Class) ptClass.getActualTypeArguments()[0]...
在描述的示例中,我们看到`BaseDao`是一个泛型抽象类,它有一个泛参数`M extends Serializable`。`OrganizationDao`和`UserDao`分别继承自`BaseDao`,并具体化了泛型类型,`OrganizationDao`中的`M`为`Organization`...
3. `BaseDAO.java`:可能是一个抽象类,包含了与数据库交互的一些共通逻辑,比如事务管理、Session的获取与关闭等。 4. `UserDAO.java`:一个具体的DAO实现,继承自`HibernateGenericDAO`,并指定User实体类的类型。...
在上述实例中,`BaseDao<T>`是一个泛型类,其中`T`代表一个未知的类型。这个泛型类主要用于实现数据库的基本操作,如增、删、查、改。通过继承`BaseDao<T>`,我们可以为不同的数据模型创建专门的DAO(Data Access ...
Java 中利用泛型和反射机制抽象DAO的实例 Java 中利用泛型和反射机制抽象DAO的实例是指在 Java 中使用泛型和反射机制来抽象出一个通用的DAO(Data Access Object),从而将DAO抽象到另一层次,提高代码的质量和可...
在构造函数中,通过`JdbcUtil.getConnection()`获取数据库连接,并通过反射机制获取`BaseDao`的父类泛型类型,从而得到`persistentClass`,这样我们就可以知道这个`BaseDao`实例对应的是哪个实体类。 `BaseDao`的...