服务热线：13616026886

技术文档 欢迎使用技术文档，我们为你提供从新手到专业开发者的所有资源，你也可以通过它日益精进

搜索
位置:首页 > 技术文档 > JAVA > 新手入门 > 基础入门 > 查看文档

ajax、struts、spring的无缝结合

人气：1644 2007-11-17

zhipingch 原创

    去年初，正好负责一个医药信息系统的设计开发，架构设计时，采用struts+jdbc（自定义采用适配器模式封装了hashmap动态vo实现的持久层）。后来ajax热潮兴起，正好系统中有很多地方需要和服务器端交互数据，如采购销售系统中的订单头/订单明细等主从表结构的维护。
    [color=blue]数据交互过程[/color]，我们考虑采用xml来组织数据结构，更新/保存:前台封装需要的xml，通过ajax提交---〉action解析xml ---〉改造原有的持久层实现xml持久化；
    查询时：持久层根据实际需要返回xml，document对象，---〉action 处理 --〉前台自己封装js库来解析xml，并刷新部分页面。

    ajax:已经有很多方法实现跨浏览器的方式，这里只介绍最简单的方式，同步模式下提交xmlstr给action（*.do）。

  2. /**
  3.  * 将数据同步传递给后台请求url
  4.  *  @return 返回xmlhttp 响应的信息
  5.  *  @param-url = '/web/module/xxx.do?p1=yy&p2=rr';
  6.  *  @param-xmlstr：xml格式的字符串 <data><xpath><![cdata[数据信息]]></xpath></data>
  7.  * @author zhipingch
  8.  * @date 2005-03-17
  9.  */
  10. function senddata(urlstr, xmlstr) {
  11.     var xmlhttp = new activexobject("microsoft.xmlhttp");
  12.     xmlhttp.open("post", urlstr, false);
  13.     xmlhttp.setrequestheader("content-type", "application/x-www-form-urlencoded");
  14.     if (xmlstr) {
  15.         xmlhttp.send(xmlstr);
  16.     } else {
  17.         xmlhttp.send();
  18.     }
  19.     return xmlhttp.responsexml;
  20. }



    struts中我们扩展了action，实现了xmlstr转化成document对象（dom4j），并且完善了转发方式。如
[quote]
1.dispatchaction
     以一个controller响应一组动作绝对是controller界的真理，struts的dispatchaction同样可以做到这点。

[list]
<action path="/admin/user" name="userform" scope="request" parameter="method" validate="false">
    <forward name="list" path="/admin/userlist.jsp"/>
</action>
[/list]
    其中parameter="method" 设置了用来指定响应方法名的url参数名为method，即/admin/user.do?method=list 将调用useraction的public actionforward list(....) 函数。   

    public actionforward unspecified(....) 函数可以指定不带method方法时的默认方法。[/quote]
    但是这样需要在url后多传递参数[size=18][color=red]method=list [/color][/size]；并且action节点配置中的[color=red]parameter="method" [/color]
也没有被充分利用，反而觉得是累赘！

    因此我们直接在basedispatchaction中增加xml字符串解析，并充分利用action节点配置中的[color=red]parameter="targetmethod" [/color]，使得转发的时候，action能够直接转发到子类的相应方法中，减少了url参数传递，增强了配置信息可读性，方便团队开发。
    同样以上述为例，扩展后的配置方式如下：
[quote]
<action path="/admin/user" scope="request" [color=red]parameter="list"[/color] validate="false">
    <forward name="list" path="/admin/userlist.jsp"/>
</action>  
 [/quote]
    其中[color=red]parameter="list"[/color] 设置了用来指定响应url=/admin/user.do的方法名,它将调用useraction的public actionforward list(....) 函数。 
     basedispatchdocumentaction 的代码如下，它做了三件重要的事情：
     1、采用dom4j直接解析xml字符串，并返回document，如果没有提交xml数据，或者采用form形式提交的话，返回null；
     2、采用模版方法处理系统异常，减少了子类中无尽的try{...}catch(){...};其中异常处理部分另作描述（你可以暂时去掉异常处理，实现xml提交和解析，如果你有兴趣，我们可以进一步交流）；

     3、提供了spring配置bean的直接调用，虽然她没有注入那么优雅，但是实现了ajax、struts、spring的结合。
