S.H.E.D. 0.9b 发布

用这个架构怎么做grid 的分页显示啊？

虽然没有看到演示，不过还是很支持楼主，呵呵

本框架扩展了Ext的Grid组件
使用Dwr实现了分页和不分页的Grid
具体的代码可以参见用户管理模块

我刚学extjs不久，对ext的继承功能很是佩服。对于这个dwr处理ext分页效果不是很明白，我想问下能不能从前台向底层传一个hql语句来得到查询结果呢？

本框架封装了单个对象的分页方法
只需要建好了Domain和Dao对象
默认的该对象就支持了分页方法
然后在Service层中按业务逻辑实现
就可以在Dwr层中使用了
分页的Dwr方法支持5个参数
依次是filterMap, likeMap, sortMap, pageNo, pageSize
含义是精确条件集、模糊条件集、排序条件集、当前页、每页记录数
其中前三个条件可以在前台页面中通过脚本设置
后两个条件由Grid组件自动处理

作为一个分层次的系统架构
不建议通过前台传递任何SQL

还是贴点代码吧
以下代码演示了用户管理模块

首先定义用户表的实体类：

package com.shed.demo.domain;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "users")
public class User implements Serializable {
	private static final long serialVersionUID = 1287059586503064731L;

	private Long userID;
	private String userName;
	private String userDesc;
	private String userPwd;
	private Integer userState;

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "userID")
	public Long getUserID() {
		return userID;
	}

	public void setUserID(Long userID) {
		this.userID = userID;
	}

	@Column(name = "userName")
	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	@Column(name = "userDesc")
	public String getUserDesc() {
		return userDesc;
	}

	public void setUserDesc(String userDesc) {
		this.userDesc = userDesc;
	}

	@Column(name = "userPwd")
	public String getUserPwd() {
		return userPwd;
	}

	public void setUserPwd(String userPwd) {
		this.userPwd = userPwd;
	}

	@Column(name = "userState")
	public Integer getUserState() {
		return userState;
	}

	public void setUserState(Integer userState) {
		this.userState = userState;
	}
}

再来定义Dao类：
由于框架已经对Dao进行了封装
所以只需要定义一个继承自 com.shed.base.orm.hibernate.EntityHibernateDao 的类就行了
所有继承的类都有了create、save、update、find及pagedQuery等方法
当然
如果业务有其他更复杂的需要
也可以定义到此类中

package com.shed.demo.dao;

import com.shed.base.orm.hibernate.EntityHibernateDao;
import com.shed.demo.domain.User;

public class UserDao extends EntityHibernateDao<User> {

}

再下来就是Service类了：

package com.shed.demo.service;

import java.util.List;
import java.util.Map;

import com.shed.base.domain.Page;
import com.shed.demo.domain.User;

public interface UserService {
	/**
	 * 用户登录方法
	 * 
	 * @param userName
	 * @param userPwd
	 * @param loginIP
	 * @return
	 */
	public Map<String, Object> doLogin(String userName, String userPwd, String logIP);

	/**
	 * 根据用户ID取用户
	 * 
	 * @param userId
	 * @return
	 */
	public User getUserByUserId(Long userId);

	/**
	 * 根据用户名取用户
	 * 
	 * @param userName
	 * @return
	 */
	public User getUserByUserName(String userName);

	/**
	 * 根据条件取用户列表
	 * 
	 * @param filter
	 * @return
	 */
	public List<User> findUser(Map<String, String> filter);

	/**
	 * 根据条件取用户分页列表
	 * 
	 * @param filterMap
	 * @param likeMap
	 * @param sortMap
	 * @param pageNo
	 * @param pageSize
	 * @return
	 */
	public Page pageUser(Map<String, String> filterMap, Map<String, String> likeMap, Map<String, String> sortMap,
			int pageNo, int pageSize);

	/**
	 * 创建用户
	 * 
	 * @param user
	 */
	public void createUser(User user);

	/**
	 * 删除用户
	 * 
	 * @param userId
	 */
	public void deleteUser(Long userId);

	/**
	 * 修改用户
	 * 
	 * @param user
	 */
	public void updateUser(User user);

	/**
	 * 修改用户密码
	 * 
	 * @param userId
	 * @param userPwd
	 */
	public void updateUserPwd(Long userId, String userPwd);
}

Service的实现：

