求高手给一思路，在线等

Question

一个表A
用hibernate，生成表的对象类 a_obj，写出操作类a_dao，这里类里面有insert方法。
用户调用的时候会new a_dao() ，然后将a_obj的对象作为参数执行insert。现在表越来越多B、C、D、E、F、G
如果还用以前的方式的话，用户调用就会比较繁琐。我希望可以写一个通用的方法，当对象被传递进来后依不同对象执行不同的dao类中的insert方法。
我想到使用反射，可是对象反射只能得到a_obj的类信息，不能得到a_dao的，如果把a_dao作为a_obj的一个属性，有会出现相互实例化调用的问题。请大家帮帮我，给个思路，谢谢！

Answer 1

使用泛型。
http://blog.csdn.net/azheng270/archive/2008/03/31/2232044.aspx

Answer 2

所有的dao总实现了某一接口吧
初始化的时候用一个数组SuperDao[] daos=[a_dao,b_dao,c_dao,d_dao]
然后调用的时候if(pram isinstanceof a_obj) ados[1].insert(pram)这样？

Answer 3

呵呵  一般数据库中表都是有关系的   Hibernian根据表间关系来生成的类文件里面自然会有 主外键对应的属性

Answer 4

a_dao的public方法全是静态方法static public行不

Answer 5

使用Hibernate的话,你还使用Insert?直接使用save()就OK,我的系统就是使用了只有一个Dao,其它的Service都调用这个类的对象就行了.

Answer 6

使用泛型。 
http://blog.csdn.net/azheng270/archive/2008/03/31/2232044.aspx

Answer 7

谢谢以上各位，http://blog.csdn.net/azheng270/archive/2008/03/31/2232044.aspx的方法不错，但还是没能完全解决我的问题，不知道是不是我理解我不到位
假如A\B\C\D\E\F表
因为在具体的业务调用类需要提前指名对象类型
public class ArticleHibernateDao extends GenericHibernateDao<Article,Long> implements
        IArticleDAO 
这话的话，针对这5各表，就要有5个对应的ArticleHibernateDao ，这样表很多的话岂不是也很繁琐。
是否只写一个ArticleHibernateDao ，依传入的对象类型自动匹配相应的方法，也就是说类型Article是可以变的！

Answer 8

public class Dao<T>{
  private Class<T> clazz;
}
使用泛型就可以了 

Answer 9

    public void insert(Object obj){
         save(obj)
    }
这样就可以,然后a_ojb a = new a_obj();
..........
...insert(a);
需要哪个对象就用哪个对象

Answer 10

泛型接口....
hibernate直接save(Object obj)
你不用管,它自己会处理一切,哈哈

Answer 11

写一个抽象类和顶层接口如下：
接口代码：public interface GenericDAO<T>{
void save(T newInstance);

T read(Serializable id);

void update(T transientObject);

void remove(Serializable id);

T getBy(String propertyName,Object value);

List<T> find(final String queryString,final Object[] params,final int begin,final int max);

List<T> find(final String countString,final String queryString,final Object[] params,PagingInfo pagingInfo); @SuppressWarnings("unchecked")
List query(final String queryString,final Object[] params,final int begin,final int max);

int batchUpdate(String HQL,Object[] params); @SuppressWarnings("unchecked")
List queryNativeSQL(String NSQL);

@SuppressWarnings("unchecked")
List queryNativeSQL(final String NSQL,final Object[] params,final int begin,final int max); public int executeNativeSQL(final String NNQ);

public void flush();
}抽象类代码：@Transactional
public class GenericDAOImpl<T> extends HibernateDaoSupport implements
GenericDAO<T> { private Class<T> clazz; @Autowired
public void setSessionFactoryOne(SessionFactory sessionFactory) {
super.setSessionFactory(sessionFactory);
} public GenericDAOImpl(Class<T> clazz) {
this.clazz = clazz;
} @Override
@Transactional
public T read(Serializable id) {
if (id == null)
return null;
return (T) this.getHibernateTemplate().get(clazz, id);
} public void setClazzType(Class<T> clazz) {
this.clazz = clazz;
} public Class<T> getClazzType() {
return this.clazz;
} @Override
@Transactional
@SuppressWarnings("unchecked")
public int batchUpdate(final String HQL, final Object[] params) {
Object set = this.getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException {
Query query = session.createQuery(HQL);
int parameterIndex = 0;
if (params != null && params.length > 0) {
for (Object object : params) {
query.setParameter(parameterIndex++, object);
}
}
return query.executeUpdate();
}
});
return (Integer) set;
} @Override
@Transactional
@SuppressWarnings("unchecked")
public int executeNativeSQL(final String NNQ) {
Object set = this.getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException {
Query query = session.createSQLQuery(NNQ).addEntity(
clazz);
return query.executeUpdate();
}
});
return (Integer) set;
} @SuppressWarnings("unchecked")
protected Object queryForObject(final String select, final Object[] values) {
HibernateCallback selectCallback = new HibernateCallback() {
public Object doInHibernate(Session session) {
Query query = session.createQuery(select);
if (values != null) {
for (int i = 0; i < values.length; i++)
query.setParameter(i, values[i]);
}
return query.uniqueResult();
}
};
return this.getHibernateTemplate().execute(selectCallback);
} @Override
@Transactional
@SuppressWarnings("unchecked")
public List<T> find(final String queryString, final Object[] params,
final int begin, final int max) {
List<T> set = (List<T>) this.getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException {
String clazzName = clazz.getName();
StringBuffer buffer = new StringBuffer(
" select obj from ");
buffer.append(clazzName).append(" obj").append(
" where ").append(queryString);
Query query = session.createQuery(buffer.toString());
int parameterIndex = 0;
if (params != null && params.length > 0) {
for (Object object : params) {
query.setParameter(parameterIndex++, object);
}
}
if (begin >= 0 && max > 0) {
query.setFirstResult(begin);
query.setMaxResults(max);
}
return query.list();
}
});
if (set != null && set.size() >= 0) {
return set;
} else {
return new ArrayList<T>();
}
} @Override
@Transactional
@SuppressWarnings("unchecked")
public void flush() {
this.getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException {
session.getTransaction().commit();
return null;
}
});
} @Override
@Transactional
@SuppressWarnings("unchecked")
public T getBy(final String propertyName, final Object value) {
if (propertyName == null || "".equals(propertyName) || value == null)
throw new IllegalArgumentException(
"Call parameter is not correct attribute names and values are not empty in getBy");
List<T> set = (List<T>) this.getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException {
String clazzName = clazz.getName();
StringBuffer buffer = new StringBuffer(
" select obj from ");
buffer.append(clazzName).append(" obj");
Query query = null;
if (propertyName != null && value != null) {
buffer.append(" where obj.").append(propertyName)
.append(" = :value ");
query = session.createQuery(buffer.toString())
.setParameter("value", value);
} else {
query = session.createQuery(buffer.toString());
}
return query.list();
}
}); if (set != null && set.size() == 1) {
return set.get(0);
} else if (set != null && set.size() > 1) {
throw new IllegalStateException("More than one object find!");
} else {
return null;
}
}

