IDC资讯中心
一、引言
不可否认，编代码、写程序，编的写的其实是人的思想；而设计模式更是这种思想的总结。“求同存异”是周总理的著名外交思想之一，“求同”就是寻求相同的地方，并且来解决它；“存异”就是搁置不同的地方，搁置的意思不是不解决，而是留待后面去解决。
在设计模式中，模板方法正是体现了这种思想的典范。
模板方法，定义一个操作中算法的骨架，将一些步骤的执行延迟到其子类中。其中，这些在父类中实现了的步骤就是所谓的“同”，“求同”就是在父类中把相同的功能先实现；而那些延迟到子类中的步骤就是所谓的“异”，“存异”就是把不同在父类中遗留下来，到子类中去各个实现。
在实际的工作中，经常会遇到这样的情况：有一序列的功能相同的模块，这些模板有很多相同或相似的步骤；当然，也有一个或两个不同的步骤。
如，有在线购物功能的网站，经常要对商品进行各种各样的排名：按商品的点击率排名、按商品的购买率排名、按商品的入站时间排名、按商品的类别进行的搜索等等。这些都是一些搜索功能，功能完全相同；不同的要么是搜索的算法、要么是搜索的数据表不同。
我们知道，如果采用struts模式的开发方法，那么我们所有的这些功能的实现都是在一个继承了action类的public actionforward execute ( actionmapping actionmapping, actionform actionform, httpservletrequest request, httpservletresponse response)中实现，这里需要实现的功能有：取得进行搜索所需要的各种条件，进行搜索算法、处理搜索结果。在这里，取得搜索所需的条件和处理搜索结果的算法是一样的，他们将产生相同的代码。不同的只是进行搜索的算法。很明显，相同的代码是需要我们进行重用的。
那么我们该怎么重用呢？
二、从一段代码谈起
首先需要说明的是：这段代码是一段反面的代码，或者说是一段坏的代码。每个人看了都会觉得不可思议，但这确确实实是我们工作中遇到的代码：
public class tospeaction extends action {
public arraylist sizerangelabel = null;
public actionforward execute ( actionmapping actionmapping, actionform actionform, httpservletrequest request, httpservletresponse response) {
……
if ("save".equalsignorecase (action)) {
stringbuffer productidstr = new stringbuffer ( );
stringbuffer specistr = new stringbuffer ( );
specimanager.getinstance ( ).saveheaddata (actionform, request, productidstr, specistr, "specification");
specid = specistr.tostring ( );
productid = productidstr.tostring ( );
form.set ("productid", productid);
form.set ("specid", specid);
}
……
//grid
if (tab.equals ("0")) { //spec
griddatasummary gdsmy = new griddatasummary (specid);
gdsmy.specbasedata.settransform (transform);
gdsmy.specbasedata.setprevtransform (prevtransform);
gdsmy.specbasedata.settextrangesizesrc ((string) form.get ("sizerangeidesc"));
gdsmy.specbasedata.setsortpomstr (sortpomstr);
gdsmy.specbasedata.setgraderuleid ((string) form.get ("ddlgulevule"));
gdsmy.specbasedata.setsizechangeflag ((string) form.get ("sizechangeflag"));
gdsmy.specbasedata.sethidepomcode ("hide".equalsignorecase (hidepomcode) ? true : false);
if ("".equalsignorecase (action)) {
load (request, gdsmy);
} else if ("load".equalsignorecase (action)) {
//grid data
load (request, gdsmy);
} else if ("save".equalsignorecase (action)) {
//save measure table data
save (request, gdsmy, form);
load (request, gdsmy);
} else if ("refgrid".equalsignorecase (action)) {
string xmldata = refgrid (specxmlstr, gridmodel, gdsmy);
loggeragent.debug ("grid business done ……\nthe xml data is " + xmldata);
request.setattribute ("xmlstring", xmldata);
// 判定弹出用户自定义排序窗体,并作业务上的处理
if (griddataconstant.str_true.equals (request.getparameter ("popupdefsort"))) {
request.setattribute ("popupdefsort", "true");
request.getsession ( ).setattribute ("pomlst", gdsmy.getpomlst ( ));
}
}
} else if (tab.equals ("1")) { //increaments
griddatagrdinc gdinc = new griddatagrdinc (specid);
gdinc.specbasedata.settransform (transform);
gdinc.specbasedata.setprevtransform (prevtransform);
gdinc.specbasedata.settextrangesizesrc ((string) form.get ("sizerangeidesc"));
gdinc.specbasedata.setsortpomstr (sortpomstr);
gdinc.specbasedata.setgraderuleid ((string) form.get ("ddlgulevule"));
gdinc.specbasedata.setsizechangeflag ((string) form.get ("sizechangeflag"));
gdinc.specbasedata.sethidepomcode ("hide".equalsignorecase (hidepomcode) ? true : false);
if ("".equalsignorecase (action)) {
load (request, gdinc , gridmodel);
} else if ("load".equalsignorecase (action)) {
//grid data
load (request, gdinc , gridmodel);
} else if ("save".equalsignorecase (action)) {
//save measure table data
save (request, gdinc, form);
gridmodel = (gridcontrolmodel) form.get ("gridmodel");
load (request, gdinc, gridmodel);
} else if ("refgrid".equalsignorecase (action)) {
string xmldata = refgrid (specxmlstr, gridmodel, gdinc);
loggeragent.debug ("grid business done ……\nthe xml data is " + xmldata);
request.setattribute ("xmlstring", xmldata);
// 判定弹出用户自定义排序窗体,并作业务上的处理
if (griddataconstant.str_true.equals (request.getparameter ("popupdefsort"))) {
request.setattribute ("popupdefsort", "true");
request.getsession ( ).setattribute ("pomlst", gdinc.getpomlst ( ));
}
}
} else if (tab.equals ("2")) { //measurements
griddatagrdmeas gdinc = new griddatagrdmeas (specid);
gdinc.specbasedata.settransform (transform);
gdinc.specbasedata.setprevtransform (prevtransform);
gdinc.specbasedata.settextrangesizesrc ((string) form.get ("sizerangeidesc"));
gdinc.specbasedata.setsortpomstr (sortpomstr);
gdinc.specbasedata.setgraderuleid ((string) form.get ("ddlgulevule"));
gdinc.specbasedata.setsizechangeflag ((string) form.get ("sizechangeflag"));
gdinc.specbasedata.sethidepomcode ("hide".equalsignorecase (hidepomcode) ? true : false);
if ("".equalsignorecase (action)) {
load (request, gdinc);
} else if ("load".equalsignorecase (action)) {
//grid data
load (request, gdinc);
} else if ("save".equalsignorecase (action)) {
//save measure table data
save (request, gdinc, form);
gridmodel = (gridcontrolmodel) form.get ("gridmodel");
load (request, gdinc);
} else if ("refgrid".equalsignorecase (action)) {
string xmldata = refgrid (specxmlstr, gridmodel, gdinc);
loggeragent.debug ("grid business done ……\nthe xml data is " + xmldata);
request.setattribute ("xmlstring", xmldata);
//判定弹出用户自定义排序窗体,并作业务上的处理
if (griddataconstant.str_true.equals (request.getparameter ("popupdefsort"))) {
request.setattribute ("popupdefsort", "true");
request.getsession ( ).setattribute ("pomlst", gdinc.getpomlst ( ));
}
}
}
……
}
很乱的一大段代码，被我剪裁下去了很多，但依然还有很大的几页。这段代码实现了什么功能，从现在的代码上看，就已经很让人头疼了，更不要提看原来的代码。通过了解需求，我才明白这段代码的功能：有几个大部分功能相似的页面，每个页面都有相似的功能，如显示数据、保存数据和刷新数据。作者将不同的页面、不同的功能都实现在了一个类里。在上面的代码中，变量tab是用来区别不同的页面的，而action是用来区别不同的动作，如显示、保存、刷新的。
我这样一说，大家都恍然大悟：好家伙，这个类的功能也够强大了的。作者这样写，最重要的原因恐怕是为了代码的重用：因为不管是不同的页面、还是不同的动作，他们都有很多相同或相似的功能，即有需要重用的代码，把他们放在一个类里面，就保证了代码的重用。
大家都知道那是不好的代码，不好在那里呢？
单一职责原则——srp
就一个类而言，应该仅有一个引起它的变化的原因。
原则——最简单，最单纯的事情最容易控制，最有效。
类的职责简单而且集中，避免相同的职责分散到不同的类之中，避免一个类承担过多的职责；减少类之间的耦合；当需求变化时，只修改一个地方。
组件——每个组件集中做好一件事情。
方法——避免写臃肿的方法。
单一职责原则告诉我们，类的功能要单一。这样的好处是多方面的：第一，开发思路清晰，不容易出错。第二，单元测试容易。第三，代码功能简单明了，交流容易。第四，维护容易。
根据srp原则，上面的一个类需要用若干个类来实现，每一个类只实现一个页面的一个功能。确立了这么一个原则，那么下面的问题就是：我们在这些类里有很多相同的代码，怎么实现这些代码的重用呢？
第三、问题的解决
最近我们做的一个项目，产品的生命周期管理系统，我们需要对产品的各个方面进行管理，如产品的总属性、结构、颜色、来源等等。而每一个方面的管理又有两个基本的操作——察看和修改保存。
我们来看使用模板方法对上述问题的解决方法：
首先我们构造一个抽象类：commonaction，该类继承了action，如下：
public abstract class commonaction extends action{
实现public final actionforward execute(actionmapping actionmapping, actionform actionform, httpservletrequest request, httpservletresponse response)方法，注意：为了commonaction类的子类不能覆盖这个方法，我们使用了final关键字。
public final actionforward execute(actionmapping actionmapping, actionform actionform, httpservletrequest request, httpservletresponse response)
{
接下来，我们来实现一些公用代码：
string productid = transformtools.getobjectstring(request.getparameter("productid"),"1");
string nodeid = transformtools.getobjectstring(request.getparameter("nodeid"));
request.setattribute("productid",productid);
request.setattribute("nodeid",nodeid);
string tabid = "";
settablist(request,productid);
fbproduct product = new fbproduct(new long(productid));
commonbean bean=new commonbean();
bean.setnodeid(nodeid);
bean.setproduct(product);
bean.setproductid(productid);
bean.settabid(tabid);
上面是一些公用代码，每一个子类都需要用同样的方法来取得的一些参数和数据。
下面是调用需要子类来实现的方法：
dowithdb(actionform,request,response,bean)
最后又是对公用代码的调用：
return setactionforward(actionmapping,actionform,request,response,bean);
}
至此，我们看到public final actionforward execute(actionmapping actionmapping, actionform actionform, httpservletrequest request, httpservletresponse response)方法已经完成。
我们来看该方法内所调用的方法的实现：
首先是public actionforward setactionforward(actionmapping actionmapping,actionform actionform, httpservletrequest request, httpservletresponse response,commonbean bean)方法，该方法有一个默认的实现，用来实现该跳转功能的绝大多数的功能实现，就是跳转到“success”；当然，有些时候我们不是这么简单的跳转，而需要做一些变化，没关系，在子类中，你可以覆盖这个方法：
public actionforward setactionforward(actionmapping actionmapping,actionform actionform, httpservletrequest request, httpservletresponse response,commonbean bean)
{
return actionmapping.findforward("success");
}
同样：
protected void settablist(httpservletrequest request,string productid)
{
arraylist list = new arraylist();
list = formdataaccess.getproductformlist(productid);
request.setattribute("tablist", list);
request.setattribute("tabname", "construction");
}
protected final void setselecttorequest(httpservletrequest request,object o)
{
hashmap map = getmap("getmap",o);
object[] keys=map.keyset().toarray();
for(int i=0;i<keys.length;i++)
{
request.setattribute(keys[i].tostring(),map.get(keys[i].tostring()));
}
}
private hashmap getmap(string methodname,object o)
{
try
{
class c=o.getclass();
class[] types=new class[]{};
object[] args=new object[]{};
method m=c.getmethod(methodname,types);
return (hashmap)m.invoke(o,args);
}
catch(exception e)
{
e.printstacktrace();
return null;
}
}
最后，我们将dowithdb方法留给子类实现：
protected abstract void dowithdb(actionform actionform, httpservletrequest request, httpservletresponse response,commonbean bean);
}
关键字abstract表明dowithdb是抽象方法，是需要在子类中实现的方法。到此，我们的commonaction类功能完成。
而在子类中，我们只需要实现protected void dowithdb(actionform actionform, httpservletrequest request, httpservletresponse response,commonbean bean)方法就行，如下：
public class toconstructionaction extends commonaction{
protected void dowithdb(actionform actionform, httpservletrequest request, httpservletresponse response,commonbean bean)
{
fbproduct product=bean.getproduct();
t_trimconstruction trimconstruction=(t_trimconstruction)product.gettabinstance(baseelementconst.ft_trim_construction ,bean.getnodeid(),baseelementconst.lib_form_trim_construction,null,request);
ftformparam param = (ftformparam)trimconstruction.getformparam();
param.setnodeid(bean.getnodeid());
param.setobjectid(bean.getproductid());
param.setdetail_object("1");
trimconstruction.loaddata(true,param);
le_trimconstruction construction=(le_trimconstruction)trimconstruction.getsectionbase("le_trimconstruction");
dynaactionform form=(dynaactionform)actionform;
string[] types=(string[])form.get("ddllabeltype");
if(types==null||types.length==0)
{
string[] typess=construction.getfabric().getlabeltypelist();
request.setattribute("types",typess);
form.set("ddllabeltype",typess);
}
else
{
request.setattribute("types",types);
}
constructiondatamanager.setwebdata(form,request,construction.getfabric());
setselecttorequest(request,construction);
request.setattribute("tabname", "construction");
request.setattribute("titlemenu", "librarytrimconstruction");
}
}
第四、总结
由上面的例子，可以看出：如果存在这样一种情况——各类中有同一个方法，在这个方法中，我们要实现一些同样的代码，也有一些不同的代码，形如下面的模式：
public class classname
{
public functionname()
{
//重用的代码
……
//各自不同的代码
……
}
}
这样，我们可以做一个抽象类，在该类中，我们将重用的代码实现，而将不能重用的代码延迟到子类中实现：
public abstract class commonclassname
{
public final functionname()
{
//重用的代码
publicfunction(…);
//各自不同的代码
privatefuction(…);
}
protected publicfunction(…)
{
//重用的代码
……
}
public abstract privatefuction(…);
}
子类：
public class sonclassname extends commonclassname
{
public privatefuction(…)
{
//各自不同的代码
……
}}
我们来看，将相同的代码在父类中先实现，而将不同的代码延迟到子类中实现，这是不是“求同存异”呢？
有了模板方法模式，关于上面的一个很烂冗长的代码是不是有了解决办法，既做到了满足面向对象的单一职责原则，又重用了代码。
模板方法可以说是所有模式中最简单、最常用的模式，我们应该熟练的掌握。
