求高手给一思路，在线等

[zjzty888]

一个表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的一个属性，有会出现相互实例化调用的问题。

请大家帮帮我，给个思路，谢谢！

[sing4j]

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

[knightzhuwei]

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

[黎某人]

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

[crazylaa]

本来就是要分开吧，各干各的。

[fyjava1984]

    public void insert(Object obj){
         save(obj)
    }

这样就可以,然后

a_ojb a = new a_obj();
..........
...insert(a);
需要哪个对象就用哪个对象

[meadking]

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

[彤袅]

写一个抽象类和顶层接口如下：
接口代码：

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：[e-mail]

[awusoft]

呵呵.楼上的和我的写的比较像.

[bawgiitx]

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

[awusoft]

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

[zhangjun460]

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

[冰思雨]

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

[zjzty888]

谢谢以上各位，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是可以变的！

[bunrise]

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

[SambaGao]

[Quote=引用 8 楼 zjzty888 的回复:]
谢谢以上各位，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是可以变的！

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