package com.shed.demo.service.impl;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.shed.base.domain.Page;
import com.shed.base.utils.Md5PasswordEncoder;
import com.shed.demo.dao.LoginLogDao;
import com.shed.demo.dao.UserDao;
import com.shed.demo.domain.LoginLog;
import com.shed.demo.domain.User;
import com.shed.demo.service.UserService;

public class UserServiceImpl implements UserService {
	private UserDao userDao;
	private LoginLogDao loginLogDao;

	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

	public void setLoginLogDao(LoginLogDao loginLogDao) {
		this.loginLogDao = loginLogDao;
	}

	public void createUser(User user) {
		user.setUserPwd(Md5PasswordEncoder.encodePassword(user.getUserPwd(), null));
		userDao.create(user);
	}

	public void deleteUser(Long userId) {
		userDao.remove(getUserByUserId(userId));
	}

	public List<User> findUser(Map<String, String> filter) {
		return userDao.find(filter);
	}

	public User getUserByUserId(Long userId) {
		return userDao.get(userId);
	}

	public Page pageUser(Map<String, String> filterMap, Map<String, String> likeMap, Map<String, String> sortMap,
			int pageNo, int pageSize) {
		return userDao.pagedQuery(filterMap, likeMap, sortMap, pageNo, pageSize);
	}

	public void updateUser(User user) {
		userDao.update(user);
	}

	public User getUserByUserName(String userName) {
		Map<String, String> filter = new HashMap<String, String>();
		filter.put("userName", userName);
		List<User> list = findUser(filter);
		return list.size() > 0 ? list.get(0) : new User();
	}

	public void updateUserPwd(Long userId, String userPwd) {
		User user = getUserByUserId(userId);
		user.setUserPwd(Md5PasswordEncoder.encodePassword(userPwd, null));
		updateUser(user);
	}

	public Map<String, Object> doLogin(String userName, String userPwd, String logIP) {
		Map<String, String> filter = new HashMap<String, String>();
		filter.put("userName", userName);
		filter.put("userPwd", userPwd);
		List<User> list = userDao.find(filter);
		Map<String, Object> result = new HashMap<String, Object>();
		if (list.size() > 0) {
			User user = list.get(0);
			switch (user.getUserState()) {
			case 1:
				result.put("flag", true);
				result.put("user", user);
				LoginLog loginLog = new LoginLog();
				loginLog.setLogIP(logIP);
				loginLog.setLogTime(new Date());
				loginLog.setUserName(user.getUserName());
				loginLog.setUserID(user.getUserID());
				loginLogDao.create(loginLog);
				break;
			default:
				result.put("flag", false);
				result.put("msg", "无效的用户！");
				break;
			}
		} else {
			result.put("flag", false);
			result.put("msg", "输入的工号或密码有误！");
		}
		return result;
	}
}

相应的Dwr类：
这是演示版的代码
所有对数据库的写操作都被屏掉了

package com.shed.demo.dwr;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.shed.base.domain.Page;
import com.shed.base.utils.Md5PasswordEncoder;
import com.shed.demo.domain.User;
import com.shed.demo.service.UserService;

public class SmDwr extends BaseDwr {
	private static final long serialVersionUID = 6912861534323592006L;

	private UserService userService;

	public void logoff() {
		DwrAuthHelper.removeUser();
	}

	public Map<String, Object> login(String userName, String userPwd) {
		Map<String, Object> result = userService.doLogin(userName, Md5PasswordEncoder.encodePassword(userPwd, null),
				getIpAddress());
		if (Boolean.valueOf(result.get("flag").toString())) {
			DwrAuthHelper.setUser(result.get("user"));
		}
		return result;
	}

	public void setUserService(UserService userService) {
		this.userService = userService;
	}

	public User getCurrentUser() {
		try {
			return super.getCurrentUser();
		} catch (Exception e) {
			return new User();
		}
	}

	/**
	 * 根据用户ID取用户
	 * 
	 * @param userId
	 * @return
	 */
	public User getUserByUserId(Long userId) {
		return userService.getUserByUserId(userId);
	}

	/**
	 * 根据用户名取用户
	 * 
	 * @param userName
	 * @return
	 */
	public User getUserByUserName(String userName) {
		return userService.getUserByUserName(userName);
	}