basedispatchdocumentaction 的源码如下：

  2. package com.ufida.haisheng.struts;
  4. import java.io.ioexception;
  5. import java.io.printwriter;
  6. import java.lang.reflect.invocationtargetexception;
  7. import java.lang.reflect.method;
  8. import java.math.bigdecimal;
  9. import java.sql.timestamp;
  10. import java.util.date;
  11. import java.util.hashmap;
  13. import javax.servlet.http.httpservletrequest;
  14. import javax.servlet.http.httpservletresponse;
  15. import javax.servlet.http.httpsession;
  17. import org.apache.commons.beanutils.convertutils;
  18. import org.apache.commons.beanutils.converters.bigdecimalconverter;
  19. import org.apache.commons.beanutils.converters.classconverter;
  20. import org.apache.commons.beanutils.converters.integerconverter;
  21. import org.apache.commons.beanutils.converters.longconverter;
  22. import org.apache.log4j.logger;
  23. import org.apache.struts.action.action;
  24. import org.apache.struts.action.actionform;
  25. import org.apache.struts.action.actionforward;
  26. import org.apache.struts.action.actionmapping;
  27. import org.apache.struts.util.messageresources;
  28. import org.dom4j.document;
  29. import org.dom4j.io.saxreader;
  30. import org.hibernate.hibernateexception;
  31. import org.springframework.beans.beansexception;
  32. import org.springframework.context.applicationcontext;
  33. import org.springframework.dao.dataaccessexception;
  34. import org.springframework.web.context.support.webapplicationcontextutils;
  36. import com.ufida.haisheng.constants.globals;
  37. import com.ufida.haisheng.converter.dateconverter;
  38. import com.ufida.haisheng.converter.timestampconverter;
  39. import com.ufida.haisheng.exp.exceptiondto;
  40. import com.ufida.haisheng.exp.exceptiondisplaydto;
  41. import com.ufida.haisheng.exp.exceptionhandler.exceptionhandlerfactory;
  42. import com.ufida.haisheng.exp.exceptionhandler.exceptionutil;
  43. import com.ufida.haisheng.exp.exceptionhandler.iexceptionhandler;
  44. import com.ufida.haisheng.exp.exceptions.baseappexception;
  45. import com.ufida.haisheng.exp.exceptions.mappingconfigexception;
  46. import com.ufida.haisheng.exp.exceptions.nosuchbeanconfigexception;
  48. /**
  49.  * 系统的ajax转发基类。增加模版处理异常信息。
  50.  * 
  51.  * @author 陈志平 chenzp
  52.  * @desc basedispatchdocumentaction.java
  53.  * 
  54.  * @说明: web 应用基础平台
  55.  * @date 2005-03-02 11:18:01 am
  56.  * @版权所有: all right reserved 2006-2008
  57.  */
  58. public abstract class basedispatchdocumentaction extends action {
  60.     protected class clazz = this.getclass();
  62.     protected static logger log = logger.getlogger(basedispatchdocumentaction.class);
  64.     /**
  65.      * 异常信息
  66.      */
  67.     protected static threadlocal<exceptiondisplaydto> 
    expdisplaydetails = new threadlocal<exceptiondisplaydto>();
  68.     
  69.     private static final long defaultlong = null;
  71.     private static applicationcontext ctx = null;
  72.     /**
  73.      * 注册转换的工具类 使得from中的string --
  74.      * model中的对应的类型(date,bigdecimal,timestamp,double...)
  75.      */
  76.     static {
  77.         convertutils.register(new classconverter(), double.class);
  78.         convertutils.register(new dateconverter(), date.class);
  79.         convertutils.register(new dateconverter(), string.class);
  80.         convertutils.register(new longconverter(defaultlong), long.class);
  81.         convertutils.register(new integerconverter(defaultlong), integer.class);
  82.         convertutils.register(new timestampconverter(), timestamp.class);
  83.         convertutils.register(new bigdecimalconverter(defaultlong), bigdecimal.class);
  84.     }
  86.     /**
  87.      * the message resources for this package.
  88.      */
  89.     protected static messageresources messages = messageresources.getmessageresources("org.apache.struts.actions.localstrings");
  91.     /**
  92.      * the set of method objects we have introspected for this class, keyed by
  93.      * method name. this collection is populated as different methods are
  94.      * called, so that introspection needs to occur only once per method name.
  95.      */
  96.     protected hashmap<string, method> methods = new hashmap<string, method>();
  98.     /**
  99.      * the set of argument type classes for the reflected method call. these are
  100.      * the same for all calls, so calculate them only once.
  101.      */
  102.     protected class[] types = { actionmapping.class, actionform.class, document.class, httpservletrequest.class,
  103.             httpservletresponse.class };
  105.     /**
  106.      * process the specified http request, and create the corresponding http
  107.      * response (or forward to another web component that will create it).
  108.      * return an <code>actionforward</code> instance describing where and how
  109.      * control should be forwarded, or <code>null</code> if the response has
  110.      * already been completed.
  111.      * 
  112.      * @param mapping
  113.      *            the actionmapping used to select this instance
  114.      * @param form
  115.      *            the optional actionform bean for this request (if any)
  116.      * @param request
  117.      *            the http request we are processing
  118.      * @param response
  119.      *            the http response we are creating
  120.      * 
  121.      * @exception exception
  122.      *                if an exception occurs
  123.      */
  124.     public actionforward execute(actionmapping mapping, actionform form, httpservletrequest request,
  125.             httpservletresponse response) throws exception {
  126.         response.setcontenttype("text/html; charset=utf-8");
  127.         exceptiondisplaydto expdto = null;
  128.         try {
  129.             document doc = createdocumentfromrequest(request);
  130.             /*
  131.              * 这里直接调用mapping的parameter配置
  132.              */
  133.             string actionmethod = mapping.getparameter();
  134.             /*
  135.              * 校验配置的方法是否正确、有效
  136.              */
  137.             isvalidmethod(actionmethod);
  139.             return dispatchmethod(mapping, form, doc, request, response, actionmethod);
  140.         } catch (baseappexception ex) {
  141.             expdto = handlerexception(request, response, ex);
  142.         } catch (exception ex) {
  143.             exceptionutil.logexception(this.getclass(), ex);
  144.             rendertext(response,"[error :对不起,系统出现错误了,请向管理员报告以下异常信息./n" + ex.getmessage() + "]");
  145.             request.setattribute(globals.errormsg, "对不起,系统出现错误了,请向管理员报告以下异常信息./n" + ex.getmessage());
  146.             expdto = handlerexception(request,response, ex);
  147.         } finally {
  148.             expdisplaydetails.set(null);
  149.         }
  150.         return null == expdto ? null : (expdto.getactionforwardname() == null ? null : mapping.findforward(expdto.getactionforwardname()));
  151.     }
  153.     /**
  154.      * 直接输出纯字符串
  155.      */
  156.     public void rendertext(httpservletresponse response, string text) {
  157.         printwriter out = null;
  158.         try {
  159.             out = response.getwriter();
  160.             response.setcontenttype("text/plain;charset=utf-8");
  161.             out.write(text);
  162.         } catch (ioexception e) {
  163.             log.error(e);
  164.         } finally {
  165.             if (out != null) {
  166.                 out.flush();
  167.                 out.close();
  168.                 out = null;
  169.             }
  170.         }
  171.     }
  172.     
  173.     /**
  174.      * 直接输出纯html
  175.      */
  176.     public void renderhtml(httpservletresponse response, string text) {
  177.         printwriter out = null;
  178.         try {
  179.             out = response.getwriter();
  180.             response.setcontenttype("text/html;charset=utf-8");
  181.             out.write(text);
  182.         } catch (ioexception e) {
  183.             log.error(e);
  184.         } finally {
  185.             if (out != null) {
  186.                 out.flush();
  187.                 out.close();
  188.                 out = null;
  189.             }
  190.         }
  191.     }
  193.     /**
  194.      * 直接输出纯xml
  195.      */
  196.     public void renderxml(httpservletresponse response, string text) {
  197.         printwriter out = null;
  198.         try {
  199.             out = response.getwriter();
  200.             response.setcontenttype("text/xml;charset=utf-8");
  201.             out.write(text);
  202.         } catch (ioexception e) {
  203.             log.error(e);
  204.         } finally {
  205.             if (out != null) {
  206.                 out.flush();
  207.                 out.close();
  208.                 out = null;
  209.             }
  210.         }
  211.     }
  213.     /**
  214.      * 异常处理
  215.      * @param request
  216.      * @param out
  217.      * @param ex
  218.      * @return exceptiondisplaydto异常描述对象
  219.      */
  220.     private exceptiondisplaydto handlerexception(httpservletrequest request,httpservletresponse response, exception ex) {
  221.         exceptiondisplaydto expdto = (exceptiondisplaydto) expdisplaydetails.get();
  222.         if (null == expdto) {            
  223.             expdto = new exceptiondisplaydto(null,this.getclass().getname());
  224.         }
  225.         iexceptionhandler exphandler = exceptionhandlerfactory.getinstance().create();
  226.         exceptiondto exdto = exphandler.handleexception(expdto.getcontext(), ex);
  227.         request.setattribute("exceptiondto", exdto);
  228.         rendertext(response,"[error:" + (exdto == null ? "exceptiondto is null,请检查expinfo.xml配置文件." : exdto.getmessagecode())
  229.                 + "]");
  230.         return expdto;
  231.     }
  233.     private void isvalidmethod(string actionmethod) throws mappingconfigexception {
  234.         if (actionmethod == null || "execute".equals(actionmethod) || "perform".equals(actionmethod)) {
  235.             log.error("[basedispatchaction->error] parameter = " + actionmethod);
  236.             expdisplaydetails.set(new exceptiondisplaydto(null, "mappingconfigexception"));
  237.             throw new mappingconfigexception("对不起,配置的方法名不能为 " + actionmethod);
  238.         }
  239.     }
  241.   /**
  242.      * 解析xml流
  243.      * @param request
  244.      * @return document对象
  245.      */
  246.     protected static document createdocumentfromrequest(httpservletrequest request) throws exception {
  247.         try {
  248.             request.setcharacterencoding("utf-8");
  249.             document document = null;
  250.             saxreader reader = new saxreader();
  251.             document = reader.read(request.getinputstream());
  252.             return document;
  253.         } catch (exception ex) {
  254.             log.warn("tips：没有提交获取xml格式数据流! ");
  255.             return null;
  256.         }
  257.     }
  259.     /**
  260.      * dispatch to the specified method.
  261.      * 
  262.      * @since struts 1.1
  263.      */
  264.     protected actionforward dispatchmethod(actionmapping mapping, actionform form, document doc,httpservletrequest request, 
    httpservletresponse response, string name) throws exception {
  265.         method method = null;
  266.         try {
  267.             method = getmethod(name);
  268.         } catch (nosuchmethodexception e) {
  269.             string message = messages.getmessage("dispatch.method", mapping.getpath(), name);
  270.             log.error(message, e);
  271.             expdisplaydetails.set(new exceptiondisplaydto(null, "mappingconfigexception"));
  272.             throw new mappingconfigexception(message, e);
  273.         }
  275.         actionforward forward = null;
  276.         try {
  277.             object args[] = { mapping, form, doc, request, response };
  278.             log.debug("[execute-begin] -> " + mapping.getpath() + "->[" + clazz.getname() + "->" + name + "]");
  279.             forward = (actionforward) method.invoke(this, args);
  280.             log.debug(" [execute-end] -> " + (null == forward ? "use ajax send to html/htm" : forward.getpath()));
  281.         } catch (classcastexception e) {
  282.             string message = messages.getmessage("dispatch.return", mapping.getpath(), name);
  283.             log.error(message, e);
  284.             throw new baseappexception(message, e);
  286.         } catch (illegalaccessexception e) {
  287.             string message = messages.getmessage("dispatch.error", mapping.getpath(), name);
  288.             log.error(message, e);
  289.             throw new baseappexception(message, e);
  291.         } catch (invocationtargetexception e) {
  292.             throwable t = e.gettargetexception();
  293.             string message = messages.getmessage("dispatch.error", mapping.getpath(), name);
  294.             throw new baseappexception(message, t);
  295.         }
  297.         return (forward);
  298.     }
  300.     /**
  301.      * introspect the current class to identify a method of the specified name
  302.      * that accepts the same parameter types as the <code>execute</code>
  303.      * method does.
  304.      * 
  305.      * @param name
  306.      *            name of the method to be introspected
  307.      * 
  308.      * @exception nosuchmethodexception
  309.      *                if no such method can be found
  310.      */
  311.     protected method getmethod(string name) throws nosuchmethodexception {
  312.         synchronized (methods) {
  313.             method method = (method) methods.get(name);
  314.             if (method == null) {
  315.                 method = clazz.getmethod(name, types);
  316.                 methods.put(name, method);
  317.             }
  318.             return (method);
  319.         }
  320.     }
  322.   /**
  323.    * 返回spring bean对象
  324.    * @param name spring bean的名称
  325.    * @exception baseappexception
  326.    */
  327.     protected object getspringbean(string name) throws baseappexception {
  328.         if (ctx == null) {
  329.             ctx = webapplicationcontextutils.getwebapplicationcontext(this.getservlet().getservletcontext());
  330.         }
  331.         object bean = null;
  332.         try {
  333.             bean = ctx.getbean(name);
  334.         } catch (beansexception ex) {
  335.             throw new nosuchbeanconfigexception("对不起,您没有配置名为:" + name + "的bean。请检查配置文件!", ex.getrootcause());
  336.         }
  337.         if (null == bean) {
  338.             throw new nosuchbeanconfigexception("对不起,您没有配置名为:" + name + "的bean。请检查配置文件!");
  339.         }
  340.         return bean;
  341.     }
  342. }


 

