为什么这样设计Dao？

[LoginOut]

public interface BaseDAO {

    public void save(Object obj);	
    public void update(Object obj);
    public void saveOrUpdate(Object obj);
	public void delete(Object obj) ;
	public void executeHQL(String hql,Object obj);
	public Object findById(Class clazz,Integer id);
	
	/**
	 * 
	 * @param shortClassName    entity bean的类名，省去包名   
	 * @param id
	 * @return
	 */
		
	public Object findById(String shortClassName,Integer id);
	public List findAll(String shortClassName);
	public List findByParam(String hql,Object obj);
	public int calculateAmount(final Class clazz,final Map conditions);
	
	/**
	 * 该方法应用于查询分页
	 * 
	 * @param clazz       待查询的类
	 * @param conditions  条件组合
	 * @param orderType   排序方式
	 * @param orderField  按哪个属性进行排序
	 * @param start       开始位置    
	 * @param pageSize    返回的页大小
	 * @return
	 */
	public List filter(final Class clazz,final Map conditions, final String orderType,final String orderField,final int start,final int pageSize);
   
}

  public interface UserDAO extends BaseDAO{
	
	
	public static final String FIND_USER_BY_LOGIN_NAME = " from User u where u.loginName=?";
	
	public static final String DEL_USER_BY_ID = " delete from User u where u.id=?";
	
	public void addUser(User user) ;
	
	
	public void updateUser(User user) ;
	
	
	public void delUser(User user) ;
	
	
	public void delUserById(final int userid);
	
	
	public User findUserById(int id);
	
	
	public User findUserByLoginName(String loginName);

}

public class UserDAOHibernate  extends BaseDAOHibernate implements UserDAO{
	
	public void addUser(User user) {
		save(user);
	}
	
	public void updateUser(User user) {
		update(user);
	}
	
	public void delUser(User user) {
		delete(user);
	}
	
	public void delUserById(final int userid){
		
		getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session s) throws HibernateException, SQLException {
				Query query = s.createQuery(DEL_USER_BY_ID);
				query.setInteger(0, userid);
				query.executeUpdate();
				return null;
			}
		});
	}
	
	public User findUserById(int id){
		return (User)findById("User",id);
	}
	
	
	public User findUserByLoginName(String loginName){
		List list = this.getHibernateTemplate().find(FIND_USER_BY_LOGIN_NAME, loginName);
		if (list.size()>0) 
			return (User)list.get(0);
		return null;
	}	

}

BaseDAO 有什么用处？
不用BaseDAO 好像也可以啊

[ly13268929]

主要是为了将来好用，实现松藕合

[asdfa23rdadsdfa]

[Quote=引用 2 楼 wn_1985 的回复:]
面向接口编程，目的是解耦合
但也不一定必须这样做，我自己设计的dao就没用接口，因为要用泛型，省很多代码，
比如你上边的UserDAOHibernate.XXXDaoHebernate等等
总之，也没有必须这一说，看你们实际风格了
[/Quote]

顶

[liuc0317]

看了下顺便说说。不对请后面指正。
首先对于 JAVA语言来说 提倡多继承！
上边写的DAO接口！我认为不怎么好使！
这样写是不是更好!
public interface GenericDAO<T, ID extends Serializable> {
void create(T entity);

void delete(T entiry);

void upate(T entiry);

T findByID(ID id);

List<T> findAll();

List<T> findList(int pageNo, int pageSize);

int getTotle();
}

[qq774097676]

面向接口编程 一定程度上可以解耦合 baseDao中的方法是通用的方法 其他的dao可以继承实现自身的方法
不过个人觉得也没有什么必要这样做吧 感觉java里很多的时候是为了实现面向接口编程而去编写接口 其实在一般的项目里也体现不出什么优势来

[logqq]

怎么设计是自己的风格而已。。。。。。

当然了怎么适合自己就怎么搞，项目搞出来就行了

[blliy117]

就是为了多点代码重用吧！没有别的

[MaWenWu281107072139]

[Quote=引用 4 楼 closewbq 的回复:]
面向接口编程只是种思想。
接口，就相当于对接的端口，模块与模块之间约定建立的交通路线。自然就耦合低了！
[/Quote]

之所以 这样子做是为了方便程序维护,升级,扩展. 也就是面向接口编程的好处.

[97095639]

面向对象的思想去 恶补吧

[dinghun8leech]

我也差不多，一个基础的，衍生几个特殊的出来，就能满足十几、几十种pojo的操作。不过这样还是有些缺陷，衍生类只能继承一次，不能同时再继承别的东西了。

[LoginOut]

Struts+Hibernate+Dao做的一个登陆，欢迎大家帮我指出其中的不足

com.telezone.dao

public interface IBaseHibernateDAO {
	public Session getSession();
}

public class BaseHibernateDAO implements IBaseHibernateDAO {

	public Session getSession() {
		return HibernateSessionFactory.getSession();
	}

}

public interface UserinfoDAO {

	public void saveUser(Userinfo user);

	public void updateUserinfo(Userinfo user);

	public void deleteUserinfoById(String userid);

	public Userinfo findUserinfoById(String uid);

	public List userinfoList(String hql, Object[] obj);
}

com.telezone.daoImpl

public class UserinfoDAOImpl extends BaseHibernateDAO implements UserinfoDAO {
     
