Struts2学习笔记-基础知识

分手后的思念是犯贱 2022-08-07 13:47 229阅读 0赞

1.反射机制    在运行时可以动态获取类或者对象的信息和调用对象方法的功能  
    1.java反射的三个动态特性  
        1.运行时生成对象的实例  
        2.运行期间调用方法  
        3.运行期间更改属性  
    2.通过java反射可以实现的功能  
        1.在运行时判断任意一个对象所属的类  
        2.在运行时构造任意一个类的对象  
        3.在运行时判断任意一个类所具有的属性和方法  
        4.在运行时调用任意一个类的方法  
    3.java 常用的反射API  
        1.Class            //反射的核心类  
            1.获取Class对象                Class cls=Class.forName("cn.hb.entity.Student");  
        2.Field            //类的属性  
            1.返回此对象的所有的public属性        Field\[\] fields=cls.getFields();  
            2.返回此对象声明的所有的属性        Field\[\] fields=cls.getDeclaredFields();  
        3.Constructor        //类的构造方法  
            1.返回此对象的所有的public构造函数    Constructor\[\] constructors=cls.getConstructors();  
        4.Method        //类的方法  
            1.返回此对象所有的public方法        Method\[\] methods=cls.getMethods();  
            2.返回此对象本身声明的所有方法        Method\[\] methods=cls.getDeclaredMethods();  