开发人员只需要继承它就可以了，我们写个简单的示例action，如下：

  2. /**
  3.  * 带ajax提交xml数据的action类模版
  4.  * 
  5.  * @author 陈志平 chenzp
  6.  * 
  7.  * @说明: web 应用基础平台
  8.  * @date aug 1, 2006 10:52:13 am
  9.  * @版权所有: all right reserved 2006-2008
  10.  */
  11. public class useraction extends basedispatchdocumentaction {
  12.          /**
  13.           * 这里 actionform 和 doc 参数必有一个为空，请聪明的你分析一下
  14.           * @param mapping --转发的映射对象
  15.           [color=blue]* @param actionform --仍然支持表单提交，此时doc == null
  16.           * @param doc document对象，解析xml后的文档对象[/color]
  17.           * @param request --请求
  18.           * @param response --响应
  19.           */
  20.     public actionforward list(actionmapping mapping, actionform actionform, [color=red]document doc[/color],httpservletrequest request, httpservletresponse response) throws baseappexception {
  21.         /**
  22.          * 转发的名称 useraction.search: 系统上下文 用于异常处理
  23.          */
  24.         expdisplaydetails.set(new exceptiondisplaydto(null, "useraction.search"));
  25.         /**
  26.          * 处理业务逻辑部分：
  27.          * 
  28.          * 获取各种类型的参数 requestutil.getstrparameter(request,"parametername");
  29.          * 
  30.          * 调用父类的 getspringbean("serviceid")方法获取spring的配置bean
  31.          * 
  32.          */
  33.         usermanager usermanager = (logmanager) getspringbean("usermanager");
  34.         //返回xml对象到前台
  35.         renderxml(response, usermanager.findusersbydoc(doc))；        
  36.                      return null;
  37.     }



至此，我们成功实现了ajax--struts--spring的无缝结合，下次介绍spring的开发应用。欢迎大家拍砖！

扫描关注微信公众号

© 2005-2021 漳州市福佳网络科技有限公司 版权所有 闽ICP备09012882号-3
闽公网安备 35060202000074号
福佳空间在线客服
20944024 178966803 1946551451

扫描关注微信公众号
13616026886
JAVA空间
PHP空间
域名注册