在本教程中，我们将手把手的演示如何使用guzz，编写一个可以并行使用5台甚至更多数据库的留言板系统。
您可以一边看一边跟着做。在实际的教程做，只需要1台数据库用来模拟。
本教程将教会你：如何创建guzz项目，如何用guzz添加数据库记录，如何实现读写分离，如何进行多数据库之间分表、切表、分布式切表等，并对“服务”有个概念。
什么是guzz？什么时候用？
guzz[?ɡuzi]念做谷子。稻谷的谷，意为种子、谷物等。
guzz和hibernate，ibatis同属于数据持久层框架，在应用架构上用于代替hibernate或者ibatis。使用guzz后，传统的ssh（spring + struts + hibernate）程序就变成了ssg（spring + struts + guzz）。同时guzz也可以和hibernate/ibatis并存，同时使用。
guzz适合于大型系统使用，包括访问量较大的系统和数据量较大的系统。当你的程序需要同时使用多台数据库，或者存在大表需要分切成小表时，guzz是目前通用持久层框架中最好的选择。guzz提供了面向未来的配置化分表、多库、表分切、读写分离，以及多台数据库之间透明的分布式事务支持等特性，使得多数据库编程和普通编程一样简单，对开发者透明。
同时guzz提供一些服务定义，帮助团队从零开始创建云服务计算平台。如果您计划将多个系统间的通用计算（功能）做成服务，并且还没有动手，guzz service将是个很好的起步点。
guzz框架免费开源，项目地址：http://code.google.com/p/guzz/
准备开发环境
在本教程中，我们使用MyEclipse IDE做开发演示。留言板将运行在1台Mysql5.0 + 1台Tomcat6上。因此您只需要自己的开发机器就可以跟上。
当然，如果你有5台或者更多数据库，会更好。
虽然教程中只有1台数据库，但效果一样。你可以更清楚的看到，guzz使用多台数据库还是只用1台数据库，对开发者基本透明。
创建MessageBoard工程
我们基于 springIOC + springMVC + guzz 架构创建留言板，因此先从guzz网站下载提供的空工程 a empty sample project buildxxxxxxx.zip ：http://code.google.com/p/guzz/downloads/list
解压工程，并导入到Eclipse中（File -> Import -> General/Existing Projects into Workspace）。 这时工作区中多了一个名为“GuzzEmpty”的项目。选择项目，右键 -> Refactor -> Rename。输入MessageBoard，确定。
从 http://code.google.com/p/guzz/downloads/list 下载最新版的guzz发布包，如“guzz1.2.9 buildxxxxxx.zip”，解压文件，将最新的guzz.jar覆盖到刚刚创建的MessageBoard工程的 /WebRoot/WEB-INF/lib/ 下。
修改 /WebRoot/WEB-INF/ 下的 fms.properties 为 messageBoard.properties ，这个为我们的主配置文件。
配置工程，插入第1条留言
配置工程
我们定义留言为Message，在src源代码目录下创建域对象example/business/Message.java：
1 package example.business;
2
3 import java.util.Date;
4
5 public class Message implements java.io.Serializable {
6
7 private int id ;
8
9 private String content ;
10
11 private Date createdTime ;
12
13 public int getId() {
14 return id;
15 }
16
17 public void setId(int id) {
18 this.id = id;
19 }
20
21 public String getContent() {
22 return content;
23 }
24
25 public void setContent(String content) {
26 this.content = content;
27 }
28
29 public Date getCreatedTime() {
30 return createdTime;
31 }
32
33 public void setCreatedTime(Date createdTime) {
34 this.createdTime = createdTime;
35 }
36
37 }
同时在 example/business/ 目录下创建域对象的映射文件 Message.hbm.xml：
1 <?xml version="1.0"?> 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 4 <hibernate-mapping> 5 <class name="example.business.Message" table="tb_message"> 6 <id name="id" type="int" column="id"> 7 <generator class="native" /> 8 </id> 9 <property name="content" type="string" column="content" /> 10 <property name="createdTime" type="datetime" column="createdTime" /> 11 </class> 12 </hibernate-mapping>
在映射文件中，留言存储在tb_message表中。tb_message用content字段存储留言内容。
启动并连上Mysql5.0，创建测试用数据库mb_main，并在其中创建表tb_message。sql语句如下：
1 create database mb_main default character set utf8 ; 2 3 use mb_main ; 4 5 create table tb_message( 6 id int not null auto_increment primary key, 7 content text, 8 createdTime datetime 9 )engine=Innodb ;
好啦，现在需要配置数据库连接池，让mb_main数据库和MessageBoard工程对接上。
打开 /WebRoot/WEB-INF/guzz.xml 文件，选择源代码模式编辑。右键选择 /WebRoot/WEB-INF/messageBoard.properties -> Open With -> Properties File Editor（注意：不能用高级可视化编辑器打开），打开主配置文件。
修改guzz.xml：删除默认配置的3组数据库组中的updateDB和logDB；删除2个service服务；在business中增加Message域对象声明。修改后的guzz.xml为：
1 <?xml version="1.0" encoding="UTF-8"?> 2 <!DOCTYPE guzz-configs PUBLIC "-//GUZZ//DTD MAIN CONFIG//EN" "http://www.guzz.org/dtd/guzz.dtd"> 3 4 <guzz-configs> 5 6 <dialect class="org.guzz.dialect.Mysql5Dialect" /> 7 8 <tran> 9 <dbgroup name="default" masterDBConfigName="masterDB" /> 10 </tran> 11 12 <config-server> 13 <server class="org.guzz.config.LocalFileConfigServer"> 14 <param name="resource" value="messageBoard.properties" /> 15 </server> 16 </config-server> 17 18 <!-- business starts --> 19 <business dbgroup="default" name="message" file="classpath:example/business/Message.hbm.xml" /> 20 <!-- business ends --> 21 22 </guzz-configs>
在新的guzz.xml中，留言对象使用default数据库组，default数据库组的master数据库的配置组名称为“masterDB”，没有slave数据库。修改刚刚打开的messageBoard.properties，修改masterDB配置组的连接池，指向我们刚才创建的数据库mb_main。其他数据库组配置删除。新的messageBoard.properties内容如下：
1 #guzz app config file. 2 3 #master db 4 [masterDB] 5 guzz.identifer=defaultMasterDB1 6 guzz.IP=localhost 7 guzz.maxLoad=120 8 driverClass=com.mysql.jdbc.Driver 9 jdbcUrl=jdbc:mysql://localhost:3306/mb_main?useUnicode=true&characterEncoding=UTF-8&useServerPrepStmts=true 10 user=root 11 password=root 12 acquireIncrement=10 13 idleConnectionTestPeriod=60 14 15 #debug settings 16 [guzzDebug] 17 #runMode=debug/production 18 runMode=debug 19 #onError=halt/log/ignore 20 onError=halt 21 printSQL=true 22 printSQLParams=true 23 ignoreDemonThreadSQL=true 24 #print out how many nano-seconds a sql takes to execute. 25 measureTime=true 26 #only print out slow sqls that takes over xxx mill-seconds to execute. 0 means print out all. 27 onlySlowSQLInMillSeconds=0 28 29 ############################### fundamental services #####################
打开 /WebRoot/WEB-INF/applicationContext.xml，删除bean:insertQueueService 。
部署工程到Tomcat6上，然后启动。如果没有错误，则配置已经成功。如果报错，请检查数据库是否给予了访问授权等。
停止tomcat6.
插入留言
下面我们开始插入第一条留言。
在/WebRoot/下创建jsp文件：messagesList.jsp，用于显示留言填写表单，内容如下：
1 <%@ page language="java" pageEncoding="UTF-8" errorPage="/WEB-INF/jsp/include/defaultException.jsp"%> 2 <%@include file="/WEB-INF/jsp/include/tags.jsp"%> 3 4 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> 5 <html> 6 <head> 7 <title>Message List</title> 8 </head> 9 10 <body> 11 12 Leave a message:<br> 13 14 <form method="POST" action="./newMessage.do"> 15 <textarea name="content" cols="80" rows="10"></textarea> 16 17 <br/> 18 <input type="submit" /> 19 </form> 20 </body> 21 </html>
创建java文件 example.view.action.NewMessageAction.java 用于处理添加新留言的Form表单提交，内容如下：
1 package example.view.action;
2
3 import javax.servlet.http.HttpServletRequest;
4 import javax.servlet.http.HttpServletResponse;
5
6 import org.guzz.GuzzContext;
7 import org.guzz.transaction.WriteTranSession;
8 import org.springframework.web.servlet.ModelAndView;
9 import org.springframework.web.servlet.mvc.Controller;
10
11 import example.business.Message;
12
13 public class NewMessageAction implements Controller {
14
15 private GuzzContext guzzContext ;
16
17 public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
18 String content = request.getParameter("content") ;
19
20 WriteTranSession write = guzzContext.getTransactionManager().openRWTran(true) ;
21
22 Message msg = new Message() ;
23 msg.setContent(content) ;
24 msg.setCreatedTime(new java.util.Date()) ;
25
26 try{
27 write.insert(msg) ;
28 }finally{
29 write.close() ;
30 }
31
32 return new ModelAndView("redirect:/messageList.jsp");
33 }
34
35 public GuzzContext getGuzzContext() {
36 return guzzContext;
37 }
38
39 public void setGuzzContext(GuzzContext guzzContext) {
40 this.guzzContext = guzzContext;
41 }
42
43 }
修改/WebRoot/WEB-INF/dispatcher-servlet.xml文件，增加NewMessageAction的映射bean：
1 <bean name="/newMessage.do" class="example.view.action.NewMessageAction"> 2 <property name="guzzContext" ref="guzzContext" /> 3 </bean>
部署程序，启动Tomcat6，访问：http://localhost:8080/guzz/messageList.jsp ，输入留言“I am the first message. What about you?”，提交。
打开数据tb_message表，可以看到1条记录已经成功插入。
分页列出发表的留言
我们在messageList.jsp中列出所有发表的留言，每页30条，分页显示。对于数据库简单的读操作，我们使用guzz taglib实现。新的 messageList.jsp 内容如下；
1 <%@ page language="java" pageEncoding="UTF-8" errorPage="/WEB-INF/jsp/include/defaultException.jsp"%>
2 <%@include file="/WEB-INF/jsp/include/tags.jsp"%>
3 <g:page business="message" var="m_messages" pageNo="${param.pageNo}" pageSize="30" orderBy="id desc" scope="request" />
4
5 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
6 <html>
7 <head>
8 <title>Message List</title>
9 </head>
10
11 <body>
12
13 Leave a message:<br>
14
15 <form method="POST" action="./newMessage.do">
16 <textarea name="content" cols="80" rows="10"></textarea>
17
18 <br/>
19 <input type="submit" />
20 </form>
21
22 <hr>
23 <table width="96%" border="1">
24 <tr>
25 <th>No.</th>
26 <th>Content</th>
27 <th>Date</th>
28 </tr>
29
30 <c:forEach items="${m_messages.elements}" var="m_msg">
31 <tr>
32 <td>${m_messages.index}</td>
33 <td><g:out value="${m_msg.content}" escapeXml="false" escapeScriptCode="true" /></td>
34 <td>${m_msg.createdTime}</td>
35 </tr>
36 </c:forEach>
37 </table>
38
39 <table width="96%" border="1">
40 <tr>
41 <c:import url="/WEB-INF/jsp/include/console_flip.jsp" />
42 </tr>
43 </table>
44
45 </body>
46 </html>
在这个jsp中，
1 <g:page business="message" var="m_messages" pageNo="${param.pageNo}" pageSize="30" orderBy="id desc" scope="request" />
根据当前传入的页码查询message，并按照id desc排序。然后我们用1个c:forEach循环，打印出结果。用m_messages.index打印出当前记录从1开始的排序位置，用g:out标签打印出允许html元素但不允许script执行的正文。最后引用通用的分页文件 /WEB-INF/jsp/include/console_flip.jsp 显示分页情况。
再次访问：http://localhost:8080/guzz/messageList.jsp ，可以看到分页显示的留言列表了：
实现读写分离（启用第2台数据库）
如果你有多台数据库，创建mb_main数据库的从库（具体可参看http://guzz.javaeye.com/blog/366508）。修改guzz.xml的
1 <dbgroup name="default" masterDBConfigName="masterDB" />
增加从数据库配置属性slaveDBConfigName，我们设置值为slaveDB。如下：
1 <dbgroup name="default" masterDBConfigName="masterDB" slaveDBConfigName="slaveDB" />
在messageBoard.properties文件增加slaveDB配置项的具体信息，如下：
1 [slaveDB] 2 guzz.identifer=defaultSlaveDB1 3 guzz.IP=localhost 4 guzz.maxLoad=80 5 driverClass=com.mysql.jdbc.Driver 6 jdbcUrl=jdbc:mysql://localhost:3306/mb_main?useUnicode=true&characterEncoding=UTF-8&useServerPrepStmts=true 7 user=root 8 password=root 9 acquireIncrement=10 10 idleConnectionTestPeriod=60
当然，如果你有单独的从数据库，jdbcUrl处修改为从库地址。
此时完成的 messageBoard.properties 文件内容为：
1 #guzz app config file. 2 3 #master db 4 [masterDB] 5 guzz.identifer=defaultMasterDB1 6 guzz.IP=localhost 7 guzz.maxLoad=120 8 driverClass=com.mysql.jdbc.Driver 9 jdbcUrl=jdbc:mysql://localhost:3306/mb_main?useUnicode=true&characterEncoding=UTF-8&useServerPrepStmts=true 10 user=root 11 password=root 12 acquireIncrement=10 13 idleConnectionTestPeriod=60 14 15 [slaveDB] 16 guzz.identifer=defaultSlaveDB1 17 guzz.IP=localhost 18 guzz.maxLoad=80 19 driverClass=com.mysql.jdbc.Driver 20 jdbcUrl=jdbc:mysql://localhost:3306/mb_main?useUnicode=true&characterEncoding=UTF-8&useServerPrepStmts=true 21 user=root 22 password=root 23 acquireIncrement=10 24 idleConnectionTestPeriod=60 25 26 #debug settings 27 [guzzDebug] 28 #runMode=debug/production 29 runMode=debug 30 #onError=halt/log/ignore 31 onError=halt 32 printSQL=true 33 printSQLParams=true 34 ignoreDemonThreadSQL=true 35 #print out how many nano-seconds a sql takes to execute. 36 measureTime=true 37 #only print out slow sqls that takes over xxx mill-seconds to execute. 0 means print out all. 38 onlySlowSQLInMillSeconds=0 39 40 ############################### fundamental services #####################
至此，即完成了读写分离的配置。系统启动后，将创建两个连接池，上面留言读取的g:page将自动从slave数据库连接操作。在调用guzz持久化API时，所有选择允许延迟的读操作也将从slave连接池操作。
实现1个多用户留言板
为了实现多用户留言板，首先我们需要增加User域对象。User对象只有三个属性，用户编号、用户名和留言数。创建example.business.User.java:
1 package example.business;
2
3 public class User implements java.io.Serializable {
4
5 private int id ;
6
7 private String userName ;
8
9 private int messageCount ;
10
11 public int getId() {
12 return id;
13 }
14
15 public void setId(int id) {
16 this.id = id;
17 }
18
19 public String getUserName() {
20 return userName;
21 }
22
23 public void setUserName(String userName) {
24 this.userName = userName;
25 }
26
27 public int getMessageCount() {
28 return messageCount;
29 }
30
31 public void setMessageCount(int messageCount) {
32 this.messageCount = messageCount;
33 }
34
35 }
创建映射文件User.hbm.xml：
1 <?xml version="1.0"?> 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 4 <hibernate-mapping> 5 <class name="example.business.User" table="tb_user"> 6 <id name="id" type="int" column="id"> 7 <generator class="native" /> 8 </id> 9 <property name="userName" type="string" column="userName" /> 10 <property name="messageCount" type="int" column="messageCount" /> 11 </class> 12 </hibernate-mapping>
同时在Message.java、Message.hbm.xml 中增加userId属性对应User对象的id属性。新的Message.java和Message.hbm.xml为：
1 package example.business;
2
3 import java.util.Date;
4
5 public class Message implements java.io.Serializable {
6
7 private int id ;
8
9 private String content ;
10
11 private int userId ;
12
13 private Date createdTime ;
14
15 public int getId() {
16 return id;
17 }
18
19 public void setId(int id) {
20 this.id = id;
21 }
22
23 public String getContent() {
24 return content;
25 }
26
27 public void setContent(String content) {
28 this.content = content;
29 }
30
31 public Date getCreatedTime() {
32 return createdTime;
33 }
34
35 public void setCreatedTime(Date createdTime) {
36 this.createdTime = createdTime;
37 }
38
39 public int getUserId() {
40 return userId;
41 }
42
43 public void setUserId(int userId) {
44 this.userId = userId;
45 }
46
47 }
1 <?xml version="1.0"?> 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 4 <hibernate-mapping> 5 <class name="example.business.Message" table="tb_message"> 6 <id name="id" type="int" column="id"> 7 <generator class="native" /> 8 </id> 9 <property name="userId" type="int" column="userId" /> 10 <property name="content" type="string" column="content" /> 11 <property name="createdTime" type="datetime" column="createdTime" /> 12 </class> 13 </hibernate-mapping>
在mb_main数据库中增加tb_user表，并调整tb_message表：
1 use mb_main ; 2 3 create table tb_user( 4 id int not null auto_increment primary key, 5 userName varchar(64) not null, 6 messageCount int(11)default 0 7 )engine=Innodb ; 8 9 alter table tb_message add column userId int(11) default 1 ; 10 create index idx_msg_uid on tb_message(userId) ; 11 12 insert into tb_user(userName) values(‘Lucy‘) ; 13 insert into tb_user(userName) values(‘Lily‘) ; 14 insert into tb_user(userName) values(‘Cathy‘) ; 15 insert into tb_user(userName) values(‘Polly, The Bird‘) ; 16 17 update tb_user set messageCount = (select count(*) from tb_message) where id = 1 ;
修改guzz.xml，增加User域对象的声明：
1 <business dbgroup="default" name="user" file="classpath:example/business/User.hbm.xml" />
由于是多用户留言板，因此 messageList.jsp 中我们需要增加一个参数用来区分用户。此参数定义为userId。无论是访问留言板，还是发表留言，我们都用userId标记当前留言板所属用户。修改 messageList.jsp 增加对userId参数的支持：
1 <%@ page language="java" pageEncoding="UTF-8" errorPage="/WEB-INF/jsp/include/defaultException.jsp"%>
2 <%@include file="/WEB-INF/jsp/include/tags.jsp"%>
3 <g:get business="user" var="m_user" limit="id=${param.userId}" />
4
5 <g:boundary>
6 <g:addLimit limit="userId=${m_user.id}" />
7 <g:page business="message" var="m_messages" tableCondition="${m_user.id}" pageNo="${param.pageNo}" pageSize="30" orderBy="id desc" scope="request" />
8 </g:boundary>
9
10 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
11 <html>
12 <head>
13 <title>${m_user.userName}‘s Message List</title>
14 </head>
15
16 <body>
17 Leave a message:<br>
18
19 <form method="POST" action="./newMessage.do">
20 <input type="hidden" name="userId" value="${m_user.id}" />
21
22 <textarea name="content" cols="80" rows="10"></textarea>
23 ....
在新的 messageList.jsp 中，g:page增加了1个查询条件。而在form表单提交时，增加了隐藏的userId参数。
修改 NewMessageAction.java 增加对userId参数的支持：
1 public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
2 int userId = RequestUtil.getParameterAsInt(request, "userId", 0) ;
3 String content = request.getParameter("content") ;
4
5 Message msg = new Message() ;
6 msg.setContent(content) ;
7 msg.setCreatedTime(new java.util.Date()) ;
8
9 //close auto-commit
10 WriteTranSession write = guzzContext.getTransactionManager().openRWTran(false) ;
11
12 try{
13 User user = (User) write.findObjectByPK(User.class, userId) ;
14 user.setMessageCount(user.getMessageCount() + 1) ;
15
16 msg.setUserId(userId) ;
17
18 write.insert(msg) ;
19 write.update(user) ;
20
21 write.commit() ;
22 }catch(Exception e){
23 write.rollback() ;
24
25 throw e ;
26 }finally{
27 write.close() ;
28 }
29
30 return new ModelAndView("redirect:/messageList.jsp", "userId", userId);
31 }
因为要同时更新两张表，因此我们选择手工控制事务的提交。
重新部署并启动应用，访问：http://localhost:8080/guzz/messageList.jsp?userId=1 ，看到Lucy‘s Message List；访问http://localhost:8080/guzz/messageList.jsp?userId=1 看到Lily‘s Message List。
多用户留言板完成。
使用2组数据库（启用第3、4台数据库）
随着业务的增长我们发现mb_main数据库负载太高，需要将tb_user表挪出去，部署到另外一组数据库中。这组数据库有1台主库（第3台数据库）和1台从库（第4台数据库）。
我们给这组新数据库取名为userDB。首先，很显然需要将现有的tb_user表导出并装载到userDB数据库组中，并建好数据库主从。假设此步骤已经完成。
为了演示，我们在本机上创建 mb_user 数据库作为userDB。
1 create database mb_user default character set utf8 ; 2 3 create table mb_user.tb_user select * from mb_main.tb_user ; 4 5 alter table mb_user.tb_user modify column id int(11) not null auto_increment primary key ; 6 7 drop table mb_main.tb_user ;
这时我们有2组数据库：mb_main存放tb_message, mb_user存放tb_user。
为了让应用知道mb_user库的存在，修改guzz.xml的tran，增加一个userDB dbgroup：
1 <dbgroup name="userDB" masterDBConfigName="userMasterDB" slaveDBConfigName="userSlaveDB" />
修改User域对象使用userDB：
1 <business dbgroup="userDB" name="user" file="classpath:example/business/User.hbm.xml" />
修改messageBoard.properties主配置文件，增加userDB主从数据库连接池的配置信息userMasterDB和userSlaveDB:
1 [userMasterDB] 2 guzz.identifer=userMasterDB1 3 guzz.IP=localhost 4 guzz.maxLoad=120 5 driverClass=com.mysql.jdbc.Driver 6 jdbcUrl=jdbc:mysql://localhost:3306/mb_user?useUnicode=true&characterEncoding=UTF-8&useServerPrepStmts=true 7 user=root 8 password=root 9 acquireIncrement=10 10 idleConnectionTestPeriod=60 11 12 [userSlaveDB] 13 guzz.identifer=userSlaveDB1 14 guzz.IP=localhost 15 guzz.maxLoad=80 16 driverClass=com.mysql.jdbc.Driver 17 jdbcUrl=jdbc:mysql://localhost:3306/mb_user?useUnicode=true&characterEncoding=UTF-8&useServerPrepStmts=true 18 user=root 19 password=root 20 acquireIncrement=10 21 idleConnectionTestPeriod=60
如果你有第3、4台独立数据库，将上面的jdbcUrl改到具体的数据库地址即可。
重新部署并启动应用，这时您的应用已经开始使用4台数据库。当你发表新留言时，更新tb_user和tb_message表的操作将自动在一个分布式事务中完成。代码不需要做任何调整。
注意： 1. 通过create table ..select..的方式，索引将不复存在，真实环境下注意重新创建索引。2. 上面例子中的sql语句通过db.table的方式操作数据库，mysql主从复制可能会忽略这类操作的复制；如果从库没有执行，需要手工在从库执行sql。下同。
将留言表分切成小表
随着业务的进一步发展，很快留言数突破千万，tb_message查询缓慢，已经成为系统的性能瓶颈。我们决定将留言表按照用户分成多张小表。
分切的规则是：每个用户1张表，表名规则为tb_message${userId}。
切表的详细说明文档，请参看：TutorialShadowTable 。
为了实现表分切，首先需要实现分切规则，创建一个新的java类 example.business.MessageShadowTableView 定义规则：
1 package example.business;
2
3 import org.guzz.exception.GuzzException;
4 import org.guzz.orm.AbstractShadowTableView;
5
6 public class MessageShadowTableView extends AbstractShadowTableView {
7
8 public String toTableName(Object tableCondition) {
9 if (tableCondition = null) { // 强制要求必须设置表分切条件，避免编程时疏忽。
10 throw new GuzzException("null table conditon is not allowed.");
11 }
12
13 Integer userId = (Integer) tableCondition;
14
15 //tb_message_${userId}
16 return "tb_message_" + userId.intValue() ;
17 }
18
19 }
可见，分切条件为用户编号userId。我们有4个用户，因此将tb_message分切成4张小表，分别为：tb_message_1, tb_message_2, tb_message_3, tb_message_4.
1 use mb_main ; 2 3 create table tb_message_1 select * from tb_message where userId = 1 ; 4 create table tb_message_2 select * from tb_message where userId = 2 ; 5 create table tb_message_3 select * from tb_message where userId = 3 ; 6 create table tb_message_4 select * from tb_message where userId = 4 ; 7 8 alter table tb_message_1 modify column id int(11) not null auto_increment primary key ; 9 alter table tb_message_2 modify column id int(11) not null auto_increment primary key ; 10 alter table tb_message_3 modify column id int(11) not null auto_increment primary key ; 11 alter table tb_message_4 modify column id int(11) not null auto_increment primary key ; 12 13 drop table tb_message ;
为了让guzz知道表分切规则，修改Message.hbm.xml映射文件，在class元素中增加属性 shadow="example.business.MessageShadowTableView" ，同时将dtd定义改成guzz的。修改后的文件为：
1 <?xml version="1.0"?> 2 <!DOCTYPE guzz-mapping PUBLIC "-//GUZZ//GUZZ MAPPING DTD//EN" "http://www.guzz.org/dtd/guzz-mapping.dtd"> 3 <guzz-mapping> 4 <class name="example.business.Message" table="tb_message" shadow="example.business.MessageShadowTableView"> 5 <id name="id" type="int" column="id"> 6 <generator class="native" /> 7 </id> 8 <property name="userId" type="int" column="userId" /> 9 <property name="content" type="string" column="content" /> 10 <property name="createdTime" type="datetime" column="createdTime" /> 11 </class> 12 </guzz-mapping>
这时guzz已经知道Message对象需要根据 example.business.MessageShadowTableView 进行切表。在所有操作 Message 的地方，需要传入userId作为切表条件（称作：tableCondition）。
对于留言读取的地方，修改 messageList.jsp 的g:page调用为：
1 <g:page business="message" var="m_messages" tableCondition="${param.userId}" pageNo="${param.pageNo}" pageSize="30" orderBy="id desc" scope="request" />
通过tableCondition属性传入切表条件。
修改 NewMessageAction.java的 write.insert(msg) 为 write.insert(msg, userId) 通过insert方法的第二个参数传入切表条件。
重新部署并启动应用，可以看到我们的留言板已经在4个小表中工作了。
分布式切表以应对超级大表
随着业务的更进一步发展，我们发现tb_message即使分成了小表，都存储在一台数据库中也过于庞大。在实际的应用中，可能是您的数据已经分切成了上百张表，总量非常大。现在，我们需要将这些分切后的小表，存储到不同的数据库机器中，减少单台数据库数据量过大的问题，同时也减少1台数据库上表的总个数。
为了解决这个问题，guzz提供了分布式切表功能，称作VirtualDB。详细介绍请参看：TutorialVirtualDB
为了演示，我们个性化的小表存储规则为：编号为1的用户，留言继续存储在default数据库组中不变（mb_main库中）；其他的存储到userDB中（mb_user库中）。当然在实际系统中，您可能不会这么切分，更可能引入第5、6、7、8甚至更多台的数据库机器。这里只是演示灵活的切分规则。
现在我们开始挪表，把tb_message_2, tb_message_3, tb_message_4从mb_main挪到mb_user中：
1 create table mb_user.tb_message_2 select * from mb_main.tb_message_2 ; 2 create table mb_user.tb_message_3 select * from mb_main.tb_message_3 ; 3 create table mb_user.tb_message_4 select * from mb_main.tb_message_4 ; 4 5 alter table mb_user.tb_message_2 modify column id int(11) not null auto_increment primary key ; 6 alter table mb_user.tb_message_3 modify column id int(11) not null auto_increment primary key ; 7 alter table mb_user.tb_message_4 modify column id int(11) not null auto_increment primary key ; 8 9 drop table mb_main.tb_message_2 ; 10 drop table mb_main.tb_message_3 ; 11 drop table mb_main.tb_message_4 ;
创建一个新的java类，定义VirtualDB的表分布规则：
1 package example.business;
2
3 import org.guzz.connection.AbstractVirtualDBView;
4 import org.guzz.exception.GuzzException;
5
6 public class MessageVirtualDBView extends AbstractVirtualDBView {
7
8 public String getPhysicsDBGroupName(Object tableCondition) {
9 if (tableCondition = null) {
10 throw new GuzzException("null table conditon is not allowed.");
11 }
12
13 int userId = (Integer) tableCondition;
14
15 if(userId = 1){
16 //store lucy‘s messages in the default database.
17 return "default" ;
18 }else{
19 //store others in the userDB database.
20 return "userDB" ;
21 }
22 }
23
24 }
为了让 guzz 知道分布式切表，对于每个使用VirtualDB的领域对象，我们需要在guzz.xml中声明一个virtualdbgroup。对于Message，修改guzz.xml，在tran元素下增加virtualdbgroup：
1 <virtualdbgroup name="messageDB" shadow="example.business.MessageVirtualDBView" />
同时，修改Message领域对象的dbgroup到新的messageDB。修改好的guzz.xml为：
1 <?xml version="1.0" encoding="UTF-8"?> 2 <!DOCTYPE guzz-configs PUBLIC "-//GUZZ//DTD MAIN CONFIG//EN" "http://www.guzz.org/dtd/guzz.dtd"> 3 4 <guzz-configs> 5 6 <dialect class="org.guzz.dialect.Mysql5Dialect" /> 7 8 <tran> 9 <dbgroup name="default" masterDBConfigName="masterDB" slaveDBConfigName="slaveDB" /> 10 <dbgroup name="userDB" masterDBConfigName="userMasterDB" slaveDBConfigName="userSlaveDB" /> 11 12 <virtualdbgroup name="messageDB" shadow="example.business.MessageVirtualDBView" /> 13 </tran> 14 15 <config-server> 16 <server class="org.guzz.config.LocalFileConfigServer"> 17 <param name="resource" value="messageBoard.properties" /> 18 </server> 19 </config-server> 20 21 <!-- business starts --> 22 <business dbgroup="messageDB" name="message" file="classpath:example/business/Message.hbm.xml" /> 23 <business dbgroup="userDB" name="user" file="classpath:example/business/User.hbm.xml" /> 24 <!-- business ends --> 25 26 </guzz-configs>
重新部署并启动应用。此时的留言板将自动将lucy的留言存储到mb_main，其他人的留言存储到mb_user库中。完成分布式切表。
用计数器服务实现支持投票（启用第3组，第5台数据库）
实现投票功能
随着留言板应用的深入，用户希望能够对留言进行投票，像digg一样支持优秀的留言。我们需要给留言增加vote功能。Vote分为支持和反对，支持增加10分，反对减少8分。在Message中增加一个voteScore记录得票的总分数。我们给Message.java对象和对应的Message.hbm.xml文件增加3个int类型属性：
1 private int voteYes ; 2 3 private int voteNo ; 4 5 private int voteScore ;
调整数据库表结构，增加这3个字段：
1 alter table mb_main.tb_message_1 add column voteYes int(11) default 0 ; 2 alter table mb_main.tb_message_1 add column voteNo int(11) default 0 ; 3 alter table mb_main.tb_message_1 add column voteScore int(11) default 0 ; 4 5 alter table mb_user.tb_message_2 add column voteYes int(11) default 0 ; 6 alter table mb_user.tb_message_2 add column voteNo int(11) default 0 ; 7 alter table mb_user.tb_message_2 add column voteScore int(11) default 0 ; 8 9 alter table mb_user.tb_message_3 add column voteYes int(11) default 0 ; 10 alter table mb_user.tb_message_3 add column voteNo int(11) default 0 ; 11 alter table mb_user.tb_message_3 add column voteScore int(11) default 0 ; 12 13 alter table mb_user.tb_message_4 add column voteYes int(11) default 0 ; 14 alter table mb_user.tb_message_4 add column voteNo int(11) default 0 ; 15 alter table mb_user.tb_message_4 add column voteScore int(11) default 0 ;
为支持用户投票，增加一个action处理此操作，example.view.action.VoteMessageAction.java：
1 package example.view.action;
2
3 import javax.servlet.http.HttpServletRequest;
4 import javax.servlet.http.HttpServletResponse;
5
6 import org.guzz.Guzz;
7 import org.guzz.GuzzContext;
8 import org.guzz.transaction.WriteTranSession;
9 import org.guzz.util.Assert;
10 import org.guzz.util.RequestUtil;
11 import org.springframework.web.servlet.ModelAndView;
12 import org.springframework.web.servlet.mvc.Controller;
13
14 import example.business.Message;
15
16 public class VoteMessageAction implements Controller {
17
18 private GuzzContext guzzContext ;
19
20 public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
21 int userId = RequestUtil.getParameterAsInt(request, "userId", 0) ;
22 int msgId = RequestUtil.getParameterAsInt(request, "msgId", 0) ;
23 String type = request.getParameter("type") ;
24
25 //auto-commit
26 WriteTranSession write = guzzContext.getTransactionManager().openRWTran(true) ;
27
28 try{
29 //set tableCondition
30 Guzz.setTableCondition(userId) ;
31 Message msg = (Message) write.findObjectByPK(Message.class, msgId) ;
32 Assert.assertNotNull(msg, "msg not found!") ;
33
34 if("yes".equals(type)){
35 msg.setVoteYes(msg.getVoteYes() + 1) ;
36 msg.setVoteScore(msg.getVoteScore() + 10) ;
37 }else{
38 msg.setVoteNo(msg.getVoteNo() + 1) ;
39 msg.setVoteScore(msg.getVoteScore() - 8) ;
40 }
41
42 write.update(msg) ;
43 }finally{
44 write.close() ;
45 }
46
47 return new ModelAndView("redirect:/messageList.jsp", "userId", userId);
48 }
49
50 public GuzzContext getGuzzContext() {
51 return guzzContext;
52 }
53
54 public void setGuzzContext(GuzzContext guzzContext) {
55 this.guzzContext = guzzContext;
56 }
57
58 }
在这个Action中，我们通过 Guzz.setTableCondition(userId) 设置当前线程所有数据库操作默认的分表条件，然后获取要投票的留言，增加计数后更新。
将这个Action的配置添加到dispatcher-servlet.xml中：
1 <bean name="/voteMessage.do" class="example.view.action.VoteMessageAction"> 2 <property name="guzzContext" ref="guzzContext" /> 3 </bean>
修改 messageList.jsp ，列出投票数和投票地址：
1 <%@ page language="java" pageEncoding="UTF-8" errorPage="/WEB-INF/jsp/include/defaultException.jsp"%>
2 <%@include file="/WEB-INF/jsp/include/tags.jsp"%>
3
4 <g:get business="user" var="m_user" limit="id=${param.userId}" />
5
6 <g:boundary>
7 <g:addLimit limit="userId=${m_user.id}" />
8 <g:page business="message" var="m_messages" tableCondition="${m_user.id}" pageNo="${param.pageNo}" pageSize="30" orderBy="id desc" scope="request" />
9 </g:boundary>
10
11 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
12 <html>
13 <head>
14 <title>${m_user.userName}‘s Message List</title>
15 </head>
16
17 <body>
18 Leave a message:<br>
19
20 <form method="POST" action="./newMessage.do">
21 <input type="hidden" name="userId" value="${m_user.id}" />
22
23 <textarea name="content" cols="80" rows="10"></textarea>
24
25 <br/>
26 <input type="submit" />
27 </form>
28
29 <hr>
30 <table width="96%" border="1">
31 <tr>
32 <th>No.</th>
33 <th>Vote</th>
34 <th>Content</th>
35 <th>Date</th>
36 </tr>
37
38 <c:forEach items="${m_messages.elements}" var="m_msg">
39 <tr>
40 <td>${m_messages.index}</td>
41 <td>
42 voteYes: <a href="./voteMessage.do?type=yes&userId=${m_msg.userId}&msgId=${m_msg.id}">${m_msg.voteYes}</a><br>
43 voteNo: <a href="./voteMessage.do?type=no&userId=${m_msg.userId}&msgId=${m_msg.id}">${m_msg.voteNo}</a><br>
44 voteScore: ${m_msg.voteScore}
45 </td>
46 <td>vote<g:out value="${m_msg.content}" escapeXml="false" escapeScriptCode="true" /></td>
47 <td>${m_msg.createdTime}</td>
48 </tr>
49 </c:forEach>
50 </table>
51
52 <table width="96%" border="1">
53 <tr>
54 <c:import url="/WEB-INF/jsp/include/console_flip.jsp" />
55 </tr>
56 </table>
57
58 </body>
59 </html>
重新并重启应用，现在投票功能就可以使用了。
SlowUpdateService（使用第5台数据库）
虽然投票功能有了，但刚上线就发现了另外一个问题：投票的量太多。每次投票都需要进行一次数据库update操作，频繁的update操作对数据库的消耗太大。
我们希望将投票操作队列化，最好能够合并对同1条记录的多个update操作，然后用批操作的方式写入数据库，最大程度的减少数据库消耗，而不要每次都单独update。
这种场景出现的比较多，因此guzz内置了 SlowUpdateService 服务来完成这种队列化计数更新操作。详细的配置参数和工作原理，请参看：AppendCoreService
下面我们开始配置。为了减少对主库的影响，计数对列我们存储在第5台临时数据库中。创建数据库mb_temp，并创建计数队列存储的表tb_guzz_su：
1 create database mb_temp default character set utf8 ; 2 3 use mb_temp ; 4 5 create table tb_guzz_su( 6 gu_id bigint not null auto_increment primary key, 7 gu_db_group varchar(32) not null, 8 gu_tab_name varchar(64) not null, 9 gu_inc_col varchar(64) not null , 10 gu_tab_pk_col varchar(64) not null, 11 gu_tab_pk_val varchar(64) not null , 12 gu_inc_count int(11) not null 13 )engine=Innodb ;
在guzz.xml中增加mb_temp对应的数据库组tempDB，并增加临时表对应域对象的声明：
1 <tran> 2 .... 3 <dbgroup name="tempDB" masterDBConfigName="tempMasterDB" /> 4 .... 5 </tran> 6 7 <business dbgroup="tempDB" name="guzzSlowUpdate" file="classpath:example/business/IncUpdateBusiness.hbm.xml" />
将工程src中的 fms/business/IncUpdateBusiness.hbm.xml 挪到 example/business/ 下。fms/business目录可以删掉了。
默认的 SlowUpdateService 服务为guzz内置服务。guzz在启动时会自动创建此服务，名称为guzzSlowUpdate，配置组的名称也为guzzSlowUpdate。修改messageBoard.properties主配置文件，增加此服务配置信息，同时增加tempDB数据库组主数据库的连接池配置：
[tempMasterDB] guzz.identifer=tempMasterDB1 guzz.IP=localhost guzz.maxLoad=120 driverClass=com.mysql.jdbc.Driver jdbcUrl=jdbc:mysql://localhost:3306/mb_temp?useUnicode=true&characterEncoding=UTF-8&useServerPrepStmts=true user=root password=root acquireIncrement=10 idleConnectionTestPeriod=60 [guzzSlowUpdate] #max size of cached queue queueSize=20480 #batch size for updating to the temporary database. batchSize=2048
至此，计数队列的配置完成。为了方便spring使用，我们将此服务导出为spring bean，在applicationContext.xml中添加bean：
1 <bean id="guzzSlowUpdateService" class="org.guzz.web.context.spring.GuzzServiceFactoryBean"> 2 <property name="serviceName" value="guzzSlowUpdate" /> 3 </bean>
修改 VoteMessageAction.java 使用计数器服务：
1 package example.view.action;
2
3 import javax.servlet.http.HttpServletRequest;
4 import javax.servlet.http.HttpServletResponse;
5
6 import org.guzz.service.core.SlowUpdateService;
7 import org.guzz.util.RequestUtil;
8 import org.springframework.web.servlet.ModelAndView;
9 import org.springframework.web.servlet.mvc.Controller;
10
11 import example.business.Message;
12
13 public class VoteMessageAction implements Controller {
14
15 private SlowUpdateService slowUpdateService ;
16
17 public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
18 int userId = RequestUtil.getParameterAsInt(request, "userId", 0) ;
19 int msgId = RequestUtil.getParameterAsInt(request, "msgId", 0) ;
20 String type = request.getParameter("type") ;
21
22 if("yes".equals(type)){
23 //public void updateCount(Class domainClass, Object tableCondition, String propToUpdate, Serializable pkValue, int countToInc) ;
24 this.slowUpdateService.updateCount(Message.class, userId, "voteYes", msgId, 1) ;
25 this.slowUpdateService.updateCount(Message.class, userId, "voteScore", msgId, 10) ;
26 }else{
27 this.slowUpdateService.updateCount(Message.class, userId, "voteNo", msgId, 1) ;
28 this.slowUpdateService.updateCount(Message.class, userId, "voteScore", msgId, -8) ;
29 }
30
31 return new ModelAndView("redirect:/messageList.jsp", "userId", userId);
32 }
33
34 public SlowUpdateService getSlowUpdateService() {
35 return slowUpdateService;
36 }
37
38 public void setSlowUpdateService(SlowUpdateService slowUpdateService) {
39 this.slowUpdateService = slowUpdateService;
40 }
41
42 }
在新的Action中，不在直接操作数据库，而是调用updateCount将计数操作写入队列。
修改 dispatcher-servlet.xml ，在bean：/voteMessage.do 中注入guzzSlowUpdateService：
<bean name="/voteMessage.do" class="example.view.action.VoteMessageAction">
<property name="slowUpdateService" ref="guzzSlowUpdateService" />
</bean>
重新部署并启动应用。投票。此时票数没有变化，没有关系，打开mb_temp数据库的tb_guzz_su表，可以看到计数操作已经成功写入到了队列中。
SlowUpdateServerService
为了将计数队列的数据写回各个表对应的主库，还需要启动计数队列服务的服务器端。修改guzz.xml文件，添加服务器端服务：
1 <service name="slowUpdateServer" configName="guzzSlowUpdateServer" class="org.guzz.service.db.impl.SlowUpdateServerImpl" />
修改messageBoard.properties文件，添加slowUpdateServer服务的详细配置信息：
1 [guzzSlowUpdateServer] 2 #batch size for updating the main database 3 batchSize=50 4 5 #page size for reading from the temporary table 6 pageSize=40 7 8 #how many pages to read from the temporary table for one loop updating 9 combinePageCount=10 10 11 #millseconds to wait for the next round of updates checking 12 updateInterval=500
重新部署并启动应用。查看tb_guzz_su表，队列已经被处理，访问：http://localhost:8080/guzz/messageList.jsp?userId=1 ，看到计数已经正确更新了。
删除留言，批量删除留言
单条留言删除
创建删除留言的Action：example.view.action.DeleteMessageAction.java：
1 package example.view.action;
2
3 import javax.servlet.http.HttpServletRequest;
4 import javax.servlet.http.HttpServletResponse;
5
6 import org.guzz.Guzz;
7 import org.guzz.GuzzContext;
8 import org.guzz.service.core.SlowUpdateService;
9 import org.guzz.transaction.WriteTranSession;
10 import org.guzz.util.RequestUtil;
11 import org.springframework.web.servlet.ModelAndView;
12 import org.springframework.web.servlet.mvc.Controller;
13
14 import example.business.Message;
15 import example.business.User;
16
17 public class DeleteMessageAction implements Controller {
18
19 private GuzzContext guzzContext ;
20
21 private SlowUpdateService slowUpdateService ;
22
23 public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
24 int userId = RequestUtil.getParameterAsInt(request, "userId", 0) ;
25 int msgId = RequestUtil.getParameterAsInt(request, "msgId", 0) ;
26
27 //auto-commit
28 WriteTranSession write = guzzContext.getTransactionManager().openRWTran(true) ;
29
30 try{
31 Guzz.setTableCondition(userId) ;
32 Message msg = (Message) write.findObjectByPK(Message.class, msgId) ;
33
34 if(msg != null){
35 write.delete(msg) ;
36
37 //dec the message count
38 this.slowUpdateService.updateCount(User.class, null, "messageCount", userId, -1) ;
39 }
40 }finally{
41 write.close() ;
42 }
43
44 return new ModelAndView("redirect:/messageList.jsp", "userId", userId);
45 }
46
47 public GuzzContext getGuzzContext() {
48 return guzzContext;
49 }
50
51 public void setGuzzContext(GuzzContext guzzContext) {
52 this.guzzContext = guzzContext;
53 }
54
55 public SlowUpdateService getSlowUpdateService() {
56 return slowUpdateService;
57 }
58
59 public void setSlowUpdateService(SlowUpdateService slowUpdateService) {
60 this.slowUpdateService = slowUpdateService;
61 }
62
63 }
配置到 dispatcher-servlet.xml 中：
1 <bean name="/deleteMessage.do" class="example.view.action.DeleteMessageAction"> 2 <property name="guzzContext" ref="guzzContext" /> 3 <property name="slowUpdateService" ref="guzzSlowUpdateService" /> 4 </bean>
修改 messageList.jsp，增加delete链接到 ./deleteMessage.do?userId=${m_msg.userId}&msgId=${m_msg.id} 即可删除消息。在消息删除时，我们同时用slowUpdateService减少用户的留言数。
批量删除
我们在 messageList.jsp 中增加一个Form表单，提交表单时提交所有选择的留言编号，服务器端根据编号批量删除。messageList.jsp:
1 <%@ page language="java" pageEncoding="UTF-8"%>
2 <%@include file="/WEB-INF/jsp/include/tags.jsp"%>
3
4 <g:get business="user" var="m_user" limit="id=${param.userId}" />
5
6 <g:boundary>
7 <g:addLimit limit="userId=${m_user.id}" />
8 <g:page business="message" var="m_messages" tableCondition="${m_user.id}" pageNo="${param.pageNo}" pageSize="30" orderBy="id desc" scope="request" />
9 </g:boundary>
10
11 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
12 <html>
13 <head>
14 <title>${m_user.userName}‘s Message List</title>
15 </head>
16
17 <body>
18 Leave a message:<br>
19
20 <form method="POST" action="./newMessage.do">
21 <input type="hidden" name="userId" value="${m_user.id}" />
22
23 <textarea name="content" cols="80" rows="10"></textarea>
24
25 <br/>
26 <input type="submit" />
27 </form>
28
29 <hr>
30 <form method="POST" action="./deleteMessage.do">
31 <input type="hidden" name="userId" value="${m_user.id}" />
32
33 <table width="96%" border="1">
34 <tr>
35 <th>No.</th>
36 <th>Vote</th>
37 <th>Content</th>
38 <th>Date</th>
39 <th>OP</th>
40 </tr>
41
42 <c:forEach items="${m_messages.elements}" var="m_msg">
43 <tr>
44 <td><input type="checkbox" name="ids" value="${m_msg.id}" />${m_messages.index}</td>
45 <td>
46 voteYes: <a href="./voteMessage.do?type=yes&userId=${m_msg.userId}&msgId=${m_msg.id}">${m_msg.voteYes}</a><br>
47 voteNo: <a href="./voteMessage.do?type=no&userId=${m_msg.userId}&msgId=${m_msg.id}">${m_msg.voteNo}</a><br>
48 voteScore: ${m_msg.voteScore}
49 </td>
50 <td>vote<g:out value="${m_msg.content}" escapeXml="false" escapeScriptCode="true" /></td>
51 <td>${m_msg.createdTime}</td>
52 <td><a href="./deleteMessage.do?userId=${m_msg.userId}&msgId=${m_msg.id}">Delete</a></td>
53 </tr>
54 </c:forEach>
55 </table>
56 <table width="96%" border="1">
57 <tr>
58 <c:import url="/WEB-INF/jsp/include/console_flip.jsp" />
59 </tr>
60 </table>
61
62 <table width="96%" border="1">
63 <tr>
64 <td><input type="submit" value="Delete All Selected Messages" /></td>
65 </tr>
66 </table>
67 </form>
68
69 </body>
70 </html>
批量删除我们依然提交到 deleteMessage.do 中，只是采用POST方法提交。修改 DeleteMessageAction.java 以支持批量操作：
1 package example.view.action;
2
3 import java.util.List;
4
5 import javax.servlet.http.HttpServletRequest;
6 import javax.servlet.http.HttpServletResponse;
7
8 import org.guzz.Guzz;
9 import org.guzz.GuzzContext;
10 import org.guzz.jdbc.ObjectBatcher;
11 import org.guzz.orm.se.SearchExpression;
12 import org.guzz.orm.se.Terms;
13 import org.guzz.service.core.SlowUpdateService;
14 import org.guzz.transaction.ReadonlyTranSession;
15 import org.guzz.transaction.WriteTranSession;
16 import org.guzz.util.RequestUtil;
17 import org.springframework.web.servlet.ModelAndView;
18 import org.springframework.web.servlet.mvc.Controller;
19
20 import example.business.Message;
21 import example.business.User;
22
23 public class DeleteMessageAction implements Controller {
24
25 private GuzzContext guzzContext ;
26
27 private SlowUpdateService slowUpdateService ;
28
29 public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
30 int userId = RequestUtil.getParameterAsInt(request, "userId", 0) ;
31
32 if("POST".equals(request.getMethod())){//Batch delete
33 int[] ids = RequestUtil.getParameterAsIntArray(request, "ids", 0) ;
34
35 if(ids.length = 0){
36 return new ModelAndView("redirect:/messageList.jsp", "userId", userId);
37 }
38
39 List<Message> msgs = null ;
40
41 //load the Messages to delete.
42 SearchExpression se = SearchExpression.forLoadAll(Message.class) ;
43 se.setTableCondition(userId) ;
44 se.and(Terms.in("id", ids)) ;
45
46 //read from slave db.
47 ReadonlyTranSession read = guzzContext.getTransactionManager().openDelayReadTran() ;
48 try{
49 msgs = read.list(se) ;
50 }finally{
51 read.close() ;
52 }
53
54 //Open write connections to the master db.
55 WriteTranSession write = guzzContext.getTransactionManager().openRWTran(false) ;
56 try{
57 //Perform Batch operation.
58 ObjectBatcher batcher = write.createObjectBatcher() ;
59 batcher.setTableCondition(userId) ;
60
61 for(Message msg : msgs){
62 batcher.delete(msg) ;
63 }
64
65 batcher.executeUpdate() ;
66
67 write.commit() ;
68 }catch(Exception e){
69 write.rollback() ;
70
71 throw e ;
72 }finally{
73 write.close() ;
74 }
75
76 //dec the message count
77 this.slowUpdateService.updateCount(User.class, null, "messageCount", userId, -msgs.size()) ;
78 }else{
79 //Delete one message
80 int msgId = RequestUtil.getParameterAsInt(request, "msgId", 0) ;
81
82 //auto-commit
83 WriteTranSession write = guzzContext.getTransactionManager().openRWTran(true) ;
84
85 try{
86 Guzz.setTableCondition(userId) ;
87 Message msg = (Message) write.findObjectByPK(Message.class, msgId) ;
88
89 if(msg != null){
90 write.delete(msg) ;
91
92 //dec the message count
93 this.slowUpdateService.updateCount(User.class, null, "messageCount", userId, -1) ;
94 }
95 }finally{
96 write.close() ;
97 }
98 }
99
100 return new ModelAndView("redirect:/messageList.jsp", "userId", userId);
101 }
102
103 public GuzzContext getGuzzContext() {
104 return guzzContext;
105 }
106
107 public void setGuzzContext(GuzzContext guzzContext) {
108 this.guzzContext = guzzContext;
109 }
110
111 public SlowUpdateService getSlowUpdateService() {
112 return slowUpdateService;
113 }
114
115 public void setSlowUpdateService(SlowUpdateService slowUpdateService) {
116 this.slowUpdateService = slowUpdateService;
117 }
118
119 }
对于POST提交的批量操作，我们获取所有提交的消息编号数组，通过 SearchExpression 查询符合的留言，创建批操作一次删除。guzz提供了两种批操作API，一种为基于对象化操作的 ObjectBatcher ，一种为基于直接SQL语句的SQLBatcher。本例子使用的是 ObjectBatcher 。
时间： 2024-10-27 11:21:41