struts常用扩展

            用户验证,错误异常处理,这个看似小事,但有时候处理也比较麻烦,随时有可能处理不好!

            一,用户验证处理

• 通过自定义标签直接添加在需要用户验证的页面 
• 通过覆盖struts 的RequestProcessor的processRole(),从而获得用户验证功能.
• 通过编写一个Action验证基类,子类继承而获得用户验证功能.

        1)自定义标签实现验证

java 代码

1. public final  class CheckLogin extends TagSupport{   
2.     
3.         public int doStartTag() throws JspException{   
4.                
5.              return (SKIP_BODY);   
6.     }   
7.       
8.        public int doEndTag() extends JspException{   
9.               
10.             HttpSession session=pageContext.getSession();   
11.             String userName=sesssion.getAttribute("USERNAME");   
12.             if(userName==null){   
13.                    pageContext.forward("xxxxx.jsp") ; //错误页面   
14.                    return (SKIP_PAGE);   
15.             }   
16.             return (EVAL_PAGE);   
17.    }   

        2)struts 的RequestProcessor的processRole(),从而获得用户验证功能

java 代码

1. protected boolean processRoles (ActionMapping mapping,   
2.                                     ActionForm form,    
3.                                     HttpServletRequest request,    
4.                                     HttpServletResponse response)   
5.                                     throws IOException, ServletException{   
6.   
7.          HttpSession session=request.getSession();   
8.          String userName=session.getAttribute("USERNAME");   
9.          if(userName==null){   
10.                 RequestDispatcher rd=request.getDispathcher("XXXX.jsp");//返回错误页面  
11.                 rd.forward(request,response);
12.                 return false;   
13.         }   
14.         return true;   
15. }  

       3)编写一个Action验证基类,子类继承而获得用户验证功能.

java 代码

1. public abstract class CheckBaseAction extends Action{   
2.              
3.        public final ActionForward execute(ActionMapping mapping,   
4.                                     ActionForm form,    
5.                                     HttpServletRequest request,    
6.                                     HttpServletResponse response)   
7.                                     throws IOException, ServletException {    
8.               
9.                 HttpSession session=request.getSession();   
10.                 String userName=session.getAttribute("USERNAME");   
11.                 if(userName==null){   
12.                          return (mapping.findForward("login"));   
13.                }   
14.                 return doExecute(mapping,request,response);   
15.     }   
16.   
17.       public abstract  ActionForward doExecute(ActionMapping mapping,   
18.                                     ActionForm form,    
19.                                     HttpServletRequest request,    
20.                                     HttpServletResponse response)   
21.                                     throws IOException, ServletException ;   
22.   
23. }   

       第三种灵活性比前2种强点,但与struts耦合比较强,或者可以使用另一种filter来实现用户检验也不错的选择!

       二.异常处理

•   通过Servlet异常处理,只要简单地在Web.xml里配置异常处理类型和返回页面
•   通过Struts的异常处理机制,在struts-config.xml配置局部异常和全局异常
•   通过编写一个Action 异常基类,子类继承而获得异常处理功能

         1) Servlet异常处理

xml 代码

1. <error-page>  
2.    <error-code>404error-code>  
3.    <location>XXX.jsplocation>   
4. error-page>  
5.   
6. <error-page>  
7.     <exception-type>java.lang.NullPointerExceptionexception-type>  
8.     <location>XXX.jsplocation>   
9. error-page>  
10.   

        2)Struts的异常处理机制,在struts-config.xml配置局部异常和全局异常

xml 代码

1.   
2.    <global-exceptions>  
3.             <exception type="java.lang.exception"       
4.                                key="action.errors.exception"      
5.                                path="/error.jsp"/>  
6.    global-exceptions>  
7.   
8.   
9.     <action-mappings>  
10.             <action path="/Login"    
11.                           type="cn.com.sqicoo.LoginAction"  
12.                           name="LoginForm"  
13.                           input="/login.jsp">  
14.            <exception type="java.lang.exception"       
15.                                key="action.errors.exception"  >  
16.            <forward name="success" path="/login_success.jsp"/>  
17.             action>  
18.     action-mappings>  

        3)编写一个Action 异常基类,子类继承而获得异常处理功能

java 代码

1. public abstract class ErrorBaseAction extends Action{      
2.                 
3.        public final ActionForward execute(ActionMapping mapping,      
4.                                     ActionForm form,       
5.                                     HttpServletRequest request,       
6.                                     HttpServletResponse response)      
7.                                     throws IOException, ServletException {       
8.               try{   
9.                      return doExecute(mapping,form,request,response);   
10.               }catch(Exception ex){   
11.                      return doException(ex,mapping,form,request,response);   
12.               }   
13.     }      
14.      
15.       public  ActionForward doException(Exception ex,   
16.                                     ActionMapping mapping,      
17.                                     ActionForm form,       
18.                                     HttpServletRequest request,       
19.                                     HttpServletResponse response)      
20.                                     throws IOException, ServletException {       
21.                  // 异常处理   
22.                   return mapping.findForward("XXX");//返回页面   
23.       }   
24.   
25.        public abstract  ActionForward doExecute(ActionMapping mapping,      
26.                                     ActionForm form,       
27.                                     HttpServletRequest request,       
28.                                     HttpServletResponse response)      
29.                                     throws IOException, ServletException;   
30.      
31. }