<rt id="bn8ez"></rt>
<label id="bn8ez"></label>
  • 

    • <span id="bn8ez"></span>
    

    <label id="bn8ez"><meter id="bn8ez"></meter></label>
    

    
    

    




    







												


        

    
	

    
	
    
		
    
			
				
    積少成多
    
				
    垃圾堆
    
			    		
		
    
	
    

    

    
	
    
		
    
			
				
 
BlogJava ::
首頁 ::
聯(lián)系 ::
聚合
 ::
管理

			
			
			
				

	
    
		
    
			
			
			
				 
				29 
				Posts ::
				1 Stories
				::
				5 Comments
				::
				0 Trackbacks
			
		
    
	
    

			    		
		
    
	
    

    


    

    
	
    
	
					

    
			
	
	
    
		
    http://www.iteye.com/topic/72170

    關于j2ee項目中異常的管理和設計。之前一直困惑于異常的處理，為什么異常分為checked和uncheck，應該遵循怎樣的規(guī)則自定義異常。在j2ee項目中，處理異常需要注意什么地方。
    [原文]
    為什么要在J2EE項目中談異常處理呢？可能許多java初學者都想說：“異常處理不就是try….catch…finally嗎？這誰都會 啊！”。筆者在初學java時也是這樣認為的。如何在一個多層的j2ee項目中定義相應的異常類？在項目中的每一層如何進行異常處理？異常何時被拋出？異 常何時被記錄？異常該怎么記錄？何時需要把checked Exception轉化成unchecked Exception  ，何時需要把unChecked Exception轉化成checked  Exception?異常是否應該呈現(xiàn)到前端頁面？如何設計一個異常框架？本文將就這些問題進行探討。 
    1． JAVA異常處理
     
    在面向過程式的編程語言中，我們可以通過返回值來確定方法是否正常執(zhí)行。比如在一個c語言編寫的程序中，如果方法正確的執(zhí)行則返回1.錯誤則返回0。在vb或delphi開發(fā)的應用程序中，出現(xiàn)錯誤時，我們就彈出一個消息框給用戶。
     
    通過方法的返回值我們并不能獲得錯誤的詳細信息。可能因為方法由不同的程序員編寫，當同一類錯誤在不同的方法出現(xiàn)時，返回的結果和錯誤信息并不一致。
     
    所以java語言采取了一個統(tǒng)一的異常處理機制。
     
    什么是異常？運行時發(fā)生的可被捕獲和處理的錯誤。
     
    在java語言中，Exception是所有異常的父類。任何異常都擴 展于Exception類。Exception就相當于一個錯誤類型。如果要定義一個新的錯誤類型就擴展一個新的Exception子類。采用異常的好處 還在于可以精確的定位到導致程序出錯的源代碼位置,并獲得詳細的錯誤信息。
     
    Java異常處理通過五個關鍵字來實 現(xiàn)，try,catch,throw ,throws,  finally。具體的異常處理結構由try….catch….finally塊來實現(xiàn)。try塊存放可能出現(xiàn)異常的java語句，catch用來捕獲發(fā) 生的異常，并對異常進行處理。Finally塊用來清除程序中未釋放的資源。不管理try塊的代碼如何返回，finally塊都總是被執(zhí)行。
     
    一個典型的異常處理代碼
     
     
    java 代碼
     
    1.    
    2. public String getPassword(String userId)throws DataAccessException{    
    3. String sql = “select password from userinfo where userid=’”+userId +”’”;    
    4. String password = null;    
    5. Connection con = null;    
    6. Statement s = null;    
    7. ResultSet rs = null;    
    8. try{    
    9.  con = getConnection();//獲得數(shù)據(jù)連接    
    10.  s = con.createStatement();    
    11.  rs = s.executeQuery(sql);    
    12.  while(rs.next()){    
    13.     password = rs.getString(1);    
    14.  }    
    15.  rs.close();    
    16.  s.close();    
    17.       
    18. }    
    19. Catch(SqlException ex){    
    20.  throw new DataAccessException(ex);    
    21. }    
    22. finally{    
    23.  try{    
    24.       if(con != null){    
    25.         con.close();    
    26.       }    
    27.  }    
    28.    Catch(SQLException sqlEx){    
    29.      throw new DataAccessException(“關閉連接失敗!”,sqlEx);    
    30.    }    
    31. }    
    32. return password;    
    33. }    
    34.     
     
     
    可以看出Java的異常處理機制具有的優(yōu)勢：
     
    給錯誤進行了統(tǒng)一的分類，通過擴展Exception類或其子類來實現(xiàn)。從而避免了相同的錯誤可能在不同的方法中具有不同的錯誤信息。在不同的方法中出現(xiàn)相同的錯誤時，只需要throw 相同的異常對象即可。
     
    獲得更為詳細的錯誤信息。通過異常類，可以給異常更為詳細，對用戶更為有用的錯誤信息。以便于用戶進行跟蹤和調試程序。
     
    把正確的返回結果與錯誤信息分離。降低了程序的復雜度。調用者無需要對返回結果進行更多的了解。
     
    強制調用者進行異常處理，提高程序的質量。當一個方法聲明需要拋出一個異常時，那么調用者必須使用try….catch塊對異常進行處理。當然調用者也可以讓異常繼續(xù)往上一層拋出。
     
     
     
    2． Checked 異常 還是 unChecked 異常？
     
    Java異常分為兩大類:checked 異常和unChecked 異常。所有繼承java.lang.Exception 的異常都屬于checked異常。所有繼承java.lang.RuntimeException的異常都屬于unChecked異常。
     
    當一個方法去調用一個可能拋出checked異常的方法，必須通過try…catch塊對異常進行捕獲進行處理或者重新拋出。
     
    我們看看Connection接口的createStatement()方法的聲明。
     
    public Statement createStatement() throws SQLException;
     
           
     
       SQLException是checked異常。當調用createStatement方法時，java強制調用者必須對SQLException進行捕獲處理。
     
     
    java 代碼
     
    1.        public String getPassword(String userId){    
    2.        try{    
    3.        ……    
    4.               Statement s = con.createStatement();    
    5.               ……    
    6.        Catch(SQLException sqlEx){    
    7.               ……    
    8.    }    
    9. ……    
    10. }    
     或者
     
     
    java 代碼
     
    1. public String getPassword(String userId)throws SQLException{    
    2.    Statement s = con.createStatement();    
    3. }   
     
     
    (當然，像Connection,Satement這些資源是需要及時關閉的，這里僅是為了說明checked 異常必須強制調用者進行捕獲或繼續(xù)拋出)
     
     
     
    unChecked異常也稱為運行時異常，通常 RuntimeException都表示用戶無法恢復的異常，如無法獲得數(shù)據(jù)庫連接，不能打開文件等。雖然用戶也可以像處理checked異常一樣捕獲 unChecked異常。但是如果調用者并沒有去捕獲unChecked異常時，編譯器并不會強制你那么做。
     
     
     
    比如一個把字符轉換為整型數(shù)值的代碼如下：
     
     
     
     
    java 代碼
     
    1. String str = “123”;    
    2. int value = Integer.parseInt(str);   
     
     
     
     
    parseInt的方法簽名為：
     
     
    java 代碼
     
    1. public static int parseInt(String s) throws NumberFormatException   
     
     
     
     
    當傳入的參數(shù)不能轉換成相應的整數(shù)時，將會拋出NumberFormatException。因為NumberFormatException擴展于RuntimeException，是unChecked異常。所以調用parseInt方法時無需要try…catch
     
     
     
    因為java不強制調用者對unChecked異常進行捕獲或往上拋 出。所以程序員總是喜歡拋出unChecked異常?；蛘弋斝枰粋€新的異常類時，總是習慣的從RuntimeException擴展。當你去調用它些方 法時，如果沒有相應的catch塊，編譯器也總是讓你通過,同時你也根本無需要去了解這個方法倒底會拋出什么異常?？雌饋磉@似乎倒是一個很好的辦法，但是 這樣做卻是遠離了java異常處理的真實意圖。并且對調用你這個類的程序員帶來誤導，因為調用者根本不知道需要在什么情況下處理異常。而checked異 ?？梢悦鞔_的告訴調用者，調用這個類需要處理什么異常。如果調用者不去處理，編譯器都會提示并且是無法編譯通過的。當然怎么處理是由調用者自己去決定的。
     
     
     
           所以Java推薦人們在應用代碼中應該使用checked異常。就像我們在上節(jié)提到運用異常的好外在于可以強制調用者必須對將會產生的異常進行處理。包括在《java Tutorial》等java官方文檔中都把checked異常作為標準用法。
     
           使用checked異常，應意味著有許多的try…catch在你的代碼中。當在編寫和處理越來越多的try…catch塊之后，許多人終于開始懷疑checked異常倒底是否應該作為標準用法了。
     
    甚至連大名鼎鼎的《thinking in java》的作者Bruce Eckel也改變了他曾經的想法。Bruce  Eckel甚至主張把unChecked異常作為標準用法。并發(fā)表文章，以試驗checked異常是否應該從java中去掉。Bruce  Eckel語：“當少量代碼時，checked異常無疑是十分優(yōu)雅的構思，并有助于避免了許多潛在的錯誤。但是經驗表明，對大量代碼來說結果正好相反”
     
    關于checked異常和unChecked異常的詳細討論可以參考
        
     
     
    使用checked異常會帶來許多的問題。
     
           checked異常導致了太多的try…catch 代碼
     
                  可能有很多checked異常對開發(fā)人員來說是無法合理地進行處理的，比如 SQLException。而開發(fā)人員卻不得不去進行try…catch。當開發(fā)人員對一個checked異常無法正確的處理時，通常是簡單的把異常打印 出來或者是干脆什么也不干。特別是對于新手來說，過多的checked異常讓他感到無所適從。
     
     
    java 代碼
     
    1.        try{    
    2.        ……    
    3.               Statement s = con.createStatement();    
    4.               ……    
    5.        Catch(SQLException sqlEx){    
    6.               sqlEx.PrintStackTrace();    
    7.    }    
    8.    或者    
    9.        try{    
    10.        ……    
    11.               Statement s = con.createStatement();    
    12.               ……    
    13.        Catch(SQLException sqlEx){    
    14.           //什么也不干    
    15. }    
      
     
    checked異常導致了許多難以理解的代碼產生
     
            當開發(fā)人員必須去捕獲一個自己無法正確處理的checked異常，通常的是重新封裝成一個新的異常后再拋出。這樣做并沒有為程序帶來任何好處。反而使代碼晚難以理解。
     
    就像我們使用JDBC代碼那樣，需要處理非常多的try…catch.，真正有用的代碼被包含在try…catch之內。使得理解這個方法變理困難起來
     
    checked異常導致異常被不斷的封裝成另一個類異常后再拋出
     
     
    java 代碼
     
    1.         public void methodA()throws ExceptionA{    
    2.          …..           
    3.           throw new ExceptionA();         
    4. }    
    5.            
    6. public void methodB()throws ExceptionB{    
    7.    try{    
    8.       methodA();    
    9.       ……    
    10.    }catch(ExceptionA ex){    
    11.    throw new ExceptionB(ex);    
    12.    }    
    13. }    
    14.             
    15.         Public void methodC()throws ExceptinC{    
    16.        try{    
    17.          methodB();    
    18.          …    
    19.        }    
    20.        catch(ExceptionB ex){    
    21.           throw new ExceptionC(ex);    
    22.         }    
    23.     }    
     我們看到異常就這樣一層層無休止的被封裝和重新拋出。
     
     
     
    checked異常導致破壞接口方法
     
       一個接口上的一個方法已被多個類使用，當為這個方法額外添加一個checked異常時，那么所有調用此方法的代碼都需要修改。
     
     
     
    可見上面這些問題都是因為調用者無法正確的處理checked異常時而被迫去捕獲和處理，被迫封裝后再重新拋出。這樣十分不方便，并不能帶來任何好處。在這種情況下通常使用unChecked異常。
     
    chekced異常并不是無一是處，checked異常比傳統(tǒng)編程的錯誤返回值要好用得多。通過編譯器來確保正確的處理異常比通過返回值判斷要好得多。
     
    如果一個異常是致命的，不可恢復的?；蛘哒{用者去捕獲它沒有任何益處，使用unChecked異常。
     
    如果一個異常是可以恢復的，可以被調用者正確處理的，使用checked異常。
     
    在使用unChecked異常時，必須在在方法聲明中詳細的說明該方法可能會拋出的unChekced異常。由調用者自己去決定是否捕獲unChecked異常
     
     
     
    倒底什么時候使用checked異常，什么時候使用unChecked異常？并沒有一個絕對的標準。但是筆者可以給出一些建議
     
    當所有調用者必須處理這個異常，可以讓調用者進行重試操作；或者該異常相當于該方法的第二個返回值。使用checked異常。
     
    這個異常僅是少數(shù)比較高級的調用者才能處理，一般的調用者不能正確的處理。使用unchecked異常。有能力處理的調用者可以進行高級處理，一般調用者干脆就不處理。
     
    這個異常是一個非常嚴重的錯誤，如數(shù)據(jù)庫連接錯誤，文件無法打開等?；蛘哌@些異常是與外部環(huán)境相關的。不是重試可以解決的。使用unchecked異常。因為這種異常一旦出現(xiàn)，調用者根本無法處理。
     
    如果不能確定時，使用unchecked異常。并詳細描述可能會拋出的異常,以讓調用者決定是否進行處理。
     
     
     
    3． 設計一個新的異常類
     
    在設計一個新的異常類時，首先看看是否真正的需要這個異常類。一般情況下盡量不要去設計新的異常類，而是盡量使用java中已經存在的異常類。
     
    如
    java 代碼
    1. IllegalArgumentException, UnsupportedOperationException  
     
     
     
    不管是新的異常是chekced異常還是unChecked異常。我們都必須考慮異常的嵌套問題。
     
     
    java 代碼
     
    1. public void methodA()throws ExceptionA{    
    2.          …..           
    3.           throw new ExceptionA();         
    4. }    
      
     
    方法methodA聲明會拋出ExceptionA.
     
     
     
    public void methodB()throws ExceptionB
     
    methodB聲明會拋出ExceptionB,當在methodB方 法中調用methodA時，ExceptionA是無法處理的,所以ExceptionA應該繼續(xù)往上拋出。一個辦法是把methodB聲明會拋出 ExceptionA.但這樣已經改變了MethodB的方法簽名。一旦改變，則所有調用methodB的方法都要進行改變。
     
    另一個辦法是把ExceptionA封裝成ExceptionB，然后再拋出。如果我們不把ExceptionA封裝在ExceptionB中，就丟失了根異常信息，使得無法跟蹤異常的原始出處。
     
     
    java 代碼
     
    1. public void methodB()throws ExceptionB{    
    2.    try{    
    3.       methodA();    
    4.       ……    
    5.    }catch(ExceptionA ex){    
    6.      throw new ExceptionB(ex);    
    7.    }    
    8. }   
     
     
     
     
       如上面的代碼中，ExceptionB嵌套一個ExceptionA.我們暫且把ExceptionA稱為“起因異常”,因為ExceptionA導致了ExceptionB的產生。這樣才不使異常信息丟失。
     
    所以我們在定義一個新的異常類時，必須提供這樣一個可以包含嵌套異常的構造函數(shù)。并有一個私有成員來保存這個“起因異常”。
     
     
    java 代碼
     
    1. public Class ExceptionB extends Exception{    
    2. private Throwable cause;    
    3.      
    4. public ExceptionB(String msg, Throwable ex){    
    5.  super(msg);    
    6.  this.cause = ex;    
    7. }    
    8.      
    9. public ExceptionB(String msg){    
    10.  super(msg);    
    11. }    
    12.      
    13. public ExceptionB(Throwable ex){    
    14.  this.cause = ex;    
    15. }    
    16. }    
     當然，我們在調用printStackTrace方法時，需要把所有的“起因異常”的信息也同時打印出來。所以我們需要覆寫printStackTrace方法來顯示全部的異常棧跟蹤。包括嵌套異常的棧跟蹤。
     
     
    java 代碼
     
    1. public void printStackTrace(PrintStrean ps){   
    2. if(cause == null){   
    3.  super.printStackTrace(ps);   
    4. }else{   
    5.  ps.println(this);   
    6.  cause.printStackTrace(ps);   
    7. }   
    8. }   
      
     
    一個完整的支持嵌套的checked異常類源碼如下。我們在這里暫且把它叫做NestedException
     
     
     
     
    java 代碼
     
    1. public NestedException extends Exception{   
    2. private Throwable cause;   
    3. public NestedException (String msg){   
    4.  super(msg);   
    5. }   
    6.     
    7. public NestedException(String msg, Throwable ex){   
    8.  super(msg);   
    9.  This.cause = ex;   
    10. }   
    11.     
    12. public Throwable getCause(){   
    13.  return (this.cause == null ? this :this.cause);   
    14. }   
    15.     
    16. public getMessage(){   
    17.  String message = super.getMessage();   
    18.  Throwable cause = getCause();   
    19.    if(cause != null){   
    20.      message = message + “;nested Exception is ” + cause;   
    21.    }   
    22.  return message;   
    23. }   
    24. public void printStackTrace(PrintStream ps){   
    25.  if(getCause == null){   
    26.     super.printStackTrace(ps);   
    27.        
    28.  }else{   
    29.  ps.println(this);   
    30.  getCause().printStackTrace(ps);   
    31.  }   
    32. }   
    33.     
    34. public void printStackTrace(PrintWrite pw){   
    35.  if(getCause() == null){   
    36.     super.printStackTrace(pw);   
    37.  }   
    38.  else{   
    39.     pw.println(this);   
    40.     getCause().printStackTrace(pw);   
    41.  }   
    42. }   
    43. public void printStackTrace(){   
    44.  printStackTrace(System.error);   
    45. }   
    46. }   
    47.     
     同樣要設計一個unChecked異常類也與上面一樣。只是需要繼承RuntimeException。
     
     
     
     
     
    4． 如何記錄異常
     
    作為一個大型的應用系統(tǒng)都需要用日志文件來記錄系統(tǒng)的運行，以便于跟蹤和記錄系統(tǒng)的運行情況。系統(tǒng)發(fā)生的異常理所當然的需要記錄在日志系統(tǒng)中。
     
     
    java 代碼
     
    1. public String getPassword(String userId)throws NoSuchUserException{   
    2. UserInfo user = userDao.queryUserById(userId);   
    3. If(user == null){   
    4.  Logger.info(“找不到該用戶信息,userId=”+userId);   
    5.  throw new NoSuchUserException(“找不到該用戶信息,userId=”+userId);   
    6. }   
    7. else{   
    8.  return user.getPassword();   
    9. }   
    10. }   
    11.     
    12. public void sendUserPassword(String userId)throws Exception {   
    13. UserInfo user = null;   
    14. try{   
    15.   user = getPassword(userId);   
    16.    //……..   
    17.  sendMail();   
    18.  //   
    19. }catch(NoSuchUserException ex)(   
    20.    logger.error(“找不到該用戶信息:”+userId+ex);   
    21.    throw new Exception(ex);   
    22. }   
      
     
    我們注意到，一個錯誤被記錄了兩次.在錯誤的起源位置我們僅是以info級別進行記錄。而在sendUserPassword方法中，我們還把整個異常信息都記錄了。
     
    筆者曾看到很多項目是這樣記錄異常的，不管三七二一，只有遇到異常就把整個異常全部記錄下。如果一個異常被不斷的封裝拋出多次，那么就被記錄了多次。那么異常倒底該在什么地方被記錄？
     
    異常應該在最初產生的位置記錄！
     
     
     
    如果必須捕獲一個無法正確處理的異常，僅僅是把它封裝成另外一種異常往上拋出。不必再次把已經被記錄過的異常再次記錄。
     
     
     
    如果捕獲到一個異常，但是這個異常是可以處理的。則無需要記錄異常
     
     
     
     
    java 代碼
     
    1. public Date getDate(String str){   
    2.  Date applyDate = null;   
    3. SimpleDateFormat format = new SimpleDateFormat(“MM/dd/yyyy”);   
    4. try{   
    5.  applyDate = format.parse(applyDateStr);   
    6. }   
    7. catch(ParseException ex){   
    8.  //乎略，當格式錯誤時，返回null   
    9. }   
    10. return applyDate;   
    11. }   
      
     
    捕獲到一個未記錄過的異?；蛲獠肯到y(tǒng)異常時，應該記錄異常的詳細信息
     
     
    java 代碼
     
    1. try{   
    2.        ……   
    3.         String sql=”select * from userinfo”;   
    4.               Statement s = con.createStatement();   
    5.               ……   
    6.        Catch(SQLException sqlEx){   
    7.           Logger.error(“sql執(zhí)行錯誤”+sql+sqlEx);   
    8. }   
            
     
       究竟在哪里記錄異常信息，及怎么記錄異常信息，可能是見仁見智的問題了。甚至有些系統(tǒng)讓異常類一記錄異常。當產生一個新異常對象時，異常信息就被自動記錄。
     
     
    java 代碼
     
    1.   public class BusinessException extends Exception {   
    2.       private void logTrace() {   
    3.           StringBuffer buffer=new StringBuffer();   
    4.           buffer.append("Business Error in Class: ");   
    5.           buffer.append(getClassName());   
    6.           buffer.append(",method: ");   
    7.           buffer.append(getMethodName());   
    8.           buffer.append(",messsage: ");   
    9.           buffer.append(this.getMessage());   
    10.           logger.error(buffer.toString());   
    11.              
    12. }   
    13. public BusinessException(String s) {   
    14.          super(s);   
    15. race();   
    16. }   
     這似乎看起來是十分美妙的，其實必然導致了異常被重復記錄。同時違反了“類的職責分配原則”，是一種不好的設計。記錄異常不屬于異常類的行為，記錄異常應 該由專門的日志系統(tǒng)去做。并且異常的記錄信息是不斷變化的。我們在記錄異常同應該給更豐富些的信息。以利于我們能夠根據(jù)異常信息找到問題的根源，以解決問 題。
     
    雖然我們對記錄異常討論了很多，過多的強調這些反而使開發(fā)人員更為疑惑，一種好的方式是為系統(tǒng)提供一個異常處理框架。由框架來決定是否記錄異常和怎么記錄異常。而不是由普通程序員去決定。但是了解些還是有益的。
     
    5． J2EE項目中的異常處理
     
    目前,J2ee項目一般都會從邏輯上分為多層。比較經典的分為三層：表示層，業(yè)務層，集成層(包括數(shù)據(jù)庫訪問和外部系統(tǒng)的訪問)。
     
    J2ee項目有著其復雜性，J2ee項目的異常處理需要特別注意幾個問題。
     
    在分布式應用時，我們會遇到許多checked異常。所有RMI調用 （包括EJB遠程接口調用）都會拋出java.rmi.RemoteException;同時RemoteException是checked異常，當我 們在業(yè)務系統(tǒng)中進行遠程調用時，我們都需要編寫大量的代碼來處理這些checked異常。而一旦發(fā)生RemoteException這些checked異 常對系統(tǒng)是非常嚴重的，幾乎沒有任何進行重試的可能。也就是說，當出現(xiàn)RemoteException這些可怕的checked異常，我們沒有任何重試的 必要性，卻必須要編寫大量的try…catch代碼去處理它。一般我們都是在最底層進行RMI調用，只要有一個RMI調用，所有上層的接口都會要求拋出 RemoteException異常。因為我們處理RemoteException的方式就是把它繼續(xù)往上拋。這樣一來就破壞了我們業(yè)務接口。 RemoteException這些J2EE系統(tǒng)級的異常嚴重的影響了我們的業(yè)務接口。我們對系統(tǒng)進行分層的目的就是減少系統(tǒng)之間的依賴，每一層的技術改 變不至于影響到其它層。
     
     
     
     
    java 代碼
     
    1. //   
    2. public class UserSoaImpl implements UserSoa{   
    3.    public UserInfo getUserInfo(String userId)throws RemoteException{   
    4.       //……   
    5. 遠程方法調用.   
    6.       //……   
    7.    }   
    8. }   
    9. public interface UserManager{   
    10.    public UserInfo getUserInfo(Stirng userId)throws RemoteException;   
    11. }   
      
     
    同樣JDBC訪問都會拋出SQLException的checked異常。
     
     
     
    為了避免系統(tǒng)級的checked異常對業(yè)務系統(tǒng)的深度侵入，我們可以為 業(yè)務方法定義一個業(yè)務系統(tǒng)自己的異常。針對像SQLException,RemoteException這些非常嚴重的異常，我們可以新定義一個 unChecked的異常，然后把SQLException，RemoteException封裝成unChecked異常后拋出。
     
    如果這個系統(tǒng)級的異常是要交由上一級調用者處理的，可以新定義一個checked的業(yè)務異常，然后把系統(tǒng)級的異常封存裝成業(yè)務級的異常后再拋出。
     
    一般地，我們需要定義一個unChecked異常，讓集成層接口的所有方法都聲明拋出這unChecked異常。
     
     
    java 代碼
     
    1. public DataAccessException extends RuntimeException{   
    2.  ……   
    3. }   
    4. public interface UserDao{   
    5.  public String getPassword(String userId)throws DataAccessException;   
    6. }   
    7.     
    8. public class UserDaoImpl implements UserDAO{   
    9. public String getPassword(String userId)throws DataAccessException{   
    10.  String sql = “select password from userInfo where userId= ‘”+userId+”’”;   
    11. try{   
    12.     …   
    13.      //JDBC調用   
    14.      s.executeQuery(sql);   
    15.     …   
    16.    }catch(SQLException ex){   
    17.       throw new DataAccessException(“數(shù)據(jù)庫查詢失敗”+sql,ex);   
    18.    }   
    19. }   
    20. }   
      
     
    定義一個checked的業(yè)務異常，讓業(yè)務層的接口的所有方法都聲明拋出Checked異常.
     
     
     
     
    java 代碼
     
    1. public class BusinessException extends Exception{   
    2.  …..   
    3. }   
    4.     
    5. public interface UserManager{   
    6.    public Userinfo copyUserInfo(Userinfo user)throws BusinessException{   
    7.       Userinfo newUser = null;   
    8.       try{   
    9.         newUser = (Userinfo)user.clone();   
    10. }catch(CloneNotSupportedException ex){   
    11.  throw new BusinessException(“不支持clone方法:”+Userinfo.class.getName(),ex);   
    12. }   
    13.  }   
    14. }  
     
     
     
     
    J2ee表示層應該是一個很薄的層，主要的功能為：獲得頁面請求，把頁 面的參數(shù)組裝成POJO對象，調用相應的業(yè)務方法，然后進行頁面轉發(fā)，把相應的業(yè)務數(shù)據(jù)呈現(xiàn)給頁面。表示層需要注意一個問題，表示層需要對數(shù)據(jù)的合法性進 行校驗，比如某些錄入域不能為空，字符長度校驗等。
     
    J2ee從頁面所有傳給后臺的參數(shù)都是字符型的，如果要求輸入數(shù)值或日期類型的參數(shù)時，必須把字符值轉換為相應的數(shù)值或日期值。
     
    如果表示層代碼校驗參數(shù)不合法時，應該返回到原始頁面，讓用戶重新錄入數(shù)據(jù)，并提示相關的錯誤信息。
     
     
     
    通常把一個從頁面?zhèn)鱽淼膮?shù)轉換為數(shù)值，我們可以看到這樣的代碼
     
     
    java 代碼
     
    1. ModeAndView handleRequest(HttpServletRequest request,HttpServletResponse response)throws Exception{   
    2.    String ageStr = request.getParameter(“age”);   
    3.    int age = Integer.parse(ageStr);   
    4.    …………   
    5.     
    6.  String birthDayStr = request.getParameter(“birthDay”);   
    7. SimpleDateFormat format = new SimpleDateFormat(“MM/dd/yyyy”);   
    8. Date birthDay = format.parse(birthDayStr);   
    9.     
    10. }   
      
     
    上面的代碼應該經常見到，但是當用戶從頁面錄入一個不能轉換為整型的字符或一個錯誤的日期值。
     
    Integer.parse()方法被拋出一個 NumberFormatException的unChecked異常。但是這個異常絕對不是一個致命的異常,一般當用戶在頁面的錄入域錄入的值不合法 時，我們應該提示用戶進行重新錄入。但是一旦拋出unchecked異常，就沒有重試的機會了。像這樣的代碼造成大量的異常信息顯示到頁面。使我們的系統(tǒng) 看起來非常的脆弱。
     
    同樣，SimpleDateFormat.parse()方法也會拋出ParseException的unChecked異常。
     
    這種情況我們都應該捕獲這些unChecked異常，并給提示用戶重新錄入。
     
     
    java 代碼
     
    1. ModeAndView handleRequest(HttpServletRequest request,HttpServletResponse response)throws Exception{   
    2.    String ageStr = request.getParameter(“age”);   
    3. String birthDayStr = request.getParameter(“birthDay”);   
    4.    int age = 0;   
    5.  Date birthDay = null;   
    6. try{   
    7. age=Integer.parse(ageStr);   
    8.    }catch(NumberFormatException ex){   
    9.      error.reject(“age”,”不是合法的整數(shù)值”);   
    10.    }   
    11.    …………   
    12.     
    13.  try{   
    14. SimpleDateFormat format = new SimpleDateFormat(“MM/dd/yyyy”);   
    15.  birthDay = format.parse(birthDayStr);   
    16. }catch(ParseException ex){   
    17.  error.reject(“birthDay”,”不是合法的日期，請錄入’MM/dd/yyy’格式的日期”);   
    18. }   
    19.     
    20. }  
     
     
    在表示層一定要弄清楚調用方法的是否會拋出unChecked異常，什么情況下會拋出這些異常，并作出正確的處理。
     
    在表示層調用系統(tǒng)的業(yè)務方法，一般情況下是無需要捕獲異常的。如果調用的業(yè)務方法拋出的異常相當于第二個返回值時，在這種情況下是需要捕獲
    
	
    
	
	
    
		posted on 2011-06-27 16:02 思無 閱讀(400) 評論(0)  編輯  收藏  所屬分類: WEB 、Java 
	
    

    







    
	    
    




    








    

				

    

    




    







    
        
	



主站蜘蛛池模板：
无码欧精品亚洲日韩一区|
美女扒开屁股让男人桶爽免费|
亚洲国产精品18久久久久久|
美女被免费网站91色|
午夜国产精品免费观看|
国产精品xxxx国产喷水亚洲国产精品无码久久一区
|
国产福利电影一区二区三区，亚洲国模精品一区
|
久久亚洲AV成人无码|
a毛片全部免费播放|
亚洲国产精品碰碰|
亚洲精品宾馆在线精品酒店|
国产成人综合亚洲AV第一页|
精品韩国亚洲av无码不卡区|
欧美日韩国产免费一区二区三区|
久久久久亚洲精品无码蜜桃|
午夜视频在线免费观看|
亚洲区小说区激情区图片区|
美女在线视频观看影院免费天天看
|
国产三级在线免费观看|
亚洲AV成人无码天堂|
蜜桃AV无码免费看永久|
亚洲午夜久久影院|
2020久久精品国产免费|
亚洲国产熟亚洲女视频|
99爱在线精品免费观看|
成年大片免费视频播放一级
|
亚洲高清最新av网站|
av无码免费一区二区三区|
亚洲精品偷拍视频免费观看|
亚洲欧洲成人精品香蕉网|
午夜成年女人毛片免费观看|
亚洲国产精品无码久久一区二区
|
国内精自视频品线六区免费|
igao激情在线视频免费|
亚洲欧美日韩中文字幕在线一区|
国产成人免费a在线视频app|
特级av毛片免费观看|
一本色道久久88—综合亚洲精品
|
内射少妇36P亚洲区|
国产亚洲精品不卡在线|
日韩电影免费观看|