2.自定义构建基于MVC模型的框架            -Controller的设计  
    1.定义Action接口  
        public interface Action\{  
            public abstract String execute(HttpServletRequest request,HttpServletResponse response);  
        \}  
    2.编写实现Action接口的类  
        public class LoginAction implements Action\{  
            public String execute(HttpServletRequest request,HttpServletResponse response)\{  
                String username=request.getParameter("username");  
                String password=request.getParameter("password");  
                if("admin".equals(username) && "123".equals(password))\{  
                    return "success";  
                \}else\{  
                    return "error";  
                \}  
            \}  
        \}  
    3.编写Result类...对应struts.xml文件的结果集  
        public class Result\{  
            private String name;            //result的name属性  
            private String text;            //result的文本属性  
            private boolean iaRedirect;        //result是否为重定向的属性  
            /\*  
             \*省略相应的get和set方法  
             \*/      
        \}  
    4.编写ActionMapper类...对应元素Action的集合  
        public class ActionMapper\{  
            private String name;            //action元素的name属性  
            private String className;        //action元素对应的class属性  
            private Map<String,Result> resultMap=new HashMap<String,Result>();    //action元素对应的result集合  
            /\*  
             \*省略相应的get和set方法  
             \*/  
             public Result getResult(String name)\{        //获得结果集合中的result元素对象  
                return resultMap.get(name);  
             \}  
             public void addResult(String name,Result result)\{    //添加result元素对象到集合中  
                resultMap.put(name,result);  
             \}  
        \}  
    5.编写ActionManager类  
        public class ActionManager\{  
            //Actions元素对应的集合信息    --ActionMapper元素的集合  
            private static Map<String,ActionMapper> actionMap=new HashMap<String,ActionMapper>();  
            public ActionMapping(String\[\] xmlpaths)\{            //同事解析多个xml配置文件  
                for(String string:xmlpaths)\{  
                    init(string);  
                \}  
            \}  
            //解析xml配置文件  
            public void init(String xmlpath)\{  
                InputStream inputStream=this.getClass().getResourceAsStream("/"+xmlpath);  
                SAXReader reader=new SAXReader();  
                //进行XML文件的头部验证  
                reader.setEntityResolver(new EntityResolver() \{  
//                    @Override  
//                    public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException \{  
//                        // TODO Auto-generated method stub  
//                        String pid="-//http://www.502829204.com";  
//                        String sid="-http://www.123.com/Struts.dtd";  
//                        if(!pid.equals(publicId))\{  
//                            throw new SAXException("PID文件头错误");  
//                        \}  
//                        if(!sid.equals(systemId))\{  
//                            throw new SAXException("SID文件头错误");  
//                        \}  
//                        return new InputSource(this.getClass().getResourceAsStream(systemId.substring(systemId.lastIndexOf("/"))));  
//                    \}  
//                \});  
                Doucment document=reader.read(inputStream);  
                Element root=document.getRootElement();  
                List<Element> list=((Element)(root.elements().iterator().next())).elements();  
                for(Element element:list)\{  
                    ActionMapper am=new ActionMapper();        //新建ActionMapper实例  
                    String name=element.attributeValue("name");    //获得action的name属性值  
                    String className=element.attributeValue("class");//获得action的class属性值  
                    am.setName(name);  
                    am.setClassName(className);  
                    List<Element> list2=element.elements();  
                    for(Element element2:list2)\{  
                        Result result=new Result();        //创建result元素对象  
                        String name=element2.attributeValue("name");    //获得result元素的name属性  
                        boolean isRedirect=Boolean.parseBoolean(elements.attributeValue("redirect"));  
                        String text=element2.getText();        //获得元素的文本值  
                        result.setName(name);  
                        result.setText(text);  
                        result.setIsRedirect(isRedirect)        //判断是否为重定向  
                        am.addResult(name,result);            //将result元素加入到ActionMapper的Result集合中  
                    \}  
                    actionMap.put(am.getName(),am);            //将ActionMapper对象加入到ActionManager的ActionMapper集合中  
                \}  
            \}  
            //通过给定的name属性值.获得对应的action元素对象  
            public ActionMapper getActionMapper(String name)\{  
                if(name==null)\{  
                    return null;  
                \}  
                ActionMapper actionMapper=actionMap.get(name);  
                if(actionMapper==null)\{  
                    throw new Exception("该集合中的元素为空");  
                \}  
                return actionMapper;  
            \}  
        \}  
    6.编写ActionFilter类实现Filter构建触发器  
        public classActionFilter implements Filter\{  
            private ActionManager actionManager;  
            //Filter的初始化  
            public void init(FilterConfig confg) throws Exception\{  
                String xmls=confg.getInitParameter("configuration");  
                String\[\] xml=null;  
                if(xmls==null)\{  
                    xml=new String\[\]\{"struts.xml"\};  
                \}else\{  
                    xml=xmls.split(",");  
                \}  
                actionManager=new Actionmanager(xml);  
            \}  
            //Filter的触发执行  
            public void doFilter(ServleRequest arg0,ServleResponse arg1,FilterChain arg2)\{  
                HttpServletRequest request=(HttpServletRequest)arg0;  
                HttpServletResponse response=(HttpServletResponse)arg1;  
                String uri=request.getRequestURI();  
                String name=uri.substring(uri.lastIndexOf("/")+1,uri.length()-7);  
                ActionMapper actionMapper=actionManager.getActionMappper(name);  
                String className=actionMapper.getClassName();  
                Class cls=Class.forName(className);  
                if(cls!=null)\{  
                    Action action=(Action)cls.newIntance();  
                    String type=action.execute(request,response);  
                    Result result=actionMapper.getResult(type);  
                    String JSPURL=result.getText();  
                    if(result.isRedirect())\{  
                        response.sendRedirect(JSPURL);  
                    \}else\{  
                        request.getRequestDispatcher(JSPURL).forward(request,response);  
                    \}  
                \}  
            \}  
            //Filter的销毁  
            public void destroy()\{  
                  
            \}  
        \}  
    7.编写struts.xml文件  
        <mystruts>  
            <actions>  
                <action name="login" class="cn.struts.action.LoginAction">  
                    <result name="success">success.jsp</result>  
                    <result name="error" redirect="true">error.jsp</result>  
                </action>  
            </actions>  
        </mystruts>  
    8.web.xml文件的配置    --针对于Filter的配置  
        <filter>  
            <filter-name>ActionFilter</filter-name>  
            <filter-class>cn.struts.filter.ActionFilter</filter-class>  
            <init-param>  
                <param-name>configuration</param-name>  
                  <param-value>struts.xml</param-value>  
            <init-param>  
        </filter>  
        <filter-mapping>  
            <filter-name>ActionFilter<filter-name>  
            <url-pattern>\*.action</utl-pattern>  
            <dispatcher>REQUEST</dispatcher>  
            <dispatcher>FORWARD</dispatcher>  
            <dispatcher>ERROR</dispatcher>  
            <dispatcher>INCLUDE</dispatcher>  
        </filter-mapping>  
3.创建struts的步骤  
    1.创建jsp页面  
        1.Struts标签主要分为两大类      
            标签库的导入    <%@ taglib uri="/struts-tag" prefix="s" %>  
            1.UI标签  
                1.表单标签  
                    1.<s:form></s:form>        对应相应的form值  
                    2.<s:textfile></s:textfile>    文本输入框  
                    3.<s:textarea></s:textarea>    文本域输入框  
                    4.<s:password></s:password>    密码输入框  
                    5.<s:radio></s:radio>        单选按钮  
                    6.<s:checkbox></s:checkbox>    复选框  
                    7.<s:submit></s:submit>        提交标签  
                    8.<s:reset></s:reset>        重置标签  
                    9:<s:hidden></s:hidden>        隐藏域标签  
                2.非表单表单标签  
                    1:<s:fielderror></s:fielderror>        //校验信息的输出  
                    2.<s:property value=""></s:property>    //对指定值的输出  
                3.Ajax标签  
            2.通用标签  
                1.条件标签  
                    1.<s:if test=""></s:if>              
                    2.<s:elseif test=""></s:elseif>  
                    3.<s:else test=""></s:else>  
                2迭代标签  
                    1.<s:iterator value="list" id="user" status="i">  
                        <s:property value="username"></s:property>  
                            <s:property value="\#i.index"></s:property>        //获得当前遍历的索引值  
                            <s:property value="\#name.username"></s:property>    //获得当前遍历的对象的某个属性  
                    </s:iterator>  
    2.创建Action实现类  
        1.struts2访问Servlet API的方式  
            1.与servlet API解耦的访问方式  
                1.使用ActionContext类获得Servlet API对象对应的Map对象  
                    1.获得HttpServletRequest        actionContext.get("request");  
                    2.获得HttpSession            actionContext.getSession();  
                    3.获得ServletContext            actionContext.getApplication();  
                2.使用struts2 向Action注入Servlet API的方式  
                    1.注入HttpServletRequest对象        实现RequestAware接口  
                    2.注入HttpSession对象            实现SessionAware接口  
                    3.注入ServletContext对象        实现ApplicationAware接口  
            2.与servlet API耦合的访问方式  
                1.使用ServletActionContext类获得Servlet API对象对应的Map对象  
                    1.获得HttpServletRequest        actionContext.getRequest();  
                    2.获得HttpServletResponse        actionContext.getResponse();  
                    3.获得ServletContext            actionContext.getServletContext();  
                2.使用struts2 向Action注入Servlet API的方式  
                    1.注入HttpServletRequest对象        实现ServletRequestAware接口  
                    2.注入HttpSession对象            实现ServletSessionAware接口  
                    3.注入ServletContext对象        实现ServletContextAware接口  
    3.修改项目配置的web.xml  
        <filter>  
            <filter-name>Struts2</filter-name>  
            <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>  
        </filter>  
        <filter-mapping>  
            <filter-name>Struts2</filter-name>  
            <url-pattern>/\*</url-pattern>  
            <dispather>REQUEST</dispatcher>  
            <dispather>FORWARD</dispatcher>  
        </filter-mapping>  
    4.创建struts的配置文件struts.xml  
        <constant name="struts.ui.theme" value="simple"></constant>    //设置用户界面主题风格.默认为XHTML  
        <constant name="struts.i18n.encoding" value="UTF-8"></constant>    //设置当前struts的界面编码 默认为UTF-8  
        <constant name="struts.enable.DynamicMethodInvocation" value="false"></constant>//禁止调用动态的方法  
        <constant name="struts.custom.i18n.resources" value="message"></costant>  
    5.编译部署并启动服务器  
4.动态配置struts.xml中的action的方法  
    1.在action元素中添加method的方法  
        <action name="login" class="cn.struts.action.LoginAction" method="login">  
            <result></result>  
        </action>  
        <action name="login" class="cn.struts.action.LoginAction" method="regist">  
            <result></result>  
        </action>  
    2.在jsp页面使用动态的action标注  
        <action name="user" class="cn.struts.action.LoginAction">  
            <result name="success">success.jsp</result>  
            <result name="error">error.jsp</result>  
            <result name="input">input.jsp</result>  
        </action>  
    ------在JSP页面的标注  
        <s:form action="user!login.action"></s:form>  
    3.使用通配符来动态加载Action类  
        <action name="\*" class="cn.struts.action.LoginAction" method="\{1\}">  
            <result name="success">success.jsp</result>  
            <result name="error">error.jsp</result>  
            <result name="input">\{1\}.jsp</result>  
        </action>  
    4.配置默认的Action    --实现无法找到Action出现的404问题  
        <default-action-ref name="default"></default-action-ref>  
        <action name="default">  
            <result>notfound.jsp</result>  
        </action>  
    5.全局的结果设置  
        <global-results>  
            <result name="error">error.jsp</result>  
            <result name="success">success.jsp</result>  
        </global-results>  
    6.result转发的配置 ---type="dispatcher" type="redirect" type="redirectAction"  
        <action name="login" class="cn.struts.action.LoginAction">  
            <result name="input">login.jsp</result>  
            <result name="success" type="redirectAction">$\{comman\}</result>  
        </action>  
5.拦截器和文件的上传下载  
    1.拦截器中相关的一些主要对象  
        1.ActionMapper        提供了在请求和Action调用请求之间的映射,ActionMapper根据请求的URL的信息.来查找是否存在对应的Action请求  
        2.ActionMapping        保存了调用Action的映射信息.包括Action的name和class  
        3.ActionProxy        在XWork和真正的Action之间充当代理.ActionProxy创建了ActionInvocation对象  
        4.ActionInvocation    表示Action的执行状态,它保存拦截器的先后顺序,Action实例  
        5.Interceptor        在请求处理之前和处理之后执行的Struts2组件  
    2.拦截器的三个阶段  
        1.做一些Action执行前的预处理  
        2.调用ActionInvocation的invoke()方法将控制转交给后序的拦截器或者返回结果字符串并终止执行  
        3.做一些Action处理后的处理  
    3.基本的内置拦截器  
        1.params拦截器            将请求的数据设置到Action的属性上  
        2.staticParams拦截器        将action元素的param子元素的值设置到Action的属性上  
        3.servletConfig拦截器        将Servlet API对象注入到Action的当中的简洁方法  
        4.fileUpload拦截器        文件上传的拦截器,将文件和元素从多请求(multipart/form-data)转换为常规的请求数据  
        5.validation拦截器        执行数据的校验  
        6.workflow拦截器        提供数据校验错误时终止流程的功能  
        7.exception拦截器        捕获异常.并将相对应的异常映射到用户指定的页面  
    4.自定义拦截器  
        public class MyInterceptor extends AbstractInterceptor\{  
                public String intercept(ActionInvocation invocation)\{  
                    //获得Session对象  
                    Map session=invocation.getInvocationContext().getSession();  
                    //获得拦截器当前的转入名称  
                    String url=invocation.getInvocationContext().getName();  
                    if("loginuser".equals(url))\{                //用此方法来拦截是否已经登录  
                        return invocation.invoke();  
                    \}else\{      
                        User user=(User)session.get("user");  
                        if(user==null)\{  
                            return Action.LOGIN;  
                        \}else\{  
                            return invocation.invoke();  
                        \}  
                    \}  
                \}  
            \}  
    5.拦截器的配置和使用  
        1.通过<interceptor name=""></interceptor>来定义拦截器  
            <interceptors>  
                //当前自定义拦截器的声明  
                <intterceptor name="myInterceptor" class="cn.struts.interceptor.MyInterceptor"></interceptor>  
                <interceptor-stack>  
                    <interceptor-ref name="myInterceptor"></interceptor-ref>  
                    <interceptor-ref name="defaultStack"></interceptor-ref>  
                </interceptor-stack>  
            </interceptors>  
        2.通过<interceptor-ref></interceptor-ref>元素来使用拦截器  
        <package>  
            <action name="user" class="cn.struts.action.UserAction">  
                <result name="success">success.jsp</result>  
                //对自定义拦截器的引用   ---当只对自定义拦截器引用的时候还要引用默认的拦截器栈defaultStack  
                <interceptor-ref name="myInterceptor"></interceptor-ref>  
                <interceptor-ref name="defaultStack"></interceptor-ref>  
                //对自定义拦截器栈的引用  
                <interceptor-ref name="myStack"></interceptor-ref>      
            </action>  
        </package>  
    6.实现文件  /  多文件的上传  
        1.上传的页面  
            <s:form action="upload.action" method="post" enctype="multipart/form-data">  
                <s:textfield name="title" label="标题"></s:textfield>  
                <s:file name="upload" label="选择文件"></s:file>  
                <s:submit value="点击上传"></s:submit>  
            </s:form>  
        2.上传的Action  
            public class UploadAction extends ActionSupport\{  
                private String title;                    //上传文件的标题    //当有多个文件:String\[\] title;  
                private File upload;                    //上传的文件        //当有多个文件:File\[\] upload  
                private String uploadContentType;            //上传的文件的类型    //当有多个文件:String\[\] uploadContentType;  
                private String uploadFileName;                //上传的文件的名称    //当有多个文件:String\[\] uploadFileName  
                private String savePath;                //保存的路径          
                /\* 省略相关的get set方法 \*/  
                public String execute()\{  
                    //获得保存的路径  
                    savePath=ServletActionContext.getServletContext().getRealPath(savePath);  
                    byte\[\] bt=new byte\[1024\];  
                    int length=0;  
                    //当同时上传多个文件  可以利用循环for(int i=0;i<upload.length;i++)\{\}  
                    InputStream inputStream=new FileInputStream(upload);        //获得选定文件的输入流        //多个的时候:upload\[i\]  
                    OutputStream outputStream=new FileOutputStream(savePath+"\\\\"+uploadFileName);            //多个的时候:uploadFileName\[i\]  
                    while((length=inputStream.read(bt))!=-1)\{  
                        outputStream.write(bt,0,length);  
                    \}  
                    inputStream.close();  
                    outputStream.close();  
                    //使用FileUtils  
                    FileUtils.copyFile(upload,new File(savePath+"\\\\"+uploadFileName));  
                    return SUCCESS;  
                \}  
            \}  
        3.struts.xml文件的配置  
            <action name="upload" class="cn.struts.action.UploadAction">  
                <param name="savePath">/upload</param>  
                <interceptor-ref name="fileUpload">  
                    //设置允许上传的文件的类型  
                    <param name="allowedTypes">image/bmp,image/png,image/gif,image/jpeg</param>  
                    //允许上传的文件的大小  
                    <param name="maximumSize">1024</param>  
                </interceptor-ref>  
                <interceptor-ref name="defaultStack"></interceptor-ref>  
                <result name="input">/global/error.jsp</result>  
            </action>  
    7.实现文件的下载  
        1.下载页面  
            <a href="download.action?fileName=a.jpg">点击下载</a>  
        2.下载的Action类  
            public class DownloadAction extends ActionSupport\{  
                private String inputPath;        //文件的下载路径  
                private String fileName;        //文件的名称  
                private InputStream inputStream;    //输入流  
                  
                public String execute()\{  
                    String path=ServletActionContext.getServletContext().getRealPath(inputPath);  
                    //中文转码---解决乱码问题  --可以写在setFileName()里面  
                    fileName=new String(fileName.getBytes("ISO-8859-1"),"UTF-8");  
                    URLEncoder.encode(fileName, "UTF-8");  
                    URLDecoder.decode(fileName, "UTF-8");  
                    inputStream=new BufferedInputStream(new FileInputStream(path+"\\\\"+fileName));  
                    //中文转码---解决乱码问题  --可以写在getFileName()里面  
                    fileName=new String(fileName.getBytes("UTF-8"),"ISO-8859-1");  
                    return SUCCESS;  
                \}  
            \}  
        3.struts.xml文件的配置  
            <action name="download" class="cn.struts.action.DownloadAction">  
                <param name="inputPath">/upload</param>  
                <result name="success" type="stream">  
                    <param name="contentType">application/octet-stream</param>  
                    <param name="inputName">inputStream</param>  
                    <param name="contentDisposition">attachment;fileName="$\{fileName\}"</param>  
                    <param name="bufferSize">4096</param>  
                </result>  
            </action>  
6.OGNL对象导航图语言                Object Graph Navigation Language  
    1.OGNL在Struts框架中做的主要作用        取代页面的java脚本,简化数据的访问操作      
        1.表达式语言  
        2.类型转换器  
    2.自定义转换器  
        1.创建自定义转换器    继承StrutsTypeConvert类...  
            1.重写public Object convertFromString(Map context,String\[\] values,Class ToType)\{\}  
            2.重写public String convertToString(Map context,Object object)\{\};  
            public class DateConvert extends StrutsTypeConvert\{  
                private Date\[\] date=\{new SimpleDateFormat("yyyy-MM-dd"),  
                            new SimpleDateFormat("yyyyMMdd"),  
                            new SimpleDateFormat("yyyy/MM/dd"),  
                            new SimpleDateFormat("yyyy年MM月dd日")\};  
                //将字符串转换为对象的方法  
                public Object convertFromString(Map context,String\[\] values,Class toType)\{  
                    String str=values\[0\]l  
                    for(int i=0;i<date.length;i++)\{  
                        try\{  
                            return date\[i\].parse(str);  
                        \}catch(Exception e)\{  
                            continue;  
                        \}  
                    \}  
                    throw new TypeConversionException();  
                \}  
                //将对象转换位字符串的方法  
                public String convertToString(Map context,Object object)\{  
                    Date date=(Date)object;  
                    return new SimpleDateFormat("yyyy-MM-dd").format(date);  
                \}  
            \}  
        2.配置自定义转换器      
            1.全局转换器    src目录下创建        xwork-conversion.properties        java.util.Date=cn.struts.convert.DateConvert  
            2.局部转换器    Action目录下创建    StudentAction-conversion.properties    student.date=cn.struts.convert.DateConvert  
        3.处理类型转换错误  
            1.前提条件    启动拦截器.继承struts-default包...<interceptor-ref name="defaultStack"></interceptor-ref>  
            2.实现ValidationAware接口或者继承ActionSupport类  
            3.创建input结果映射  
            4.在页面使用<s:fielderror></s:fielderror>来显示错误  
            5.修改所有类型的转换错误信息  
                1.在struts.xml文件创建常量    <constrant name="struts.custom.i18n.resources" value="message"></constant>  
                2.在src目录下创建message.properties    xwork.default.invalid.fieldvalue=字段"\{0\}"的属性值无效  
            6.修改指定类型的转换错误信息  
                1.在当前的Action的目录下面创建StudentAction.properties    invalid.fieldvalue.date=日期转换类型错误  
7.Struts2的校验框架  
    1.Struts2内置的校验器  
        1.必填校验器            required  
            1.<param name="trim">true</param>  
        2.必填字符串校验器        requiredstring  
            1.<param name="trim">true</param>  
        3.整数校验器            int  
            1.<param name="min">20</param>  
            2.<param name="max">80</param>  
        4.字符串长度校验器        stringlength  
            1.<param name="minLength">6</param>  
            2.<param name="maxLength">15</param>  
        5.正则表达式校验器        regex  
            1.<param name="regex">^\\d\{10\}$</param>  
        6.字段表达式校验器        fieldexpression  
            1.<param name="expression">password==repassword</param>  
        7.日期校验器            date  
        8.双精度校验器            double      
    2.验证框架的使用步骤  
        1.创建Action类继承ActionSupport类  
            public class StudentAction extends ActionSupport\{  
                private Student student;        //学生对象  
                private String repassword;        //确认密码  
                //省略get set方法  
                public String regist()\{  
                    return SUCCESS;  
                \}  
            \}  
        2.在struts.xml文件中配置action  
            <constant name="struts.custom.i18n.resources" value="message"></constant>  
            <package>  
                <default-action-ref name="default"></default-action-ref>  
                <global-results>  
                    <result name="success">/global/success.jsp</result>  
                    <result name="error">/global/error.jsp</result>  
                </global-results>  
                <action name="default">  
                    <result>/global/notfound.jsp</result>  
                </action>  
                <action name="\*Student" class="cn.struts.action.StudentAction" method="\{1\}">  
                    <result name="input">studentregist.jsp</result>  
                </action>  
            <package>  
        3.创建jsp页面  
            <s:form action="registStudent.action" method="post">  
                <table>  
                    <tr>  
                        <td><s:text name="username"></s:text>:</td>  
                        <td><s:textfield name="student.username"></s:textfield></td>  
                        <td><s:fielderror fieldName="student.username"></s:fielderror></td>  
                    </tr>  
                    <tr>........</tr>  
                    <tr><td><s:submit value="%\{getText('submit')\}"></s:submit></td></tr>  
                </table>  
            </s:form>  
        4.编写验证文件和验证规则  
            <validators>  
                <field name="student.username">  
                    <field-validator type="requiredstring">  
                        <param name="trim">true</param>  
                        <message key="username.null"></message>    //当无需国际化时候.元素text直接可以写错误消息提示:用户名不能为空  
                    </field-validator>  
                    <field-validator type="stringlength">  
                        <param name="minLength">6</param>  
                        <param name="maxLength">15</param>  
                        <message key="username.length"></message>//当无需国际化时候:用户名长度在$\{minLenght\}和$\{maxLength\}之间  
                    </field-validator>  
                </field>  
            </validators>          
        5.创建国际化文件  
            1.默认的格式文件        message.properties  
            2.英文格式文件            message\_en.properties  
            3.中文香港格式文件        message\_zh\_HK.properties  
                page.title=注册首页  
                page.info=新用户注册  
                username=用户名  
                user.null=用户名不能为空  
                user.length=用户名的长度在$\{minLenght\}和$\{maxLength\}之间  
                password=密码  
                .......  
                email.regex=email的格式不正确  
                repassword.same=两次输入的密码不一致