·您的位置: 首页 » 资源教程 » 编程开发 » JAVA、JSP » 求同存异??Java模式系列谈之模板方法

求同存异??Java模式系列谈之模板方法

类别: JAVA教程  评论数:0 总得分:0

一、引言



  不可否认,编代码、写程序,编的写的其实是人的思想;而设计模式更是这种思想的总结。“求同存异”是周总理的著名外交思想之一,“求同”就是寻求相同的地方,并且来解决它;“存异”就是搁置不同的地方,搁置的意思不是不解决,而是留待后面去解决。

在设计模式中,模板方法正是体现了这种思想的典范。

模板方法,定义一个操作中算法的骨架,将一些步骤的执行延迟到其子类中。其中,这些在父类中实现了的步骤就是所谓的“同”,“求同”就是在父类中把相同的功能先实现;而那些延迟到子类中的步骤就是所谓的“异”,“存异”就是把不同在父类中遗留下来,到子类中去各个实现。

在实际的工作中,经常会遇到这样的情况:有一序列的功能相同的模块,这些模板有很多相同或相似的步骤;当然,也有一个或两个不同的步骤。

如,有在线购物功能的网站,经常要对商品进行各种各样的排名:按商品的点击率排名、按商品的购买率排名、按商品的入站时间排名、按商品的类别进行的搜索等等。这些都是一些搜索功能,功能完全相同;不同的要么是搜索的算法、要么是搜索的数据表不同。

我们知道,如果采用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(…)

        {

               //各自不同的代码

               ……

}}

我们来看,将相同的代码在父类中先实现,而将不同的代码延迟到子类中实现,这是不是“求同存异”呢?

有了模板方法模式,关于上面的一个很烂冗长的代码是不是有了解决办法,既做到了满足面向对象的单一职责原则,又重用了代码。
   模板方法可以说是所有模式中最简单、最常用的模式,我们应该熟练的掌握。


-= 资 源 教 程 =-
文 章 搜 索
关键词:
类型:
范围:
纯粹空间 softpure.com
Copyright © 2006-2008 暖阳制作 版权所有
QQ: 15242663 (拒绝闲聊)  Email: faisun@sina.com
 纯粹空间 - 韩国酷站|酷站欣赏|教程大全|资源下载|免费博客|美女壁纸|设计素材|技术论坛   Valid XHTML 1.0 Transitional
百度搜索 谷歌搜索 Alexa搜索 | 粤ICP备19116064号-1