	/**
	 * 根据条件取用户列表
	 * 
	 * @param filter
	 * @return
	 */
	public List<User> findUser(Map<String, String> filter) {
		return userService.findUser(filter);
	}

	/**
	 * 根据条件取用户分页列表
	 * 
	 * @param filterMap
	 * @param likeMap
	 * @param sortMap
	 * @param pageNo
	 * @param pageSize
	 * @return
	 */
	public Page pageUser(Map<String, String> filterMap, Map<String, String> likeMap, Map<String, String> sortMap,
			int pageNo, int pageSize) {
		return userService.pageUser(filterMap, likeMap, sortMap, pageNo, pageSize);
	}

	/**
	 * 创建用户
	 * 
	 * @param user
	 */
	public void createUser(User user) {
		// userService.createUser(user);
	}

	/**
	 * 删除用户
	 * 
	 * @param userId
	 */
	public void deleteUser(Long userId) {
		// userService.deleteUser(userId);
	}

	/**
	 * 修改用户
	 * 
	 * @param user
	 */
	public void updateUser(User user) {
		// userService.updateUser(user);
	}

	/**
	 * 修改用户密码
	 * 
	 * @param userId
	 * @param userPwd
	 * @param preUserPwd
	 * @return
	 */
	public Map<String, String> updateUserPwd(Long userId, String userPwd, String preUserPwd) {
		Map<String, String> result = new HashMap<String, String>();
		User user = getUserByUserId(userId);
		if (user.getUserPwd().equals(Md5PasswordEncoder.encodePassword(preUserPwd, null))) {
			// userService.updateUserPwd(userId, userPwd);
			result.put("flag", "true");
		} else {
			result.put("flag", "false");
			result.put("msg", "输入的当前密码不正确！");
		}

		return result;
	}
}

以上就是所有的JAVA类了
下面是相关的配置xml了

Hibernate 配置文件
hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
		"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <mapping class="com.shed.demo.domain.Menu" />
        <mapping class="com.shed.demo.domain.LoginLog" />
        <!-- 新增内容 -->
        <mapping class="com.shed.demo.domain.User" />
    </session-factory>
</hibernate-configuration>

Spring Dao 类配置文件
spring-dao.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean class="com.shed.demo.dao.MenuDao" id="menuDao">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <bean class="com.shed.demo.dao.LoginLogDao" id="loginLogDao">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <!-- 新增内容 -->
    <bean class="com.shed.demo.dao.UserDao" id="userDao">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
</beans>

Spring Service 类配置文件
spring-service.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean id="menuService" class="com.shed.demo.service.impl.MenuServiceImpl">
        <property name="menuDao" ref="menuDao"></property>
    </bean>

    <!-- 新增内容 -->
    <bean id="userService" class="com.shed.demo.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
        <property name="loginLogDao" ref="loginLogDao"></property>
    </bean>
</beans>

Spring Dwr 类配置文件
spring-dwr.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:dwr="http://www.directwebremoting.org/schema/spring-dwr"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd 
	http://www.directwebremoting.org/schema/spring-dwr http://www.directwebremoting.org/schema/spring-dwr-2.0.xsd">

    <!-- 新增内容 -->
    <bean id="smDwr" class="com.shed.demo.dwr.SmDwr">
        <property name="menuService" ref="menuService" />
        <property name="userService" ref="userService" />
        <dwr:remote javascript="smDwr"></dwr:remote>
    </bean>

    <dwr:configuration>
        <dwr:convert type="bean" class="$Proxy*"></dwr:convert>
        <dwr:convert type="exception" class="java.lang.Exception"></dwr:convert>
        <dwr:convert type="exception" class="java.lang.RuntimeException"></dwr:convert>
        <dwr:convert type="exception" class="java.lang.NullPointerException"></dwr:convert>
        <dwr:convert type="bean" class="java.lang.StackTraceElement"></dwr:convert>
        <dwr:convert type="bean" class="com.shed.base.domain.KeyLabel"></dwr:convert>
        <dwr:convert type="bean" class="com.shed.base.domain.Page"></dwr:convert>
        <dwr:convert type="hibernate3" class="com.shed.demo.domain.*"></dwr:convert>
    </dwr:configuration>
</beans>

userMan.js

