`
q601180252
  • 浏览: 1067 次
  • 性别: Icon_minigender_1
  • 来自: 上海
最近访客 更多访客>>
文章分类
社区版块
存档分类
最新评论

帮看看这个dao

DAOSQLJavaEXTJ# 
阅读更多
package com.test.dao;

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.SQLException;
import java.util.ArrayList;
import java.util.List;
import com.test.util.DBUtil;
import com.test.GenericClass;


@SuppressWarnings("unchecked")
public class BaseDAO<T> implements DAO<T> {

private Class classs = GenericClass.getClass(this.getClass(), 0);

public void addOrUpdate(String sql, Object[] objects) {
}

public void del(String sql, Object[] objects) {
}

public T find(String where, Object[] objects) throws Exception {
Connection con = DBUtil.getConnection();
PreparedStatement ps = con.prepareStatement("select * from "
+ classs.getSimpleName() + where);
setPrames(ps, objects);
ResultSet rs = ps.executeQuery();
Field[] fields = classs.getDeclaredFields();
Method[] methods = classs.getDeclaredMethods();
T o = (T) classs.newInstance();
if (rs.next()) {
ext(rs, fields, methods, o);
}
return o;
}

public QueryResult<T> findAll(int frist, int max, String where,
Object[] objects) throws Exception {
QueryResult queryResult = new QueryResult();
Connection con = DBUtil.getConnection();
StringBuilder sql = new StringBuilder();
String wheres = (where == null || "".equals(where)) ? "" : " where "
+ where;
//如果frist 和max都为-1 就不需要分页
if (frist == -1 && max == -1) {
sql.append("select * from " + classs.getSimpleName());
sql.append(wheres);
} else {
sql
.append("select * from(select *,row_number() over(order by id) as rownumber from "
+ classs.getSimpleName()
+ " ) as s where rownumber between "
+ frist
+ " and " + max + "");
sql.append(" and " + where);
}
PreparedStatement ps = con.prepareStatement(sql.toString());
setPrames(ps, objects);
ResultSet rs = ps.executeQuery();
Field[] fields = classs.getDeclaredFields();
Method[] methods = classs.getDeclaredMethods();
List list = new ArrayList();
while (rs.next()) {
T o = (T) classs.newInstance();
ext(rs, fields, methods, o);
list.add(o);
}
queryResult.setRows(list);
ps = con.prepareStatement("select count(*) from "
+ classs.getSimpleName() + wheres);
setPrames(ps, objects);
rs = ps.executeQuery();
if (rs.next()) {
queryResult.setTotal(rs.getLong(1));
}
return queryResult;
}

private void ext(ResultSet rs, Field[] fields, Method[] methods, T o)
throws IllegalArgumentException, IllegalAccessException,
InvocationTargetException, SQLException {
for (int i = 0; i < fields.length; i++) {
for (int j = 0; j < methods.length; j++) {
if (methods[j].getName().equalsIgnoreCase(
"set" + fields[i].getName())) {
if (fields[i].getType().getSimpleName().equals("int")) {
methods[j].invoke(o, rs.getInt(fields[i].getName()));
} else if (fields[i].getType().getSimpleName().equals(
"String")) {
methods[j].invoke(o, rs.getString(fields[i].getName()));
} else if (fields[i].getType().getSimpleName().equals(
"float")) {
methods[j].invoke(o, rs.getFloat(fields[i].getName()));
}
}
}
}
}

private void setPrames(PreparedStatement ps, Object[] objects)
throws SQLException {
if (objects != null && objects.length > 0) {
for (int i = 0; i < objects.length; i++) {
ps.setObject(i + 1, objects[i]);
}
}
}

}
package com.test.util;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

@SuppressWarnings("unchecked")
public class GenerieUtils {
public static Class getClass(Class class1, int index) {
Type type = class1.getGenericSuperclass();
if (!(type instanceof ParameterizedType)) {
return Object.class;
}
Type[] types = ((ParameterizedType) type).getActualTypeArguments();
if (!(type instanceof Class)) {
return Object.class;
}
return (Class) types[index];
}
}
package com.test.dao;

import java.util.List;

public class QueryResult<T> {
private List<T> rows;
private long total;

public List<T> getRows() {
return rows;
}

public void setRows(List<T> rows) {
this.rows = rows;
}

public long getTotal() {
return total;
}

public void setTotal(long total) {
this.total = total;
}

}
增删改 不知道该怎么写好一点..........
本人学java还没一年 所以写的不好请见谅
分享到：
评论
19 楼 starcheney 2011-05-30  
瞅瞅我这个。。。。。 
public class ProductDaoImpl implements ProductDao {
	private HibernateTemplate template;
	public HibernateTemplate getTemplate() {
		return template;
	}
	public void setTemplate(HibernateTemplate template) {
		this.template = template;
	}

	public void deleteProduct(Product product) {
		template.delete(product);
	}

	public void insertProduct(Product product) {
		template.save(product);
	}

	@SuppressWarnings("unchecked")
	public List<Product> queryAllProducts() {
		return template.find("from Product");
	}

	public Product queryProductById(Integer id) {
		return (Product)template.get(Product.class, id);
		
	}

	@SuppressWarnings("unchecked")
	public List<Product> queryProductByName(final String productName) {
		return (List<Product>)template.execute(new HibernateCallback(){
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query q=session.createQuery("from Product as p where p.productName = ? ");
				q.setString(0, productName);
				return q.list();
			}	
		});
	}

	@SuppressWarnings("unchecked")
	public List<Product> queryProductByStatus(final Status status) {
		return (List<Product>)template.execute(new HibernateCallback(){
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query q=session.createQuery("from Product as p where p.status.id = ? ");
				q.setInteger(0, status.getId());
				return q.list();
			}
		});
	}

	public void updateProduct(Product product) {
		template.update(product);
	}
	@SuppressWarnings("unchecked")
	public List<Product> queryProductByProductType(final ProductType productType) {
		return (List<Product>)template.execute(new HibernateCallback(){
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query q=session.createQuery("from Product as p where p.productType.id=? ");
				q.setInteger(0, productType.getId());
				return q.list();
			}
		});
	}
	
	@SuppressWarnings("unchecked")
	public List<Product> queryAllProducts(final PageModel page) {
		Long size=(Long)template.find("select count(*) from Product as p order by p.id").get(0);
		page.setTotalCount(size.intValue());
		return (List<Product>)template.execute(new HibernateCallback(){
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query q=session.createQuery("from Product as p order by p.id");
				q.setFirstResult(page.getFirstResult());
				q.setMaxResults(page.getPageSize());
				return q.list();
			}
		});
	}

	@SuppressWarnings("unchecked")
	public List<Product> queryProductByName(final PageModel page,final String productName) {	
		return (List<Product>)template.execute(new HibernateCallback(){
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query q1=session.createQuery("select count(*) from Product as p where p.productName = ? order by p.id");
				q1.setString(0, productName);
				page.setTotalCount(q1.executeUpdate());
				Query q2=session.createQuery("from Product as p where p.productName = ? order by p.id");
				q2.setString(0, productName);
				q2.setFirstResult(page.getFirstResult());
				q2.setMaxResults(page.getPageSize());
				return q2.list();
			}});
	}

	@SuppressWarnings("unchecked")
	public List<Product> queryProductByProductType(final PageModel page,
			final ProductType productType) {
		return (List<Product>)template.execute(new HibernateCallback(){
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query q1=session.createQuery("select count(*) from Product as p where p.productType.id = ? order by p.id");
				q1.setInteger(0, productType.getId());
				page.setTotalCount(q1.executeUpdate());
				Query q2=session.createQuery("from Product as p where p.productType.id = ? order by p.id");
				q2.setInteger(0, productType.getId());
				q2.setFirstResult(page.getFirstResult());
				q2.setMaxResults(page.getPageSize());
				return q2.list();
			}});
	}

	@SuppressWarnings("unchecked")
	public List<Product> queryProductByStatus(final PageModel page,final Status status) {	
		return (List<Product>)template.execute(new HibernateCallback(){
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query q1=session.createQuery("select count(*) from Product as p where p.status.id = ? order by p.id");
				q1.setInteger(0, status.getId());
				page.setTotalCount(q1.executeUpdate());
				Query q2=session.createQuery("from Product as p where p.status.id = ? order by p.id");
				q2.setInteger(0, status.getId());
				q2.setFirstResult(page.getFirstResult());
				q2.setMaxResults(page.getPageSize());
				return q2.list();
			}});
	}
18 楼 kanny87929 2011-05-30  
蛋痛~~~~~~~~~~~~~~
17 楼 chinaway 2011-05-30  
不出意外的话，楼主要被扣分了。哈哈
这代码谁能看懂啊，太乱了
16 楼 haifeng_wc 2011-05-30  
一团糟的代码，很蛋疼的啊
15 楼 cw550284 2011-05-30  
whaosoft 写道
1年的写个这个不错了

....还在我上大学的时候，类似的这个封装我已经写过啦
14 楼 newypei 2011-05-30  
steafler 写道
建议不要用泛型



为什么啊？求解释，谢谢
13 楼 shunai 2011-05-30  
鼓励自己造轮子！继续加油!
12 楼 imacback 2011-05-30  
这样的式的没法看。。。
11 楼 hh161151 2011-05-30  
我把我的贴出来，你可以参考参考。 
package com.test.dao;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Date;
import java.util.List;

import javax.annotation.Resource;

import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;

import com.test.bean.Pager;
import com.test.bean.Search;
import com.test.bean.Pager.OrderType;

/**
 * Dao接口实现 - 基类实现
 * =======================================
 * @author  作者姓名：
 * @version 创建时间：Apr 8, 2011 5:30:19 PM
 * =======================================
 */
@Component
public class BaseDaoImpl<T, PK extends Serializable> implements BaseDao<T, PK> {

	private Class<T> entityClass;
	protected SessionFactory sessionFactory;

	@SuppressWarnings("unchecked")
	public BaseDaoImpl() {
		this.entityClass = null;
		//得到类的Class
        Class c = getClass();
        //返回本类的父类,包含泛型参数信息
        Type type = c.getGenericSuperclass();
        if (type instanceof ParameterizedType) {
            Type[] parameterizedType = ((ParameterizedType) type).getActualTypeArguments();
            this.entityClass = (Class<T>) parameterizedType[0];
        }
	}

	/**
	 * 设置SessionFactory
	 * @param sessionFactory - Hibernate的SessionFactory
	 */
	@Resource
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}

	/**
	 * 得到当前Session
	 * @return Session - Hibernate的Session
	 */
	protected Session getSession() {
		return sessionFactory.getCurrentSession();
	}
	
	/**
	 * 保存实体对象
	 * @param entity - 实体
	 * @return PK - 实体分配后的ID
	 */
	@SuppressWarnings("unchecked")
	public PK save(T entity) {
		Assert.notNull(entity, "entity is required");
		return (PK)getSession().save(entity);
	}
	
	/**
	 * 根据ID获取实体对象(get方式)
	 * @param id - 实体id
	 * @return T - 实体对象
	 */
	@SuppressWarnings("unchecked")
	public T get(PK id) {
		Assert.notNull(id, "id is required");
		return (T)getSession().get(entityClass, id);
	}
	
	/**
	 * 根据ID获取实体对象(load方式)
	 * @param id - id
	 * @return T - 实体对象
	 */
	@SuppressWarnings("unchecked")
	public T load(PK id) {
		Assert.notNull(id, "id is required");
		return (T)getSession().load(entityClass, id);
	}
	
	/**
	 * 删除实体对象
	 * @param entity - 实体对象
	 */
	public void delete(T entity) {
		Assert.notNull(entity, "entity is required");
		getSession().delete(entity);
	}
	
	/**
	 * 删除实体对象
	 * @param id - id
	 */
	public void delete(PK id) {
		Assert.notNull(id, "entity is required");
		T entity = load(id);
		getSession().delete(entity);
	}
	
	/**
	 * 更改实体对象
	 * @param entity - 实体对象
	 */
	public void update(T entity) {
		Assert.notNull(entity, "entity is required");
		getSession().update(entity);
	}
	
	/**
	 * 根据ID数组获取实体对象集合.
	 * @param ids - id数组
	 * @return List - 实体集合
	 */
	@SuppressWarnings("unchecked")
	public List<T> get(PK[] ids) {
		Assert.notEmpty(ids, "ids must not be empty");
		String hql = "from " + entityClass.getName() + " as model where model.id in(:ids)";
		return getSession().createQuery(hql).setParameterList("ids", ids).list();
	}
	
	/**
	 * 根据属性名和属性值获取实体对象
	 * @param propertyName - 属性名
	 * @param value - 属性值
	 * @return T - 对象
	 */
	@SuppressWarnings("unchecked")
	public T get(String propertyName, Object value) {
		Assert.hasText(propertyName, "propertyName must not be empty");
		Assert.notNull(value, "value is required");
		String hql = "from " + entityClass.getName() + " as model where model." + propertyName + " = ?";
		return (T) getSession().createQuery(hql).setParameter(0, value).uniqueResult();
	}
	
	/**
	 * 根据属性名和属性值获取实体对象集合
	 * @param propertyName - 属性名
	 * @param value - 属性值
	 * @return List - 对象集合
	 */
	@SuppressWarnings("unchecked")
	public List<T> getList(String propertyName, Object value) {
		Assert.hasText(propertyName, "propertyName must not be empty");
		Assert.notNull(value, "value is required");
		String hql = "from " + entityClass.getName() + " as model where model." + propertyName + " = ?";
		return getSession().createQuery(hql).setParameter(0, value).list();
	}
	
	/**
	 * 获取所有实体对象集合
	 * @return List - 实体集合
	 */
	@SuppressWarnings("unchecked")
	public List<T> getAll() {
		String hql = "from " + entityClass.getName();
		return getSession().createQuery(hql).list();
	}
	
	/**
	 * 获取所有实体对象总数.
	 * @return long - 实体对象总数
	 */
	public Long getTotalCount() {
		String hql = "select count(*) from " + entityClass.getName();
		return (Long) getSession().createQuery(hql).uniqueResult();
	}
	
	/**
	 * 根据ID数组删除实体对象
	 * @param ids - id数组
	 */
	public void delete(PK[] ids) {
		Assert.notEmpty(ids, "ids must not be empty");
		for (PK id : ids) {
			T entity = load(id);
			getSession().delete(entity);
		}
	}
	
	/**
	 * 根据Pager对象进行查询
	 * @param pager - 页面bean
	 * @return Pager - 页面bean
	 */
	public Pager findByPager(Pager pager) {
		if (pager == null) {
			pager = new Pager();
		}
		DetachedCriteria detachedCriteria = DetachedCriteria.forClass(entityClass);
		return findByPager(pager, detachedCriteria);
	}
	
	/**
	 * 根据Pager和DetachedCriteria对象进行查询
	 * @param pager - 页面bean
	 * @param detachedCriteria - Hibernate的detachedCriteria
	 * @return Pager - 页面bean
	 */
	public Pager findByPager(Pager pager, DetachedCriteria detachedCriteria) {
		if (pager == null) {
			pager = new Pager();
		}
		Integer pageNumber = pager.getPageNumber();
		Integer pageSize = pager.getPageSize();
		String property = pager.getProperty();
		String keyword = pager.getKeyword();
		String orderBy = pager.getOrderBy();
		OrderType orderType = pager.getOrderType();
		
		Criteria criteria = detachedCriteria.getExecutableCriteria(getSession());
		if (StringUtils.isNotEmpty(property) && StringUtils.isNotEmpty(keyword)) {
			String propertyString = "";
			if (property.contains(".")) {
				String propertyPrefix = StringUtils.substringBefore(property, ".");
				String propertySuffix = StringUtils.substringAfter(property, ".");
				criteria.createAlias(propertyPrefix, "model");
				propertyString = "model." + propertySuffix;
			} else {
				propertyString = property;
			}
			criteria.add(Restrictions.like(propertyString, "%" + keyword + "%"));
		}
		
		Integer totalCount = (Integer) criteria.setProjection(Projections.rowCount()).uniqueResult();
		
		criteria.setProjection(null);
		criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
		criteria.setFirstResult((pageNumber - 1) * pageSize);
		criteria.setMaxResults(pageSize);
		if (StringUtils.isNotEmpty(orderBy) && orderType != null) {
			if (orderType == OrderType.asc) {
				criteria.addOrder(Order.asc(orderBy));
			} else {
				criteria.addOrder(Order.desc(orderBy));
			}
		}
		pager.setTotalCount(totalCount);
		pager.setList(criteria.list());
		return pager;
	}
	
	
	/**
	 * 根据Search和Pager来查询
	 * @param search - 查询bean
	 * @param pager - 页面bean
	 * @return Pager - 页面bean
	 */
	public Pager searchByProperty(Search search, Pager pager){
		
		if (pager == null) {
			pager = new Pager();
		}
		if (search == null) {
			search = new Search();
		}
		Integer pageNumber = pager.getPageNumber();
		Integer pageSize = pager.getPageSize();
		String orderBy = pager.getOrderBy();
		OrderType orderType = pager.getOrderType();
		
		DetachedCriteria detachedCriteria = DetachedCriteria.forClass(entityClass);
		Criteria criteria = detachedCriteria.getExecutableCriteria(getSession());
		//循环取得条件(字符串类型)
		if(search.getStrProperty()!=null){
			for(int i=0; i < search.getStrProperty().size(); i++){
				String propertyStr = search.getStrProperty().get(i);
				String keywordStr = search.getStrKeyword().get(i);
				if (StringUtils.isNotEmpty(propertyStr) && StringUtils.isNotEmpty(keywordStr)) {
					criteria.add(Restrictions.like(propertyStr, "%" + keywordStr + "%"));
				}
			}
		}
		//循环取得条件(日期类型)
		if(search.getDateProperty()!=null){
			for(int i=0; i < search.getDateProperty().size(); i++){
				String propertyDate = search.getDateProperty().get(i);
				Date dateFrom = search.getDateFrom().get(i);
				Date dateTo = search.getDateTo().get(i);
				if (dateFrom != null && !"".equals(dateFrom) && dateTo != null && !"".equals(dateTo)) {
					criteria.add(Restrictions.between(propertyDate, dateFrom, dateTo));
				}
			}
		}
		//循环取得条件(整数类型)
		if(search.getIntProperty()!=null){
			for(int i=0; i < search.getIntProperty().size(); i++){
				String propertyInt = search.getIntProperty().get(i);
				Object intFrom = search.getIntFrom().get(i);
				Object intTo = search.getIntTo().get(i);
				if (intFrom != null && intTo != null) {
					criteria.add(Restrictions.between(propertyInt, intFrom, intTo));
				}
			}
		}
		
		Integer totalCount = (Integer) criteria.setProjection(Projections.rowCount()).uniqueResult();
		criteria.setProjection(null);
		criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
		criteria.setFirstResult((pageNumber - 1) * pageSize);
		criteria.setMaxResults(pageSize);
		//设定排序规则
		if (StringUtils.isNotEmpty(orderBy) && orderType != null) {
			if (orderType == OrderType.asc) {
				criteria.addOrder(Order.asc(orderBy));
			} else {
				criteria.addOrder(Order.desc(orderBy));
			}
		}
		pager.setTotalCount(totalCount);
		pager.setList(criteria.list());
		
		return pager;
	}
	
	/**
	 * 刷新session.
	 */
	public void flush() {
		getSession().flush();
	}

	/**
	 * 清除Session
	 */
	public void clear() {
		getSession().clear();
	}

	/**
	 * 清除某一对象.
	 */
	public void evict(Object object) {
		Assert.notNull(object, "object is required");
		getSession().evict(object);
	}
	
	/**
	 * 根据属性名、修改前后属性值判断在数据库中是否唯一(若新修改的值与原来值相等则直接返回true).
	 * @param propertyName	属性名称
	 * @param oldValue		修改前的属性值
	 * @param oldValue		修改后的属性值
	 * @return boolean
	 */
	public boolean isUnique(String propertyName, Object oldValue, Object newValue) {
		Assert.hasText(propertyName, "propertyName must not be empty");
		Assert.notNull(newValue, "newValue is required");
		if (newValue == oldValue || newValue.equals(oldValue)) {
			return true;
		}
		if (newValue instanceof String) {
			if (oldValue != null && StringUtils.equalsIgnoreCase((String) oldValue, (String) newValue)) {
				return true;
			}
		}
		T object = get(propertyName, newValue);
		return (object == null);
	}

	/**
	 * 根据属性名判断数据是否已存在.
	 * @param propertyName	属性名称
	 * @param value			值
	 * @return boolean
	 */
	public boolean isExist(String propertyName, Object value) {
		Assert.hasText(propertyName, "propertyName must not be empty");
		Assert.notNull(value, "value is required");
		T object = get(propertyName, value);
		return (object != null);
	}
	
}
10 楼 szcs10138456 2011-05-30  
先批评下你的代码规范
9 楼 287854442 2011-05-30   
package com.test.dao; 

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.SQLException; 
import java.util.ArrayList; 
import java.util.List; 
import com.test.util.DBUtil; 
import com.test.GenericClass; 


@SuppressWarnings("unchecked") 
public class BaseDAO<T> implements DAO<T> { 

private Class classs = GenericClass.getClass(this.getClass(), 0); 

public void addOrUpdate(String sql, Object[] objects) { 
} 

public void del(String sql, Object[] objects) { 
} 

public T find(String where, Object[] objects) throws Exception { 
Connection con = DBUtil.getConnection(); 
PreparedStatement ps = con.prepareStatement("select * from " 
+ classs.getSimpleName() + where); 
setPrames(ps, objects); 
ResultSet rs = ps.executeQuery(); 
Field[] fields = classs.getDeclaredFields(); 
Method[] methods = classs.getDeclaredMethods(); 
T o = (T) classs.newInstance(); 
if (rs.next()) { 
ext(rs, fields, methods, o); 
} 
return o; 
} 

public QueryResult<T> findAll(int frist, int max, String where, 
Object[] objects) throws Exception { 
QueryResult queryResult = new QueryResult(); 
Connection con = DBUtil.getConnection(); 
StringBuilder sql = new StringBuilder(); 
String wheres = (where == null || "".equals(where)) ? "" : " where " 
+ where; 
//如果frist 和max都为-1 就不需要分页 
if (frist == -1 && max == -1) { 
sql.append("select * from " + classs.getSimpleName()); 
sql.append(wheres); 
} else { 
sql 
.append("select * from(select *,row_number() over(order by id) as rownumber from " 
+ classs.getSimpleName() 
+ " ) as s where rownumber between " 
+ frist 
+ " and " + max + ""); 
sql.append(" and " + where); 
} 
PreparedStatement ps = con.prepareStatement(sql.toString()); 
setPrames(ps, objects); 
ResultSet rs = ps.executeQuery(); 
Field[] fields = classs.getDeclaredFields(); 
Method[] methods = classs.getDeclaredMethods(); 
List list = new ArrayList(); 
while (rs.next()) { 
T o = (T) classs.newInstance(); 
ext(rs, fields, methods, o); 
list.add(o); 
} 
queryResult.setRows(list); 
ps = con.prepareStatement("select count(*) from " 
+ classs.getSimpleName() + wheres); 
setPrames(ps, objects); 
rs = ps.executeQuery(); 
if (rs.next()) { 
queryResult.setTotal(rs.getLong(1)); 
} 
return queryResult; 
} 

private void ext(ResultSet rs, Field[] fields, Method[] methods, T o) 
throws IllegalArgumentException, IllegalAccessException, 
InvocationTargetException, SQLException { 
for (int i = 0; i < fields.length; i++) { 
for (int j = 0; j < methods.length; j++) { 
if (methods[j].getName().equalsIgnoreCase( 
"set" + fields[i].getName())) { 
if (fields[i].getType().getSimpleName().equals("int")) { 
methods[j].invoke(o, rs.getInt(fields[i].getName())); 
} else if (fields[i].getType().getSimpleName().equals( 
"String")) { 
methods[j].invoke(o, rs.getString(fields[i].getName())); 
} else if (fields[i].getType().getSimpleName().equals( 
"float")) { 
methods[j].invoke(o, rs.getFloat(fields[i].getName())); 
} 
} 
} 
} 
} 

private void setPrames(PreparedStatement ps, Object[] objects) 
throws SQLException { 
if (objects != null && objects.length > 0) { 
for (int i = 0; i < objects.length; i++) { 
ps.setObject(i + 1, objects[i]); 
} 
} 
} 

} 
package com.test.util; 

import java.lang.reflect.ParameterizedType; 
import java.lang.reflect.Type; 

@SuppressWarnings("unchecked") 
public class GenerieUtils { 
public static Class getClass(Class class1, int index) { 
Type type = class1.getGenericSuperclass(); 
if (!(type instanceof ParameterizedType)) { 
return Object.class; 
} 
Type[] types = ((ParameterizedType) type).getActualTypeArguments(); 
if (!(type instanceof Class)) { 
return Object.class; 
} 
return (Class) types[index]; 
} 
} 
package com.test.dao; 

import java.util.List; 

public class QueryResult<T> { 
private List<T> rows; 
private long total; 

public List<T> getRows() { 
return rows; 
} 

public void setRows(List<T> rows) { 
this.rows = rows; 
} 

public long getTotal() { 
return total; 
} 

public void setTotal(long total) { 
this.total = total; 
} 

}


没有缩进。。。汗。
8 楼 holly2k 2011-05-30  
已阅。。。
7 楼 Aaronlong31 2011-05-30  
ext(ResultSet rs, Field[] fields, Method[] methods, T o)方法中，你是通过fields判断属性的，其实只要找出所有已“set”开头的方法，调用就行了。
你那个双重循环加上反射，太费劲了。
还有，整个类，一个close方法都没有，Connection / PreparedStatment/ ResultSet用完后都要close的，要放在finally块中。
这个类不是很通用，限制比较多，建议你看看spring的JdbcTemplate。
6 楼 yizhilong28 2011-05-30  
泛型、反射、jdbc，感觉怪怪的。
lz的对象属性全是基本类型？
5 楼 JMS_Exception 2011-05-30  
steafler 写道
建议不要用泛型

Hi 
   steafler
   小弟不解 。求结果
4 楼 steafler 2011-05-30  
建议不要用泛型
3 楼 whaosoft 2011-05-30  
1年的写个这个不错了
2 楼 //ghost 2011-05-29  
这个太乱了，看起来好费劲哦。
1 楼 hehe456as 2011-05-29  
这个代码格式。能把人累死。javaeye有代码排版这个功能的啊，怎么不用
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    PHP_DAO_MYSQL php写的dao看起来还好

    这个压缩包中的文件似乎提供了一个PHP实现的DAO框架，适合初学者学习和理解DAO模式的运用。 `dao.class.php`：这个文件可能包含了DAO的基类或接口，定义了通用的方法，如连接数据库、执行SQL语句、处理结果集等。在...

    DAO设计模式（工厂+代理）

    在这个“DAO设计模式（工厂+代理）”的例子中，我们将探讨如何结合工厂模式和代理模式来实现更灵活、更易于维护的DAO层。 首先，让我们理解DAO的基本概念。DAO是一个接口或抽象类，定义了对数据库进行操作的方法，...

    大家看看我设计的泛型DAO（使用Spring的Anotation和Hibernate）

    在`我设计的泛型DAO.jpg`中，可能展示了这个设计的类图或者代码结构，进一步解释了各个组件如何协作以实现泛型DAO的功能。 总之，这种设计模式充分利用了Spring的注解驱动和Hibernate的ORM能力，降低了代码的复杂性...

    java 基于泛型与反射的通用 DAO

    本文将深入探讨如何结合这两种技术实现一个通用的DAO（Data Access Object）设计模式。 首先，我们来看“泛型”。泛型是Java 5引入的新特性，它允许在类、接口和方法中使用类型参数，从而提高了代码的类型安全性和...

    DAO实训例子

    5. 跟踪业务逻辑代码，看DAO是如何被调用的。 通过这个DAO实训例子，你可以深入理解数据库操作的抽象化和模块化，为今后的项目开发打下坚实的基础。同时，这也能帮助你掌握如何有效地编写测试用例，验证DAO的正确性...

    MFC DAO编程函数一览

    首先，我们来看CDaoWorkspace类，它是工作区的抽象，用于管理多个数据库的连接。工作区可以包含一个或多个数据库，并负责事务处理。一些重要的CDaoWorkspace成员函数包括： 1. `Open()` 和 `Close()`：分别用于打开...

    dao.rar_dao

    4. **GoodsCar.java**：这个类名看起来像是“购物车”的错误拼写，可能代表购物车的功能。它可能不是DAO类，而是用于表示用户购物车的模型类，包含商品ID、数量等字段，并提供添加、删除商品，计算总价等方法。 5. ...

    泛型dao

    泛型DAO则进一步增强了这种模式，通过泛型参数化，使得一个DAO类可以服务于多种类型的实体对象，减少了代码重复，提高了效率。 首先，我们需要理解什么是泛型。Java泛型是Java SE 5.0引入的新特性，它允许在定义类...

    自己封装的DAO

    自己封装的dao层，自我感觉很牛逼。可以下下来看看，提点优化建议

    java复习题，jdbc，DAO模式，oracle复习题

    DAO（Data Access Object）模式是一种设计模式，常用于在应用程序和数据库之间提供一个抽象层，以实现数据访问的独立性。Oracle则是一款强大的关系型数据库管理系统，广泛应用于大型企业的核心系统。 首先，我们来...

    两个通用DAO

    首先，我们来看`BaseDAO.java`，这个文件通常会定义一个抽象基类，它包含了一些通用的数据库操作方法，如增删查改（CRUD）的基本接口或模板方法。例如： 1. `insert(T entity)`: 用于插入一个新的实体对象到数据库...

    ado_dao_odbc.rar_dao_dao ado odbc_dao odbc_odbc _radataba

    描述中的“几个老外写ado,dao,odbc实例，可以看看他们与我们的差距”表明这些代码是由非中国开发者编写的，可能是为了比较不同数据库访问技术的应用技巧和实现方式，或者是作为学习和参考的资源，帮助我们理解如何用...

    applicationContext-dao.xml配置

    在`applicationContext-dao.xml`中，我们需要配置一个数据源，这通常是JDBC的数据源，例如使用Apache的DBCP或Tomcat的内置数据源。数据源定义了连接数据库所需的参数，如URL、用户名、密码等。以下是一个示例： ```...

    工厂模式很DAO模式实现购物车

    本项目“工厂模式很DAO模式实现购物车”是使用Java语言实现的一个购物车系统，旨在帮助初学者理解并运用这两种设计模式。 首先，我们来看**工厂模式**。工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳...

    JSP留言管理系统Ⅵ(MVC+DAO设计模式)

    在这个系统中，视图负责将模型中的数据渲染成用户可以看懂的格式，如网页布局、样式等。 - **Controller（控制器）**：作为模型和视图之间的桥梁，接收用户的请求，调用模型进行处理，并将结果传递给视图显示。在...

    MVC+DAO_留言管理程序（javaweb）

    整体来看，这个项目是一个实践MVC和DAO设计模式的典型JavaWeb应用，旨在提升代码的可读性、可维护性和可扩展性，同时也展示了如何利用Servlet和MySQL进行数据管理。通过学习和分析这个项目，开发者可以深入了解...

    JSP DAO留言管理代码实例 笔记.rar

    首先，我们来看DAO设计模式的核心思想。DAO模式提供了一个接口，该接口定义了对特定数据源进行操作的方法，比如增删改查。在JSP应用中，DAO作为与数据库交互的中间层，使得JSP页面不再直接处理SQL语句，降低了耦合度...

    解决The type org.springframework.dao.support.DaoSupport cannot be resolved.bao报错

    这个错误通常意味着编译环境无法找到`DaoSupport`类，这是Spring DAO模块中的一个关键类，用于提供数据访问对象（DAO）的基本支持。`DaoSupport`是许多自定义DAO实现的基础，它提供了事务管理和其他便利功能。 首先...

    FireStorm_DAO_Architect_Edition_v3.0.180

    "FireStorm DAO" 是这个软件的主要标识，可能是其品牌名称或者是产品系列的关键特征。这可能是一个专有的数据库开发工具，专注于提供高效、灵活的DAO生成和管理服务，以适应各种数据库系统，如MySQL、Oracle、SQL ...

Magicbox
Global site tag (gtag.js) - Google Analytics