@Override
@Transactional
public List<T> find(final String countString,final String queryString,final Object[] params,PagingInfo pagingInfo)
{
int begin,max; //首先查询记录数目
Long count = (Long)queryForObject(countString, params);
pagingInfo.setTotalCount(count.intValue());

//查询分页列表
begin=(pagingInfo.getPageIndex()-1)*pagingInfo.getPageSize();
max=pagingInfo.getPageSize();

return find(queryString,params,begin,max);
} @Override
@Transactional
@SuppressWarnings("unchecked")
public List query(final String queryString, final Object[] params,
final int begin, final int max) {
List set = (List) this.getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException {
Query query = session.createQuery(queryString);
int parameterIndex = 0;
if (params != null && params.length > 0) {
for (Object object : params) {
query.setParameter(parameterIndex++, object);
}
}
if (begin >= 0 && max > 0) {
query.setFirstResult(begin);
query.setMaxResults(max);
}
return query.list();
}
});
if (set != null && set.size() >= 0) {
return set;
} else {
return new ArrayList();
}
} @Override
@Transactional
@SuppressWarnings("unchecked")
public List queryNativeSQL(final String NSQL, final Object[] params,
final int begin, final int max) {
List set = (List) this.getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException {
Query query = session.createSQLQuery(NSQL).addEntity(
clazz);
int parameterIndex = 0;
if (params != null && params.length > 0) {
for (Object object : params) {
query.setParameter(parameterIndex++, object);
}
}
if (begin >= 0 && max > 0) {
query.setFirstResult(begin);
query.setMaxResults(max);
}
return query.list();
}
});
if (set != null && set.size() >= 0) {
return set;
} else {
return new ArrayList();
}
} @Override
@Transactional
@SuppressWarnings("unchecked")
public List queryNativeSQL(final String NSQL) { Object set = this.getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException {
Query query = session.createSQLQuery(NSQL).addEntity(
clazz);
return query.list();
}
});
return (List) set; } @Override
@Transactional
public void remove(Serializable id) throws GenericException {
if (id == null)
throw new IllegalArgumentException(
"ID value can not be empty in removing...");
T object = this.read(id);
if (object != null) {
try {
this.getHibernateTemplate().delete(object);
} catch (Exception e) {
throw new GenericException();
}
}
} @Override
@Transactional
public void save(T newInstance) {
this.getHibernateTemplate().save(newInstance);
} @Override
@Transactional
public void update(T transientObject) {
this.getHibernateTemplate().merge(transientObject);
}}实现接口代码：public interface UserDao extends GenericDAO<UserInfo>{}实现类代码：@Repository(BeanNames.BEAN_DAO_USER)
@Scope("prototype")
public class UserDaoImpl extends GenericDAOImpl<UserInfo> implements UserDao{
public UserDaoImpl(){
super(UserInfo.class);
}
}其中GenericDAO<UserInfo>里面的内容就是Model的类，就UserInfo就是定义的Model，注：这段代码里面使用了Spring框架，如果不使用的话直接去掉相关注释Annotation以及Spring里面创建Hibernate的Session的方法替换成纯的Hibernate的就可以了。这只是一种解决方案，不是最优方案，但是使用这个方法就进行了Hibernate里面基本方法的封装，使得UserDaoImpl只能插入和返回UserInfo等操作，楼主可以多看看，如果有什么问题来Email我们讨论，谢谢！Email：[email protected]

Answer 12

楼主可以在全局的作用域中创建一个Map作为缓存。
里面存放<A_obj.class,A_dao>类似的内容，
也就是说，存放的是Key是对象的类对象（而不是对象本身）；
Value是对象对应的DAO对象（而不是类对象）。
然后，程序初始化的时候，将Map的内容填满，
使用的时候，只要使用Map的get方法，即可获得相应的DAO对象。

Answer 13

能重构的就重构在一起。
Article 还可以写成多态。子类有各种各样的类型。再想想。