Ext.extend(SHED.module, {
    init: function() {
        // 定义用户资料窗口
        var userWin = new SHED.Window({
            id: 'userWin',
            title: '用户资料',
            height: 200,
            items: new SHED.form.DWRForm({// 定义用户资料 DWRForm
                afterSubmit: function() {// 窗口操作完成后执行的方法
                    grid.reload();
                },
                labelWidth: 85,
                dwr: {// 定义所需的 DWR 方法
                    load: smDwr.getUserByUserId,// 加载用户资料的方法 
                    save: smDwr.createUser,// 创建用户的方法
                    update: smDwr.updateUser// 更新用户资料的方法
                },
                items: [{// 定义 DWRForm 中的字段
                    fieldLabel: '用户ID',
                    name: 'userID',
                    xtype: 'hidden'
                }, {
                    fieldLabel: '用户密码',
                    name: 'userPwd',
                    value: '000000',
                    xtype: 'hidden'
                }, {
                    fieldLabel: '用户名称',
                    name: 'userName',
                    allowBlank: false,
                    validator: function(v) {
                        return (/[\W]/).test(v) ? "用户名只能由英文字母、数字和下划线组成！" : true;
                    }
                }, {
                    store: [[1, '有效'], [0, '无效']],
                    triggerAction: 'all',
                    mode: 'local',
                    editable: false,
                    fieldLabel: '状　　态',
                    hiddenName: 'userState',
                    value: 1,
                    xtype: 'combo'
                }, {
                    fieldLabel: '用户说明',
                    name: 'userDesc',
                    xtype: 'textarea'
                }]
            })
        });
        
        // 定义添加用户按钮
        var addBtn = new Ext.Toolbar.Button({
            text: '添加用户',
            iconCls: 'btn_insert',
            handler: function(o, e) {
                // 调用的 Window 的 show 方法，DWRForm 提交时将调用添加方法
                userWin.show();
            }
        });
        
        // 定义修改用户按钮
        var editBtn = new Ext.Toolbar.Button({
            text: '修改用户',
            iconCls: 'btn_modify',
            handler: function(o, e) {
                var record = grid.getSelectedRow();
                if (record) {
                    // 调用的 Windows 的 load 方法，DWRForm 提交时将调用更新方法
                    userWin.load(record.userID);
                } else {
                    SHED.msg('请选择要修改的用户！');
                }
            }
        });
        
        // 定义用户资料分页 Grid
        var grid = new SHED.grid.PageGrid({
            id: 'userGrid',
            initload: true,
            firstColumn: 'radio',// 定义首列渲染类型，可用值：undefined（无），radio（单选），checkbox（多选），number（数字），其中除 checkbox 可以同时选择多条记录外，其他值时均只能选择单条记录
            tbar: ['-', addBtn, editBtn],// 定义顶部工具栏包含对象
              // bbar: true,// 定义底部工具栏包含对象，默认为分页工具栏
            filter: {},
            listeners: {
                'rowdblclick': editBtn.handler// 绑定行双击事件，双击记录时调用修改用户资料按钮方法
            },
            dwr: {
                call: smDwr.pageUser// Grid 读取数据时调用的分页方法
            },
            metas: [{// 定义 Grid 每列显示内容
                id: 'userID',
                field: 'userID',
                type: 'int',
                hidden: true
            }, {
                field: 'userName',
                desc: '用户名'
            }, {
                field: 'userDesc',
                desc: '用户说明'
            }, {
                field: 'userState',
                desc: '状　　态',
                renderer: function(val) {
                    return val == 1 ? '有效' : '无效';
                }
            }]
        });
        
        // 注册关联销毁对象，除模块主对象和主对象工具栏包含对象之外的所有组件，必须在此处进行注册，否则在模块被关闭时会造成内存泄漏
        this.main.associatedComp = [userWin];
        // 定义本模块主对象为 grid
        this.main.add(grid);
        // 模块初始化方法
        this.main.doLayout();
    }
});

辛苦了，楼主同学。上面这些代码基本都看过了，其实我只是不明白为啥非得将数据库读写操作封装的这么死，hibernate对数据库的映射就已经够完美了，为啥还要用dwr再实现一遍读写操作？它真的能适应一些复杂的查询如：嵌套查询么？，为啥不能dwr只是处理对象映射而把数据库读写操作交给一条灵活的sql语句呢？
  本人比较异想天开，不知道说的对不对。

请问楼主怎么把项目 放到googlecode里的呀~