       //省略crud
	public List userinfoList(String hql, Object[] obj) {
		List userinfoList;
		try {
			userinfoList = getSession().createQuery(hql)
					.setParameter(0, obj[0]).setParameter(1, obj[1])
					.setParameter(2, obj[2]).list();
		} catch (RuntimeException re) {
			log.error("UserinfoDAOImpl userinfoSize failed", re);
			throw re;
		}
		return userinfoList;
	}
}

com.telezone.services

public interface UserinfoServices {

	public Userinfo isLogin(String userid, String password, Byte usertype);

	public boolean updatePassword(String oldPw, String newPw);

}

com.telezone.servicesImpl

 public class UserinfoServicesImpl implements UserinfoServices {

	private static final Log log = LogFactory
			.getLog(UserinfoServicesImpl.class);

	public Userinfo isLogin(String userid, String password, Byte usertype) {
		UserinfoDAO userDao = new UserinfoDAOImpl();
		StringBuffer sb = new StringBuffer();
		Object[] obj = new Object[3];
		try {
			sb
					.append("from Userinfo uinfo where uinfo.userid = ? and uinfo.userpw = dbo.md5(?) and uinfo.usertype = ? ");
			obj[0] = userid;
			obj[1] = password;
			obj[2] = usertype;
			List userinfoList = userDao.userinfoList(sb.toString(), obj);
			if (userinfoList.size() > 0)
				return (Userinfo) userinfoList.get(0);
		} catch (Exception e) {
			log.error("UserinfoServicesImpl isLogin failed", e);
		}
		return null;
	}

	public boolean updatePassword(String oldPw, String newPw) {
		// TODO Auto-generated method stub
		return false;
	}

}

测试


public class UserinfoServicesImplTest extends TestCase {

UserinfoServices userinfoSer = null;

protected void setUp() throws Exception {
userinfoSer = new UserinfoServicesImpl();
}

public void testIsLogin() {
String uid = "sys";
String pw = "123";
Byte utype = 1;
Userinfo userinfo = userinfoSer.isLogin(uid, pw, utype);
if(null == userinfo){
System.out.println("登录失败");
}else{
System.out.println("登录成功");
}
}
}



31：
我也差不多，一个基础的，衍生几个特殊的出来，就能满足十几、几十种pojo的操作。不过这样还是有些缺陷，衍生类只能继承一次，不能同时再继承别的东西了。

体会不出来，我再想想看

[sxjkk]

lou建议楼主看看软件工程就晓得怎么回事了
推荐《Java与模式》，写的很不错

[BearKin]

实际上很久很久很久很久以前就有人说过了

行为规范用接口 通用功能用抽象 实际上这个抽象不一定非得是抽象 因为用抽象的重点 是可以继承 而继承的类也不一定是抽象类

所以 行为规范用实现 通用功能用继承

你这个模式是这样的

BaseDAO 接口

UserDAO 接口(继承了BaseDAO接口)

UserDAOHibernate 实现类 实现了UserDAO接口 同时继承了BaseDAO接口的实现类BaseDAOHibernate

首先BaseDAO接口定义了很多未实现的方法 这些方法是通用方法 也就是每个DAO都可能需要用到的方法

这个接口规范的是BaseDAOHibernate 他规范了所有通用功能类的方法

这时候 UserDAO 继承了BaseDAO接口 看清楚 是继承 该接口并不需要关心究竟谁来实现那些BaseDAO里未被实现的方法 只是作为通用功能将这些未实现的方法一并继承了

然后UserDAOHibernate 实现了UserDAO接口 并且继承了BaseDAOHibernate 通过他来实现由UserDAO接口继承下来的通用的 未实现的方法 然后并在UserDAOHibernate实现UserDAO未实现的方法


通用功能的好处是 同样的功能不用重复的去写代码 所以BaseDAO实际上指的是继承 只不过继承这个通用功能可以随时改变他的实现而已 而每个业务都可能有他自己才有的业务 所以说 才需要再加个接口(UserDAO)
而BaseDAO接口就像是一个被隐藏起来的接口 不存在了

[wn_1985]

[Quote=引用 11 楼 loginout 的回复:]
引用 6 楼 wn_1985 的回复:
引用 5 楼 loginout 的回复:
引用 4 楼 closewbq 的回复:
面向接口编程只是种思想。
接口，就相当于对接的端口，模块与模块之间约定建立的交通路线。自然就耦合低了！

UserDAO extends BaseDAO
这里有必要吗？
UserDAO  也没有用 BaseDAO 里面的方法啊？

看来lz比较对我的路子，可以参考我的风格
象我这种懒人就1个BaseDaoHibernate+泛型，项目中能省的代码非常非常多
也有严格按照分层设计的，就如LZ贴出的一样
还是那句话：没有什么是绝对的，没有必须那么作一说。

Hibernate+Spring ?
[/Quote]
嗯

[礼拜六]

AOP

[「已注销」]

面向接口的编程 减少耦合

[liguominz]

面向接口编程，最大的作用就是接耦，
便于代码维护和扩展。

[goodlucktomyself]

提高代码的重用性，同时也使分工明确：哪些是数据层，哪些是业务逻辑层...

[suwanjun881011]

一看lz 就没有开发过真正的项目……

[MAXMANMAX]

重复使用吧

[zhanlang9075]

遵循MVC设计模式的BaseDao为给你的面向OO编程带来无穷的乐趣！